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

Begin work on RenderPipeline

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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

86
examples/VulkanTest/main.cpp
View File

@ -122,6 +122,8 @@ int main()
return __LINE__;
}
std::shared_ptr<Nz::RenderDevice> device = window.GetRenderDevice();
Nz::VkRenderWindow& vulkanWindow = *static_cast<Nz::VkRenderWindow*>(window.GetImpl());
/*VkPhysicalDeviceFeatures features;
@ -136,17 +138,17 @@ int main()
std::vector<VkQueueFamilyProperties> queues;
instance.GetPhysicalDeviceQueueFamilyProperties(physDevice, &queues);*/
Nz::VulkanDevice& device = vulkanWindow.GetDevice();
Nz::VulkanDevice& vulkanDevice = vulkanWindow.GetDevice();
Nz::Vk::ShaderModule vertexShader;
if (!vertexShader.Create(device.shared_from_this(), reinterpret_cast<Nz::UInt32*>(vertexShaderCode.data()), vertexShaderCode.size()))
if (!vertexShader.Create(vulkanDevice.shared_from_this(), reinterpret_cast<Nz::UInt32*>(vertexShaderCode.data()), vertexShaderCode.size()))
{
NazaraError("Failed to create vertex shader");
return __LINE__;
}
Nz::Vk::ShaderModule fragmentShader;
if (!fragmentShader.Create(device.shared_from_this(), reinterpret_cast<Nz::UInt32*>(fragmentShaderCode.data()), fragmentShaderCode.size()))
if (!fragmentShader.Create(vulkanDevice.shared_from_this(), reinterpret_cast<Nz::UInt32*>(fragmentShaderCode.data()), fragmentShaderCode.size()))
{
NazaraError("Failed to create fragment shader");
return __LINE__;
@ -169,25 +171,25 @@ int main()
std::cout << "Index count: " << drfreakIB->GetIndexCount() << std::endl;
Nz::RenderBuffer* renderBufferIB = static_cast<Nz::RenderBuffer*>(drfreakIB->GetBuffer()->GetImpl());
if (!renderBufferIB->Synchronize(&device))
if (!renderBufferIB->Synchronize(&vulkanDevice))
{
NazaraError("Failed to synchronize render buffer");
return __LINE__;
}
Nz::VulkanBuffer* indexBufferImpl = static_cast<Nz::VulkanBuffer*>(renderBufferIB->GetHardwareBuffer(&device));
Nz::VulkanBuffer* indexBufferImpl = static_cast<Nz::VulkanBuffer*>(renderBufferIB->GetHardwareBuffer(&vulkanDevice));
// Index buffer
std::cout << "Vertex count: " << drfreakVB->GetVertexCount() << std::endl;
Nz::RenderBuffer* renderBufferVB = static_cast<Nz::RenderBuffer*>(drfreakVB->GetBuffer()->GetImpl());
if (!renderBufferVB->Synchronize(&device))
if (!renderBufferVB->Synchronize(&vulkanDevice))
{
NazaraError("Failed to synchronize render buffer");
return __LINE__;
}
Nz::VulkanBuffer* vertexBufferImpl = static_cast<Nz::VulkanBuffer*>(renderBufferVB->GetHardwareBuffer(&device));
Nz::VulkanBuffer* vertexBufferImpl = static_cast<Nz::VulkanBuffer*>(renderBufferVB->GetHardwareBuffer(&vulkanDevice));
struct
{
@ -205,7 +207,7 @@ int main()
Nz::UInt32 uniformSize = sizeof(ubo);
Nz::Vk::Buffer uniformBuffer;
if (!uniformBuffer.Create(device.shared_from_this(), 0, uniformSize, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT))
if (!uniformBuffer.Create(vulkanDevice.shared_from_this(), 0, uniformSize, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT))
{
NazaraError("Failed to create vertex buffer");
return __LINE__;
@ -214,7 +216,7 @@ int main()
VkMemoryRequirements memRequirement = uniformBuffer.GetMemoryRequirements();
Nz::Vk::DeviceMemory uniformBufferMemory;
if (!uniformBufferMemory.Create(device.shared_from_this(), memRequirement.size, memRequirement.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT))
if (!uniformBufferMemory.Create(vulkanDevice.shared_from_this(), memRequirement.size, memRequirement.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT))
{
NazaraError("Failed to allocate vertex buffer memory");
return __LINE__;
@ -245,7 +247,7 @@ int main()
layoutBinding.pImmutableSamplers = nullptr;
Nz::Vk::DescriptorSetLayout descriptorLayout;
if (!descriptorLayout.Create(device.shared_from_this(), layoutBinding))
if (!descriptorLayout.Create(vulkanDevice.shared_from_this(), layoutBinding))
{
NazaraError("Failed to create descriptor set layout");
return __LINE__;
@ -256,7 +258,7 @@ int main()
poolSize.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
Nz::Vk::DescriptorPool descriptorPool;
if (!descriptorPool.Create(device.shared_from_this(), 1, poolSize, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT))
if (!descriptorPool.Create(vulkanDevice.shared_from_this(), 1, poolSize, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT))
{
NazaraError("Failed to create descriptor pool");
return __LINE__;
@ -266,6 +268,28 @@ int main()
descriptorSet.WriteUniformDescriptor(0, uniformBuffer, 0, uniformSize);
Nz::RenderPipelineInfo pipelineInfo;
pipelineInfo.depthBuffer = true;
pipelineInfo.depthCompare = Nz::RendererComparison_Equal;
std::unique_ptr<Nz::RenderPipeline> pipeline = device->InstantiateRenderPipeline(pipelineInfo);
VkDescriptorSetLayout descriptorSetLayout = descriptorLayout;
VkPipelineLayoutCreateInfo layout_create_info = {
VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType
nullptr, // const void *pNext
0, // VkPipelineLayoutCreateFlags flags
1U, // uint32_t setLayoutCount
&descriptorSetLayout, // const VkDescriptorSetLayout *pSetLayouts
0, // uint32_t pushConstantRangeCount
nullptr // const VkPushConstantRange *pPushConstantRanges
};
Nz::Vk::PipelineLayout pipelineLayout;
pipelineLayout.Create(vulkanDevice.shared_from_this(), layout_create_info);
std::array<VkPipelineShaderStageCreateInfo, 2> shaderStageCreateInfo = {
{
{
@ -392,21 +416,6 @@ int main()
{0.0f, 0.0f, 0.0f, 0.0f} // float blendConstants[4]
};
VkDescriptorSetLayout descriptorSetLayout = descriptorLayout;
VkPipelineLayoutCreateInfo layout_create_info = {
VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType
nullptr, // const void *pNext
0, // VkPipelineLayoutCreateFlags flags
1U, // uint32_t setLayoutCount
&descriptorSetLayout, // const VkDescriptorSetLayout *pSetLayouts
0, // uint32_t pushConstantRangeCount
nullptr // const VkPushConstantRange *pPushConstantRanges
};
Nz::Vk::PipelineLayout pipelineLayout;
pipelineLayout.Create(device.shared_from_this(), layout_create_info);
std::array<VkDynamicState, 2> dynamicStates = {
VK_DYNAMIC_STATE_SCISSOR,
VK_DYNAMIC_STATE_VIEWPORT,
@ -420,20 +429,7 @@ int main()
dynamicStates.data() // const VkDynamicState* pDynamicStates;
};
VkPipelineDepthStencilStateCreateInfo depthStencilInfo = {
VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType;
nullptr, // const void* pNext;
0U, // VkPipelineDepthStencilStateCreateFlags flags;
VK_TRUE, // VkBool32 depthTestEnable;
VK_TRUE, // VkBool32 depthWriteEnable;
VK_COMPARE_OP_LESS_OR_EQUAL, // VkCompareOp depthCompareOp;
VK_FALSE, // VkBool32 depthBoundsTestEnable;
VK_FALSE, // VkBool32 stencilTestEnable;
VkStencilOpState{},// VkStencilOpState front;
VkStencilOpState{},// VkStencilOpState back;
0.f, // float minDepthBounds;
0.f // float maxDepthBounds;
};
VkPipelineDepthStencilStateCreateInfo depthStencilInfo = Nz::VulkanRenderPipeline::BuildDepthStencilInfo(pipelineInfo);
VkGraphicsPipelineCreateInfo pipeline_create_info = {
VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType
@ -457,15 +453,15 @@ int main()
-1 // int32_t basePipelineIndex
};
Nz::Vk::Pipeline pipeline;
if (!pipeline.CreateGraphics(device.shared_from_this(), pipeline_create_info))
Nz::Vk::Pipeline vkPipeline;
if (!vkPipeline.CreateGraphics(vulkanDevice.shared_from_this(), pipeline_create_info))
{
NazaraError("Failed to create pipeline");
return __LINE__;
}
Nz::Vk::CommandPool cmdPool;
if (!cmdPool.Create(device.shared_from_this(), 0, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT))
if (!cmdPool.Create(vulkanDevice.shared_from_this(), 0, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT))
{
NazaraError("Failed to create rendering cmd pool");
return __LINE__;
@ -475,7 +471,7 @@ int main()
clearValues[0].color = {1.0f, 0.8f, 0.4f, 0.0f};
clearValues[1].depthStencil = {1.f, 0};
Nz::Vk::Queue graphicsQueue(device.shared_from_this(), device.GetEnabledQueues()[0].queues[0].queue);
Nz::Vk::Queue graphicsQueue(vulkanDevice.shared_from_this(), vulkanDevice.GetEnabledQueues()[0].queues[0].queue);
Nz::UInt32 imageCount = vulkanWindow.GetFramebufferCount();
std::vector<Nz::Vk::CommandBuffer> renderCmds = cmdPool.AllocateCommandBuffers(imageCount, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
@ -532,7 +528,7 @@ int main()
renderCmd.BindIndexBuffer(indexBufferImpl->GetBufferHandle(), 0, VK_INDEX_TYPE_UINT16);
renderCmd.BindVertexBuffer(0, vertexBufferImpl->GetBufferHandle(), 0);
renderCmd.BindDescriptorSet(VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, descriptorSet);
renderCmd.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
renderCmd.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, vkPipeline);
renderCmd.SetScissor(Nz::Recti{0, 0, int(windowSize.x), int(windowSize.y)});
renderCmd.SetViewport({0.f, 0.f, float(windowSize.x), float(windowSize.y)}, 0.f, 1.f);
renderCmd.DrawIndexed(drfreakIB->GetIndexCount());

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>

11
src/Nazara/Renderer/RenderPipeline.cpp Normal file
View File

@ -0,0 +1,11 @@
// Copyright (C) 2015 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
#include <Nazara/Renderer/RenderPipeline.hpp>
#include <Nazara/Renderer/Debug.hpp>
namespace Nz
{
RenderPipeline::~RenderPipeline() = default;
}

8
src/Nazara/Renderer/RenderWindow.cpp
View File

@ -28,6 +28,14 @@ namespace Nz
///TODO
}
std::shared_ptr<RenderDevice> RenderWindow::GetRenderDevice()
{
if (!m_impl)
return std::shared_ptr<RenderDevice>();
return m_impl->GetRenderDevice();
}
bool RenderWindow::OnWindowCreated()
{
RendererImpl* rendererImpl = Renderer::GetRendererImpl();

6
src/Nazara/VulkanRenderer/VulkanDevice.cpp
View File

@ -3,6 +3,7 @@
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/VulkanRenderer/VulkanDevice.hpp>
#include <Nazara/VulkanRenderer/VulkanRenderPipeline.hpp>
#include <Nazara/VulkanRenderer/Debug.hpp>
namespace Nz
@ -13,4 +14,9 @@ namespace Nz
{
return std::make_unique<VulkanBuffer>(shared_from_this(), parent, type);
}
std::unique_ptr<RenderPipeline> VulkanDevice::InstantiateRenderPipeline(RenderPipelineInfo pipelineInfo)
{
return std::make_unique<VulkanRenderPipeline>(shared_from_this(), std::move(pipelineInfo));
}
}

51
src/Nazara/VulkanRenderer/VulkanRenderPipeline.cpp Normal file
View File

@ -0,0 +1,51 @@
// 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/Core/ErrorFlags.hpp>
#include <Nazara/VulkanRenderer/Utils.hpp>
#include <cassert>
#include <Nazara/VulkanRenderer/Debug.hpp>
namespace Nz
{
VulkanRenderPipeline::VulkanRenderPipeline(Vk::DeviceHandle device, RenderPipelineInfo pipelineInfo) :
m_device(std::move(device)),
m_pipelineInfo(std::move(pipelineInfo))
{
}
VkPipelineDepthStencilStateCreateInfo VulkanRenderPipeline::BuildDepthStencilInfo(const RenderPipelineInfo& pipelineInfo)
{
VkPipelineDepthStencilStateCreateInfo createInfo = {};
createInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
createInfo.pNext = nullptr;
createInfo.flags = 0U;
createInfo.depthTestEnable = pipelineInfo.depthBuffer;
createInfo.depthWriteEnable = pipelineInfo.depthWrite;
createInfo.depthCompareOp = ToVulkan(pipelineInfo.depthCompare);
createInfo.depthBoundsTestEnable = VK_FALSE;
createInfo.stencilTestEnable = pipelineInfo.stencilTest;
createInfo.front = BuildStencilOp(pipelineInfo, true);
createInfo.back = BuildStencilOp(pipelineInfo, false);
return createInfo;
}
VkStencilOpState VulkanRenderPipeline::BuildStencilOp(const RenderPipelineInfo& pipelineInfo, bool front)
{
const auto& pipelineStencil = (front) ? pipelineInfo.stencilFront : pipelineInfo.stencilBack;
VkStencilOpState stencilStates;
stencilStates.compareMask = pipelineStencil.compareMask;
stencilStates.compareOp = ToVulkan(pipelineStencil.compare);
stencilStates.depthFailOp = ToVulkan(pipelineStencil.depthFail);
stencilStates.failOp = ToVulkan(pipelineStencil.fail);
stencilStates.passOp = ToVulkan(pipelineStencil.pass);
stencilStates.reference = pipelineStencil.reference;
stencilStates.writeMask = pipelineStencil.writeMask;
return stencilStates;
}
}