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

Begin work on RenderPipeline

Browse Source
This commit is contained in:
Lynix
2020-02-25 22:56:08 +01:00
parent 7bbba14ba0
commit c05ea4095a
22 changed files with 284 additions and 173 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
include/Nazara/Renderer.hpp
View File

@@ -30,21 +30,17 @@
#define NAZARA_GLOBAL_RENDERER_HPP
#include <Nazara/Renderer/Config.hpp>
#include <Nazara/Renderer/ContextParameters.hpp>
#include <Nazara/Renderer/DebugDrawer.hpp>
#include <Nazara/Renderer/Enums.hpp>
#include <Nazara/Renderer/GlslWriter.hpp>
#include <Nazara/Renderer/OpenGL.hpp>
#include <Nazara/Renderer/RenderBuffer.hpp>
#include <Nazara/Renderer/RenderDeviceInfo.hpp>
#include <Nazara/Renderer/RenderDevice.hpp>
#include <Nazara/Renderer/RenderDeviceInfo.hpp>
#include <Nazara/Renderer/Renderer.hpp>
#include <Nazara/Renderer/RendererImpl.hpp>
#include <Nazara/Renderer/RenderPipeline.hpp>
#include <Nazara/Renderer/RenderStates.hpp>
#include <Nazara/Renderer/RenderSurface.hpp>
#include <Nazara/Renderer/RenderTarget.hpp>
#include <Nazara/Renderer/RenderTexture.hpp>
#include <Nazara/Renderer/RenderWindow.hpp>
#include <Nazara/Renderer/RenderWindowImpl.hpp>
#include <Nazara/Renderer/RenderWindowParameters.hpp>
@@ -53,7 +49,5 @@
#include <Nazara/Renderer/ShaderBuilder.hpp>
#include <Nazara/Renderer/ShaderWriter.hpp>
#include <Nazara/Renderer/Texture.hpp>
#include <Nazara/Renderer/UberShader.hpp>
#include <Nazara/Renderer/UberShaderPreprocessor.hpp>
#endif // NAZARA_GLOBAL_RENDERER_HPP

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

@@ -9,6 +9,7 @@
#include <Nazara/Prerequisites.hpp>
#include <Nazara/Renderer/Config.hpp>
#include <Nazara/Renderer/RenderPipeline.hpp>
#include <Nazara/Utility/AbstractBuffer.hpp>
#include <memory>
@@ -23,6 +24,7 @@ namespace Nz
virtual ~RenderDevice();
virtual std::unique_ptr<AbstractBuffer> InstantiateBuffer(Buffer* parent, BufferType type) = 0;
virtual std::unique_ptr<RenderPipeline> InstantiateRenderPipeline(RenderPipelineInfo pipelineInfo) = 0;
};
}

21
include/Nazara/Renderer/RenderPipeline.hpp
View File

@@ -9,31 +9,20 @@
#include <Nazara/Utility/Enums.hpp>
#include <Nazara/Renderer/RenderStates.hpp>
#include <Nazara/Renderer/Shader.hpp>
//#include <Nazara/Renderer/Shader.hpp>
namespace Nz
{
struct RenderPipelineInfo : RenderStates
{
ShaderConstRef shader;
/*ShaderConstRef shader;*/
};
class RenderPipeline
class NAZARA_RENDERER_API RenderPipeline
{
public:
inline RenderPipeline();
inline ~RenderPipeline();
inline bool Create(const RenderPipelineInfo& pipelineInfo);
inline void Destroy();
inline const RenderPipelineInfo& GetInfo() const;
inline bool IsValid() const;
private:
RenderPipelineInfo m_pipelineInfo;
bool m_valid;
RenderPipeline() = default;
virtual ~RenderPipeline();
};
}

35
include/Nazara/Renderer/RenderPipeline.inl
View File

@@ -8,41 +8,6 @@
namespace Nz
{
inline RenderPipeline::RenderPipeline() :
m_valid(false)
{
}
inline RenderPipeline::~RenderPipeline()
{
}
inline bool RenderPipeline::Create(const RenderPipelineInfo& pipelineInfo)
{
NazaraAssert(pipelineInfo.shader, "Invalid shader");
m_pipelineInfo = pipelineInfo;
m_valid = true;
return true;
}
inline void RenderPipeline::Destroy()
{
m_valid = false;
}
inline const RenderPipelineInfo& RenderPipeline::GetInfo() const
{
NazaraAssert(m_valid, "Invalid pipeline info");
return m_pipelineInfo;
}
inline bool RenderPipeline::IsValid() const
{
return m_valid;
}
}
#include <Nazara/Renderer/DebugOff.hpp>

49
include/Nazara/Renderer/RenderStates.hpp
View File

@@ -18,49 +18,18 @@ namespace Nz
BlendFunc srcBlend = BlendFunc_One;
FaceFilling faceFilling = FaceFilling_Fill;
FaceSide cullingSide = FaceSide_Back;
RendererComparison depthFunc = RendererComparison_Less;
RendererComparison depthCompare = RendererComparison_Less;
struct
{
RendererComparison back = RendererComparison_Always;
RendererComparison front = RendererComparison_Always;
} stencilCompare;
struct
{
UInt32 back = 0xFFFFFFFF;
UInt32 front = 0xFFFFFFFF;
} stencilCompareMask;
struct
{
StencilOperation back = StencilOperation_Keep;
StencilOperation front = StencilOperation_Keep;
} stencilDepthFail;
struct
{
StencilOperation back = StencilOperation_Keep;
StencilOperation front = StencilOperation_Keep;
} stencilFail;
struct
{
StencilOperation back = StencilOperation_Keep;
StencilOperation front = StencilOperation_Keep;
} stencilPass;
struct
{
UInt32 back = 0U;
UInt32 front = 0U;
} stencilReference;
struct
{
UInt32 back = 0xFFFFFFFF;
UInt32 front = 0xFFFFFFFF;
} stencilWriteMask;
RendererComparison compare = RendererComparison_Always;
StencilOperation depthFail = StencilOperation_Keep;
StencilOperation fail = StencilOperation_Keep;
StencilOperation pass = StencilOperation_Keep;
UInt32 compareMask = 0xFFFFFFFF;
UInt32 reference = 0;
UInt32 writeMask = 0xFFFFFFFF;
} stencilBack, stencilFront;
bool blending = false;
bool colorWrite = true;

64
include/Nazara/Renderer/RenderStates.inl
View File

@@ -35,27 +35,28 @@ namespace Nz
}
if (lhs.depthBuffer)
NazaraRenderStateMember(depthFunc);
NazaraRenderStateMember(depthCompare);
if (lhs.faceCulling)
NazaraRenderStateMember(cullingSide);
if (lhs.stencilTest)
{
NazaraRenderStateMember(stencilCompare.back);
NazaraRenderStateMember(stencilCompare.front);
NazaraRenderStateMember(stencilCompareMask.back);
NazaraRenderStateMember(stencilCompareMask.front);
NazaraRenderStateMember(stencilDepthFail.back);
NazaraRenderStateMember(stencilDepthFail.front);
NazaraRenderStateMember(stencilFail.back);
NazaraRenderStateMember(stencilFail.front);
NazaraRenderStateMember(stencilPass.back);
NazaraRenderStateMember(stencilPass.front);
NazaraRenderStateMember(stencilReference.back);
NazaraRenderStateMember(stencilReference.front);
NazaraRenderStateMember(stencilWriteMask.back);
NazaraRenderStateMember(stencilWriteMask.front);
NazaraRenderStateMember(stencilBack.compare);
NazaraRenderStateMember(stencilBack.compareMask);
NazaraRenderStateMember(stencilBack.depthFail);
NazaraRenderStateMember(stencilBack.fail);
NazaraRenderStateMember(stencilBack.pass);
NazaraRenderStateMember(stencilBack.reference);
NazaraRenderStateMember(stencilBack.writeMask);
NazaraRenderStateMember(stencilFront.compare);
NazaraRenderStateMember(stencilFront.compareMask);
NazaraRenderStateMember(stencilFront.depthFail);
NazaraRenderStateMember(stencilFront.fail);
NazaraRenderStateMember(stencilFront.pass);
NazaraRenderStateMember(stencilFront.reference);
NazaraRenderStateMember(stencilFront.writeMask);
}
NazaraRenderStateFloatMember(lineWidth, 0.001f);
@@ -85,6 +86,7 @@ namespace std
#define NazaraRenderStateBoolDep(dependency, member) parameterHash |= ((pipelineInfo.dependency && pipelineInfo.member) ? 1U : 0U) << (parameterIndex++)
#define NazaraRenderStateEnum(member) Nz::HashCombine(seed, static_cast<Nz::UInt8>(pipelineInfo.member))
#define NazaraRenderStateFloat(member, maxDiff) Nz::HashCombine(seed, std::floor(pipelineInfo.member / maxDiff) * maxDiff)
#define NazaraRenderStateUInt32(member) Nz::HashCombine(seed, pipelineInfo.member)
NazaraRenderStateBool(blending);
NazaraRenderStateBool(colorWrite);
@@ -104,27 +106,28 @@ namespace std
}
if (pipelineInfo.depthBuffer)
NazaraRenderStateEnum(depthFunc);
NazaraRenderStateEnum(depthCompare);
if (pipelineInfo.faceCulling)
NazaraRenderStateEnum(cullingSide);
if (pipelineInfo.stencilTest)
{
NazaraRenderStateEnum(stencilCompare.back);
NazaraRenderStateEnum(stencilCompare.front);
NazaraRenderStateEnum(stencilCompareMask.back);
NazaraRenderStateEnum(stencilCompareMask.front);
NazaraRenderStateEnum(stencilDepthFail.back);
NazaraRenderStateEnum(stencilDepthFail.front);
NazaraRenderStateEnum(stencilFail.back);
NazaraRenderStateEnum(stencilFail.front);
NazaraRenderStateEnum(stencilPass.back);
NazaraRenderStateEnum(stencilPass.front);
NazaraRenderStateEnum(stencilReference.back);
NazaraRenderStateEnum(stencilReference.front);
NazaraRenderStateEnum(stencilWriteMask.back);
NazaraRenderStateEnum(stencilWriteMask.front);
NazaraRenderStateEnum(stencilBack.compare);
NazaraRenderStateUInt32(stencilBack.compareMask);
NazaraRenderStateEnum(stencilBack.depthFail);
NazaraRenderStateEnum(stencilBack.fail);
NazaraRenderStateEnum(stencilBack.pass);
NazaraRenderStateUInt32(stencilBack.reference);
NazaraRenderStateUInt32(stencilBack.writeMask);
NazaraRenderStateEnum(stencilFront.compare);
NazaraRenderStateUInt32(stencilFront.compareMask);
NazaraRenderStateEnum(stencilFront.depthFail);
NazaraRenderStateEnum(stencilFront.fail);
NazaraRenderStateEnum(stencilFront.pass);
NazaraRenderStateUInt32(stencilFront.reference);
NazaraRenderStateUInt32(stencilFront.writeMask);
}
NazaraRenderStateFloat(lineWidth, 0.001f);
@@ -134,6 +137,7 @@ namespace std
#undef NazaraRenderStateBoolDep
#undef NazaraRenderStateEnum
#undef NazaraRenderStateFloat
#undef NazaraRenderStateUInt32
Nz::HashCombine(seed, parameterHash);

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

@@ -19,6 +19,8 @@
namespace Nz
{
class RenderDevice;
class NAZARA_RENDERER_API RenderWindow : public Window
{
public:
@@ -34,6 +36,7 @@ namespace Nz
void EnableVerticalSync(bool enabled);
inline RenderWindowImpl* GetImpl();
std::shared_ptr<RenderDevice> GetRenderDevice();
inline bool IsValid() const;

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

@@ -11,6 +11,7 @@
#include <Nazara/Math/Vector2.hpp>
#include <Nazara/Platform/WindowHandle.hpp>
#include <Nazara/Renderer/Config.hpp>
#include <Nazara/Renderer/RenderDevice.hpp>
#include <Nazara/Renderer/RenderWindowParameters.hpp>
#include <vector>
@@ -26,6 +27,8 @@ namespace Nz
virtual ~RenderWindowImpl();
virtual bool Create(RendererImpl* renderer, RenderSurface* surface, const Vector2ui& size, const RenderWindowParameters& parameters) = 0;
virtual std::shared_ptr<RenderDevice> GetRenderDevice() = 0;
};
}

1
include/Nazara/Utility.hpp
View File

@@ -63,6 +63,7 @@
#include <Nazara/Utility/StaticMesh.hpp>
#include <Nazara/Utility/SubMesh.hpp>
#include <Nazara/Utility/TriangleIterator.hpp>
#include <Nazara/Utility/UniformBuffer.hpp>
#include <Nazara/Utility/Utility.hpp>
#include <Nazara/Utility/VertexBuffer.hpp>
#include <Nazara/Utility/VertexDeclaration.hpp>

1
include/Nazara/VulkanRenderer.hpp
View File

@@ -37,6 +37,7 @@
#include <Nazara/VulkanRenderer/VulkanBuffer.hpp>
#include <Nazara/VulkanRenderer/VulkanDevice.hpp>
#include <Nazara/VulkanRenderer/VulkanRenderer.hpp>
#include <Nazara/VulkanRenderer/VulkanRenderPipeline.hpp>
#include <Nazara/VulkanRenderer/VulkanSurface.hpp>
#include <Nazara/VulkanRenderer/Wrapper.hpp>

5
include/Nazara/VulkanRenderer/Utils.hpp
View File

@@ -9,11 +9,16 @@
#include <Nazara/Prerequisites.hpp>
#include <Nazara/Core/String.hpp>
#include <Nazara/Utility/Enums.hpp>
#include <Nazara/VulkanRenderer/Wrapper/Loader.hpp>
namespace Nz
{
inline VkCompareOp ToVulkan(RendererComparison comparison);
inline VkStencilOp ToVulkan(StencilOperation stencilOp);
NAZARA_VULKANRENDERER_API String TranslateVulkanError(VkResult code);
}
#include <Nazara/VulkanRenderer/Utils.inl>
#endif // NAZARA_UTILS_VULKAN_HPP

49
include/Nazara/VulkanRenderer/Utils.inl Normal file
View File

@@ -0,0 +1,49 @@
// Copyright (C) 2016 Jérôme Leclercq
// This file is part of the "Nazara Engine - Vulkan Renderer"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/VulkanRenderer/Utils.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/String.hpp>
#include <Nazara/VulkanRenderer/Debug.hpp>
namespace Nz
{
inline VkCompareOp ToVulkan(RendererComparison comparison)
{
switch (comparison)
{
case RendererComparison_Never: return VK_COMPARE_OP_NEVER;
case RendererComparison_Less: return VK_COMPARE_OP_LESS;
case RendererComparison_Equal: return VK_COMPARE_OP_EQUAL;
case RendererComparison_LessOrEqual: return VK_COMPARE_OP_LESS_OR_EQUAL;
case RendererComparison_Greater: return VK_COMPARE_OP_GREATER;
case RendererComparison_NotEqual: return VK_COMPARE_OP_NOT_EQUAL;
case RendererComparison_GreaterOrEqual: return VK_COMPARE_OP_GREATER_OR_EQUAL;
case RendererComparison_Always: return VK_COMPARE_OP_ALWAYS;
}
NazaraError("Unhandled RendererComparison 0x" + String::Number(comparison, 16));
return VK_COMPARE_OP_NEVER;
}
VkStencilOp ToVulkan(StencilOperation stencilOp)
{
switch (stencilOp)
{
case StencilOperation_Decrement: return VK_STENCIL_OP_DECREMENT_AND_CLAMP;
case StencilOperation_DecrementNoClamp: return VK_STENCIL_OP_DECREMENT_AND_WRAP;
case StencilOperation_Increment: return VK_STENCIL_OP_INCREMENT_AND_CLAMP;
case StencilOperation_IncrementNoClamp: return VK_STENCIL_OP_INCREMENT_AND_WRAP;
case StencilOperation_Invert: return VK_STENCIL_OP_INVERT;
case StencilOperation_Keep: return VK_STENCIL_OP_KEEP;
case StencilOperation_Replace: return VK_STENCIL_OP_REPLACE;
case StencilOperation_Zero: return VK_STENCIL_OP_ZERO;
}
NazaraError("Unhandled RendererComparison 0x" + String::Number(stencilOp, 16));
return VK_STENCIL_OP_KEEP;
}
}
#include <Nazara/VulkanRenderer/DebugOff.hpp>

2
include/Nazara/VulkanRenderer/VkRenderWindow.hpp
View File

@@ -51,6 +51,8 @@ namespace Nz
inline UInt32 GetPresentableFamilyQueue() const;
inline const Vk::Swapchain& GetSwapchain() const;
std::shared_ptr<RenderDevice> GetRenderDevice() override;
void Present(UInt32 imageIndex) override;
VkRenderWindow& operator=(const VkRenderWindow&) = delete;

5
include/Nazara/VulkanRenderer/VkRenderWindow.inl
View File

@@ -37,6 +37,11 @@ namespace Nz
return m_swapchain;
}
inline std::shared_ptr<RenderDevice> Nz::VkRenderWindow::GetRenderDevice()
{
return m_device;
}
inline void VkRenderWindow::Present(UInt32 imageIndex)
{
NazaraAssert(imageIndex < m_frameBuffers.size(), "Invalid image index");

1
include/Nazara/VulkanRenderer/VulkanDevice.hpp
View File

@@ -24,6 +24,7 @@ namespace Nz
~VulkanDevice();
std::unique_ptr<AbstractBuffer> InstantiateBuffer(Buffer* parent, BufferType type) override;
std::unique_ptr<RenderPipeline> InstantiateRenderPipeline(RenderPipelineInfo pipelineInfo) override;
VulkanDevice& operator=(const VulkanDevice&) = delete;
VulkanDevice& operator=(VulkanDevice&&) = delete; ///TODO?

34
include/Nazara/VulkanRenderer/VulkanRenderPipeline.hpp Normal file
View File

@@ -0,0 +1,34 @@
// Copyright (C) 2016 Jérôme Leclercq
// This file is part of the "Nazara Engine - Renderer module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once
#ifndef NAZARA_VULKANRENDERER_VULKANRENDERPIPELINE_HPP
#define NAZARA_VULKANRENDERER_VULKANRENDERPIPELINE_HPP
#include <Nazara/Prerequisites.hpp>
#include <Nazara/Renderer/RenderPipeline.hpp>
#include <Nazara/VulkanRenderer/Config.hpp>
#include <Nazara/VulkanRenderer/Wrapper/Device.hpp>
namespace Nz
{
class NAZARA_VULKANRENDERER_API VulkanRenderPipeline : public RenderPipeline
{
public:
VulkanRenderPipeline(Vk::DeviceHandle device, RenderPipelineInfo pipelineInfo);
~VulkanRenderPipeline() = default;
static VkPipelineDepthStencilStateCreateInfo BuildDepthStencilInfo(const RenderPipelineInfo& pipelineInfo);
static VkStencilOpState BuildStencilOp(const RenderPipelineInfo& pipelineInfo, bool front);
private:
Vk::DeviceHandle m_device;
RenderPipelineInfo m_pipelineInfo;
};
}
#include <Nazara/VulkanRenderer/VulkanRenderPipeline.inl>
#endif // NAZARA_VULKANRENDERER_VULKANRENDERPIPELINE_HPP

12
include/Nazara/VulkanRenderer/VulkanRenderPipeline.inl Normal file
View File

@@ -0,0 +1,12 @@
// Copyright (C) 2016 Jérôme Leclercq
// This file is part of the "Nazara Engine - Vulkan Renderer"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/VulkanRenderer/VulkanRenderPipeline.hpp>
#include <Nazara/VulkanRenderer/Debug.hpp>
namespace Nz
{
}
#include <Nazara/VulkanRenderer/DebugOff.hpp>