Add buffer support

src/Nazara/Renderer/RenderBuffer.cpp

@@ -3,18 +3,87 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Renderer/RenderBuffer.hpp>
+#include <Nazara/Core/Error.hpp>
 #include <Nazara/Renderer/Debug.hpp>
 
 namespace Nz
 {
+	bool RenderBuffer::Fill(const void* data, UInt32 offset, UInt32 size)
+	{
+		if (m_softwareBuffer.Fill(data, offset, size))
+		{
+			for (auto& bufferPair : m_hardwareBuffers)
+				bufferPair.second.synchronized = false;
+
+			return true;
+		}
+		else
+			return false;
+	}
+
 	bool RenderBuffer::Initialize(UInt32 size, BufferUsageFlags usage)
 	{
+		m_size = size;
 		m_softwareBuffer.Initialize(size, usage);
+
 		return true;
 	}
 
-	DataStorage Nz::RenderBuffer::GetStorage() const
+	AbstractBuffer* RenderBuffer::GetHardwareBuffer(RenderDevice* device)
+	{
+		auto it = m_hardwareBuffers.find(device);
+		if (it == m_hardwareBuffers.end())
+			return nullptr;
+
+		return it->second.buffer.get();
+	}
+
+	DataStorage RenderBuffer::GetStorage() const
 	{
 		return DataStorage::DataStorage_Hardware;
 	}
+
+	void* RenderBuffer::Map(BufferAccess access, UInt32 offset, UInt32 size)
+	{
+		if (void* ptr = m_softwareBuffer.Map(access, offset, size))
+		{
+			if (access != BufferAccess_ReadOnly)
+			{
+				for (auto& bufferPair : m_hardwareBuffers)
+					bufferPair.second.synchronized = false;
+			}
+
+			return ptr;
+		}
+		else
+			return nullptr;
+	}
+
+	bool RenderBuffer::Unmap()
+	{
+		return m_softwareBuffer.Unmap();
+	}
+
+	bool RenderBuffer::Synchronize(RenderDevice* device)
+	{
+		auto it = m_hardwareBuffers.find(device);
+		if (it == m_hardwareBuffers.end())
+		{
+			HardwareBuffer hwBuffer;
+			hwBuffer.buffer = device->InstantiateBuffer(m_parent, m_type);
+			if (!hwBuffer.buffer->Initialize(m_size, m_usage))
+			{
+				NazaraError("Failed to initialize hardware buffer");
+				return false;
+			}
+
+			it = m_hardwareBuffers.emplace(device, std::move(hwBuffer)).first;
+		}
+
+		HardwareBuffer& hwBuffer = it->second;
+		if (hwBuffer.synchronized)
+			return true;
+
+		return hwBuffer.buffer->Fill(m_softwareBuffer.GetData(), 0, m_size);
+	}
 }

src/Nazara/Renderer/RenderDevice.cpp

@@ -2,10 +2,10 @@
 // This file is part of the "Nazara Engine - Renderer module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
-#include <Nazara/Renderer/RenderDeviceInstance.hpp>
+#include <Nazara/Renderer/RenderDevice.hpp>
 #include <Nazara/Renderer/Debug.hpp>
 
 namespace Nz
 {
-	RenderDeviceInstance::~RenderDeviceInstance() = default;
+	RenderDevice::~RenderDevice() = default;
 }

src/Nazara/Renderer/RenderWindow.cpp

@@ -29,15 +29,16 @@ namespace Nz
 
 	bool RenderWindow::OnWindowCreated()
 	{
-		auto surface = Renderer::GetRendererImpl()->CreateRenderSurfaceImpl();
+		RendererImpl* rendererImpl = Renderer::GetRendererImpl();
+		auto surface = rendererImpl->CreateRenderSurfaceImpl();
 		if (!surface->Create(GetHandle()))
 		{
 			NazaraError("Failed to create render surface: " + Error::GetLastError());
 			return false;
 		}
 
-		auto impl = Renderer::GetRendererImpl()->CreateRenderWindowImpl();
-		if (!impl->Create(surface.get(), GetSize(), m_parameters))
+		auto impl = rendererImpl->CreateRenderWindowImpl();
+		if (!impl->Create(rendererImpl, surface.get(), GetSize(), m_parameters))
 		{
 			NazaraError("Failed to create render window implementation: " + Error::GetLastError());
 			return false;

src/Nazara/Renderer/Renderer.cpp

@@ -8,6 +8,7 @@
 #include <Nazara/Core/DynLib.hpp>
 #include <Nazara/Core/Log.hpp>
 #include <Nazara/Platform/Platform.hpp>
+#include <Nazara/Renderer/RenderBuffer.hpp>
 #include <Nazara/Utility/AbstractBuffer.hpp>
 #include <Nazara/Utility/Buffer.hpp>
 #include <Nazara/Utility/Utility.hpp>
@@ -135,9 +136,9 @@ namespace Nz
 		Utility::Uninitialize();
 	}
 
-	AbstractBuffer* Renderer::CreateHardwareBufferImpl(Buffer * parent, BufferType type)
+	AbstractBuffer* Renderer::CreateHardwareBufferImpl(Buffer* parent, BufferType type)
 	{
-		return s_rendererImpl->CreateHardwareBufferImpl(parent, type).release();
+		return new RenderBuffer(parent, type);
 	}
 
 	std::unique_ptr<RendererImpl> Renderer::s_rendererImpl;