Add support for Uniform Buffer to Utility/Renderer

include/Nazara/Renderer/OpenGL.hpp

@@ -132,7 +132,6 @@ namespace Nz
 			static GLenum BufferLock[BufferAccess_Max+1];
 			static GLenum BufferLockRange[BufferAccess_Max+1];
 			static GLenum BufferTarget[BufferType_Max+1];
-			static GLenum BufferTargetBinding[BufferType_Max+1];
 			static GLenum ComponentType[ComponentType_Max+1];
 			static GLenum CubemapFace[6]; // Un cube possède six faces et ça n'est pas près de changer
 			static GLenum FaceFilling[FaceFilling_Max+1];
@@ -161,6 +160,7 @@ NAZARA_RENDERER_API extern PFNGLBEGINCONDITIONALRENDERPROC   glBeginConditionalR
 NAZARA_RENDERER_API extern PFNGLBEGINQUERYPROC               glBeginQuery;
 NAZARA_RENDERER_API extern PFNGLBINDATTRIBLOCATIONPROC       glBindAttribLocation;
 NAZARA_RENDERER_API extern PFNGLBINDBUFFERPROC               glBindBuffer;
+NAZARA_RENDERER_API extern PFNGLBINDBUFFERRANGEPROC          glBindBufferRange;
 NAZARA_RENDERER_API extern PFNGLBINDFRAMEBUFFERPROC          glBindFramebuffer;
 NAZARA_RENDERER_API extern PFNGLBINDFRAGDATALOCATIONPROC     glBindFragDataLocation;
 NAZARA_RENDERER_API extern PFNGLBINDRENDERBUFFERPROC         glBindRenderbuffer;

include/Nazara/Renderer/Renderer.hpp

@@ -25,6 +25,7 @@ namespace Nz
 	class Shader;
 	class Texture;
 	class TextureSampler;
+	class UniformBuffer;
 	class VertexBuffer;
 	class VertexDeclaration;
 
@@ -41,6 +42,8 @@ namespace Nz
 
 			static void BeginCondition(const GpuQuery& query, GpuQueryCondition condition);
 
+			static void BindUniformBuffer(unsigned int bindingPoint, const UniformBuffer* uniformBuffer);
+
 			static void Clear(UInt32 flags = RendererBuffer_Color | RendererBuffer_Depth);
 
 			static void DrawFullscreenQuad();

include/Nazara/Utility/Enums.hpp

@@ -49,8 +49,9 @@ namespace Nz
 	{
 		BufferType_Index,
 		BufferType_Vertex,
+		BufferType_Uniform,
 
-		BufferType_Max = BufferType_Vertex
+		BufferType_Max = BufferType_Uniform
 	};
 
 	enum BufferUsage

include/Nazara/Utility/IndexBuffer.hpp

@@ -38,7 +38,6 @@ namespace Nz
 			inline const BufferRef& GetBuffer() const;
 			inline UInt32 GetEndOffset() const;
 			inline UInt32 GetIndexCount() const;
-			inline DataStorage GetStorage() const;
 			inline UInt32 GetStride() const;
 			inline UInt32 GetStartOffset() const;
 

include/Nazara/Utility/IndexBuffer.inl

@@ -22,11 +22,6 @@ namespace Nz
 		return m_indexCount;
 	}
 
-	inline DataStorage IndexBuffer::GetStorage() const
-	{
-		return DataStorage();
-	}
-
 	inline UInt32 IndexBuffer::GetStride() const
 	{
 		return static_cast<UInt32>((m_largeIndices) ? sizeof(UInt32) : sizeof(UInt16));

include/Nazara/Utility/UniformBuffer.hpp

@@ -0,0 +1,69 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Utility module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_UNIFORMBUFFER_HPP
+#define NAZARA_UNIFORMBUFFER_HPP
+
+#include <Nazara/Prerequisites.hpp>
+#include <Nazara/Core/ObjectRef.hpp>
+#include <Nazara/Core/Signal.hpp>
+#include <Nazara/Utility/Buffer.hpp>
+
+namespace Nz
+{
+	class UniformBuffer;
+
+	using UniformBufferConstRef = ObjectRef<const UniformBuffer>;
+	using UniformBufferRef = ObjectRef<UniformBuffer>;
+
+	class NAZARA_UTILITY_API UniformBuffer : public RefCounted
+	{
+		public:
+			UniformBuffer() = default;
+			UniformBuffer(BufferRef buffer);
+			UniformBuffer(BufferRef buffer, UInt32 offset, UInt32 size);
+			UniformBuffer(UInt32 length, DataStorage storage, BufferUsageFlags usage);
+			UniformBuffer(const UniformBuffer& uniformBuffer);
+			UniformBuffer(UniformBuffer&&) = delete;
+			~UniformBuffer();
+
+			bool Fill(const void* data, UInt32 offset, UInt32 size);
+
+			inline const BufferRef& GetBuffer() const;
+			inline UInt32 GetEndOffset() const;
+			inline UInt32 GetStartOffset() const;
+
+			inline bool IsValid() const;
+
+			void* Map(BufferAccess access, UInt32 offset = 0, UInt32 size = 0);
+			void* Map(BufferAccess access, UInt32 offset = 0, UInt32 size = 0) const;
+
+			void Reset();
+			void Reset(BufferRef buffer);
+			void Reset(BufferRef buffer, UInt32 offset, UInt32 size);
+			void Reset(UInt32 size, DataStorage storage, BufferUsageFlags usage);
+			void Reset(const UniformBuffer& uniformBuffer);
+
+			void Unmap() const;
+
+			UniformBuffer& operator=(const UniformBuffer& uniformBuffer);
+			UniformBuffer& operator=(UniformBuffer&&) = delete;
+
+			template<typename... Args> static UniformBufferRef New(Args&&... args);
+
+			// Signals:
+			NazaraSignal(OnUniformBufferRelease, const UniformBuffer* /*UniformBuffer*/);
+
+		private:
+			BufferRef m_buffer;
+			UInt32 m_endOffset;
+			UInt32 m_startOffset;
+	};
+}
+
+#include <Nazara/Utility/UniformBuffer.inl>
+
+#endif // NAZARA_UNIFORMBUFFER_HPP

include/Nazara/Utility/UniformBuffer.inl

@@ -0,0 +1,41 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Utility module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/Utility/UniformBuffer.hpp>
+#include <memory>
+#include <Nazara/Utility/Debug.hpp>
+
+namespace Nz
+{
+	inline const BufferRef& UniformBuffer::GetBuffer() const
+	{
+		return m_buffer;
+	}
+
+	inline UInt32 UniformBuffer::GetEndOffset() const
+	{
+		return m_endOffset;
+	}
+
+	inline UInt32 UniformBuffer::GetStartOffset() const
+	{
+		return m_startOffset;
+	}
+
+	inline bool UniformBuffer::IsValid() const
+	{
+		return m_buffer.IsValid();
+	}
+
+	template<typename... Args>
+	UniformBufferRef UniformBuffer::New(Args&&... args)
+	{
+		std::unique_ptr<UniformBuffer> object(new UniformBuffer(std::forward<Args>(args)...));
+		object->SetPersistent(false);
+
+		return object.release();
+	}
+}
+
+#include <Nazara/Utility/DebugOff.hpp>

src/Nazara/Renderer/OpenGL.cpp

@@ -885,6 +885,7 @@ namespace Nz
 			glBeginQuery = reinterpret_cast<PFNGLBEGINQUERYPROC>(LoadEntry("glBeginQuery"));
 			glBindAttribLocation = reinterpret_cast<PFNGLBINDATTRIBLOCATIONPROC>(LoadEntry("glBindAttribLocation"));
 			glBindBuffer = reinterpret_cast<PFNGLBINDBUFFERPROC>(LoadEntry("glBindBuffer"));
+			glBindBufferRange = reinterpret_cast<PFNGLBINDBUFFERRANGEPROC>(LoadEntry("glBindBufferRange"));
 			glBindFragDataLocation = reinterpret_cast<PFNGLBINDFRAGDATALOCATIONPROC>(LoadEntry("glBindFragDataLocation"));
 			glBindFramebuffer = reinterpret_cast<PFNGLBINDFRAMEBUFFERPROC>(LoadEntry("glBindFramebuffer"));
 			glBindRenderbuffer = reinterpret_cast<PFNGLBINDRENDERBUFFERPROC>(LoadEntry("glBindRenderbuffer"));
@@ -1896,19 +1897,12 @@ namespace Nz
 
 	GLenum OpenGL::BufferTarget[] =
 	{
-		GL_ELEMENT_ARRAY_BUFFER, // BufferType_Index,
+		GL_ELEMENT_ARRAY_BUFFER, // BufferType_Index
-		GL_ARRAY_BUFFER,		 // BufferType_Vertex
+		GL_ARRAY_BUFFER,         // BufferType_Vertex
+		GL_UNIFORM_BUFFER        // BufferType_Uniform
 	};
 
-	static_assert(BufferType_Max + 1 == 2, "Buffer target array is incomplete");
+	static_assert(BufferType_Max + 1 == 3, "Buffer target array is incomplete");
-
-	GLenum OpenGL::BufferTargetBinding[] =
-	{
-		GL_ELEMENT_ARRAY_BUFFER_BINDING, // BufferType_Index,
-		GL_ARRAY_BUFFER_BINDING,		 // BufferType_Vertex
-	};
-
-	static_assert(BufferType_Max + 1 == 2, "Buffer target binding array is incomplete");
 
 	GLenum OpenGL::ComponentType[] =
 	{
@@ -2117,6 +2111,7 @@ PFNGLBEGINCONDITIONALRENDERPROC   glBeginConditionalRender   = nullptr;
 PFNGLBEGINQUERYPROC               glBeginQuery               = nullptr;
 PFNGLBINDATTRIBLOCATIONPROC       glBindAttribLocation       = nullptr;
 PFNGLBINDBUFFERPROC               glBindBuffer               = nullptr;
+PFNGLBINDBUFFERRANGEPROC          glBindBufferRange          = nullptr;
 PFNGLBINDFRAMEBUFFERPROC          glBindFramebuffer          = nullptr;
 PFNGLBINDFRAGDATALOCATIONPROC     glBindFragDataLocation     = nullptr;
 PFNGLBINDRENDERBUFFERPROC         glBindRenderbuffer         = nullptr;

src/Nazara/Renderer/Renderer.cpp

@@ -29,6 +29,7 @@
 #include <Nazara/Utility/Utility.hpp>
 #include <Nazara/Utility/VertexBuffer.hpp>
 #include <Nazara/Utility/VertexDeclaration.hpp>
+#include <Nazara/Utility/UniformBuffer.hpp>
 #include <Nazara/Platform/Platform.hpp>
 #include <map>
 #include <memory>
@@ -134,6 +135,22 @@ namespace Nz
 		glBeginConditionalRender(query.GetOpenGLID(), OpenGL::QueryCondition[condition]);
 	}
 
+	void Renderer::BindUniformBuffer(unsigned int bindingPoint, const UniformBuffer* uniformBuffer)
+	{
+		NazaraAssert(uniformBuffer && uniformBuffer->IsValid(), "Buffer must be valid");
+
+		const Nz::BufferRef& buffer = uniformBuffer->GetBuffer();
+		if (buffer->GetStorage() != DataStorage_Hardware)
+		{
+			NazaraError("Uniform buffer storage is not hardware");
+			return;
+		}
+
+		HardwareBuffer* hwBuffer = static_cast<HardwareBuffer*>(buffer->GetImpl());
+
+		glBindBufferRange(GL_UNIFORM_BUFFER, bindingPoint, hwBuffer->GetOpenGLID(), uniformBuffer->GetStartOffset(), uniformBuffer->GetEndOffset() - uniformBuffer->GetStartOffset());
+	}
+
 	void Renderer::Clear(UInt32 flags)
 	{
 		#ifdef NAZARA_DEBUG

src/Nazara/Utility/IndexBuffer.cpp

@@ -106,6 +106,7 @@ namespace Nz
 	void IndexBuffer::Reset(bool largeIndices, BufferRef buffer, UInt32 offset, UInt32 size)
 	{
 		NazaraAssert(buffer && buffer->IsValid(), "Invalid buffer");
+		NazaraAssert(buffer->GetType() == BufferType_Index, "Buffer must be an index buffer");
 		NazaraAssert(size > 0, "Invalid size");
 		NazaraAssert(offset + size > buffer->GetSize(), "Virtual buffer exceed buffer bounds");
 

src/Nazara/Utility/UniformBuffer.cpp

@@ -0,0 +1,118 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Utility module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/Utility/UniformBuffer.hpp>
+#include <Nazara/Core/Error.hpp>
+#include <Nazara/Core/ErrorFlags.hpp>
+#include <Nazara/Utility/Config.hpp>
+#include <Nazara/Utility/Debug.hpp>
+
+namespace Nz
+{
+	UniformBuffer::UniformBuffer(BufferRef buffer)
+	{
+		ErrorFlags(ErrorFlag_ThrowException, true);
+		Reset(std::move(buffer));
+	}
+
+	UniformBuffer::UniformBuffer(BufferRef buffer, UInt32 offset, UInt32 size)
+	{
+		ErrorFlags(ErrorFlag_ThrowException, true);
+		Reset(std::move(buffer), offset, size);
+	}
+
+	UniformBuffer::UniformBuffer(UInt32 length, DataStorage storage, BufferUsageFlags usage)
+	{
+		ErrorFlags(ErrorFlag_ThrowException, true);
+		Reset(length, storage, usage);
+	}
+
+	UniformBuffer::UniformBuffer(const UniformBuffer& uniformBuffer) :
+	RefCounted(),
+	m_buffer(uniformBuffer.m_buffer),
+	m_endOffset(uniformBuffer.m_endOffset),
+	m_startOffset(uniformBuffer.m_startOffset)
+	{
+	}
+
+	UniformBuffer::~UniformBuffer()
+	{
+		OnUniformBufferRelease(this);
+	}
+
+	bool UniformBuffer::Fill(const void* data, UInt32 offset, UInt32 size)
+	{
+		NazaraAssert(m_buffer && m_buffer->IsValid(), "Invalid buffer");
+		NazaraAssert(m_startOffset + offset + size <= m_endOffset, "Exceeding virtual buffer size");
+
+		return m_buffer->Fill(data, m_startOffset + offset, size);
+	}
+
+	void* UniformBuffer::Map(BufferAccess access, UInt32 offset, UInt32 size)
+	{
+		NazaraAssert(m_buffer && m_buffer->IsValid(), "Invalid buffer");
+		NazaraAssert(m_startOffset + offset + size <= m_endOffset, "Exceeding virtual buffer size");
+
+		return m_buffer->Map(access, offset, size);
+	}
+
+	void* UniformBuffer::Map(BufferAccess access, UInt32 offset, UInt32 size) const
+	{
+		NazaraAssert(m_buffer && m_buffer->IsValid(), "Invalid buffer");
+		NazaraAssert(m_startOffset + offset + size <= m_endOffset, "Exceeding virtual buffer size");
+
+		return m_buffer->Map(access, offset, size);
+	}
+
+	void UniformBuffer::Reset()
+	{
+		m_buffer.Reset();
+	}
+
+	void UniformBuffer::Reset(BufferRef buffer)
+	{
+		NazaraAssert(buffer && buffer->IsValid(), "Invalid buffer");
+
+		Reset(buffer, 0, buffer->GetSize());
+	}
+
+	void UniformBuffer::Reset(BufferRef buffer, UInt32 offset, UInt32 size)
+	{
+		NazaraAssert(buffer && buffer->IsValid(), "Invalid buffer");
+		NazaraAssert(buffer->GetType() == BufferType_Uniform, "Buffer must be an uniform buffer");
+		NazaraAssert(size > 0, "Invalid size");
+		NazaraAssert(offset + size > buffer->GetSize(), "Virtual buffer exceed buffer bounds");
+
+		m_buffer = buffer;
+		m_endOffset = offset + size;
+		m_startOffset = offset;
+	}
+
+	void UniformBuffer::Reset(UInt32 size, DataStorage storage, BufferUsageFlags usage)
+	{
+		m_endOffset = size;
+		m_startOffset = 0;
+
+		m_buffer = Buffer::New(BufferType_Uniform, m_endOffset, storage, usage);
+	}
+
+	void UniformBuffer::Reset(const UniformBuffer& UniformBuffer)
+	{
+		m_buffer = UniformBuffer.m_buffer;
+		m_endOffset = UniformBuffer.m_endOffset;
+		m_startOffset = UniformBuffer.m_startOffset;
+	}
+
+	void UniformBuffer::Unmap() const
+	{
+		m_buffer->Unmap();
+	}
+
+	UniformBuffer& UniformBuffer::operator=(const UniformBuffer& uniformBuffer)
+	{
+		Reset(uniformBuffer);
+
+		return *this;
+	}
+}

src/Nazara/Utility/VertexBuffer.cpp

@@ -98,6 +98,7 @@ namespace Nz
 	void VertexBuffer::Reset(VertexDeclarationConstRef vertexDeclaration, BufferRef buffer)
 	{
 		NazaraAssert(buffer && buffer->IsValid(), "Invalid buffer");
+		NazaraAssert(buffer->GetType() == BufferType_Vertex, "Buffer must be a vertex buffer");
 
 		UInt32 size = buffer->GetSize();
 		Reset(std::move(vertexDeclaration), std::move(buffer), 0, size);