sid
/
NazaraEngine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add support for Uniform Buffer to Utility/Renderer

This commit is contained in:
Lynix 2018-06-06 20:18:42 +02:00
parent 056bd0efdd
commit e4eae425b2
12 changed files with 259 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/Nazara/Renderer/OpenGL.hpp
View File

@ -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;

3
include/Nazara/Renderer/Renderer.hpp
View File

@ -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();

3
include/Nazara/Utility/Enums.hpp
View File

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

1
include/Nazara/Utility/IndexBuffer.hpp
View File

@ -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;

5
include/Nazara/Utility/IndexBuffer.inl
View File

@ -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));

69
include/Nazara/Utility/UniformBuffer.hpp Normal file
View File

@ -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

41
include/Nazara/Utility/UniformBuffer.inl Normal file
View File

@ -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>

17
src/Nazara/Renderer/OpenGL.cpp
View File

@ -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_ARRAY_BUFFER, // BufferType_Vertex
GL_ELEMENT_ARRAY_BUFFER, // BufferType_Index
GL_ARRAY_BUFFER, // BufferType_Vertex
GL_UNIFORM_BUFFER // BufferType_Uniform
};
static_assert(BufferType_Max + 1 == 2, "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");
static_assert(BufferType_Max + 1 == 3, "Buffer target 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;

17
src/Nazara/Renderer/Renderer.cpp
View File

@ -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

1
src/Nazara/Utility/IndexBuffer.cpp
View File

@ -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");

118
src/Nazara/Utility/UniformBuffer.cpp Normal file
View File

@ -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;
}
}

1
src/Nazara/Utility/VertexBuffer.cpp
View File

@ -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);