diff --git a/examples/VulkanTest/main.cpp b/examples/VulkanTest/main.cpp index c579594be..907bc43a0 100644 --- a/examples/VulkanTest/main.cpp +++ b/examples/VulkanTest/main.cpp @@ -122,6 +122,8 @@ int main() return __LINE__; } + std::shared_ptr device = window.GetRenderDevice(); + Nz::VkRenderWindow& vulkanWindow = *static_cast(window.GetImpl()); /*VkPhysicalDeviceFeatures features; @@ -136,17 +138,17 @@ int main() std::vector 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(vertexShaderCode.data()), vertexShaderCode.size())) + if (!vertexShader.Create(vulkanDevice.shared_from_this(), reinterpret_cast(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(fragmentShaderCode.data()), fragmentShaderCode.size())) + if (!fragmentShader.Create(vulkanDevice.shared_from_this(), reinterpret_cast(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(drfreakIB->GetBuffer()->GetImpl()); - if (!renderBufferIB->Synchronize(&device)) + if (!renderBufferIB->Synchronize(&vulkanDevice)) { NazaraError("Failed to synchronize render buffer"); return __LINE__; } - Nz::VulkanBuffer* indexBufferImpl = static_cast(renderBufferIB->GetHardwareBuffer(&device)); + Nz::VulkanBuffer* indexBufferImpl = static_cast(renderBufferIB->GetHardwareBuffer(&vulkanDevice)); // Index buffer std::cout << "Vertex count: " << drfreakVB->GetVertexCount() << std::endl; Nz::RenderBuffer* renderBufferVB = static_cast(drfreakVB->GetBuffer()->GetImpl()); - if (!renderBufferVB->Synchronize(&device)) + if (!renderBufferVB->Synchronize(&vulkanDevice)) { NazaraError("Failed to synchronize render buffer"); return __LINE__; } - Nz::VulkanBuffer* vertexBufferImpl = static_cast(renderBufferVB->GetHardwareBuffer(&device)); + Nz::VulkanBuffer* vertexBufferImpl = static_cast(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 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 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 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 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()); diff --git a/include/Nazara/Renderer.hpp b/include/Nazara/Renderer.hpp index d64926f30..652538c6b 100644 --- a/include/Nazara/Renderer.hpp +++ b/include/Nazara/Renderer.hpp @@ -30,21 +30,17 @@ #define NAZARA_GLOBAL_RENDERER_HPP #include -#include #include #include #include -#include #include -#include #include +#include #include #include #include #include #include -#include -#include #include #include #include @@ -53,7 +49,5 @@ #include #include #include -#include -#include #endif // NAZARA_GLOBAL_RENDERER_HPP diff --git a/include/Nazara/Renderer/RenderDevice.hpp b/include/Nazara/Renderer/RenderDevice.hpp index f01ea5ec5..18f27bc5e 100644 --- a/include/Nazara/Renderer/RenderDevice.hpp +++ b/include/Nazara/Renderer/RenderDevice.hpp @@ -9,6 +9,7 @@ #include #include +#include #include #include @@ -23,6 +24,7 @@ namespace Nz virtual ~RenderDevice(); virtual std::unique_ptr InstantiateBuffer(Buffer* parent, BufferType type) = 0; + virtual std::unique_ptr InstantiateRenderPipeline(RenderPipelineInfo pipelineInfo) = 0; }; } diff --git a/include/Nazara/Renderer/RenderPipeline.hpp b/include/Nazara/Renderer/RenderPipeline.hpp index 846cfb4af..d78270ca2 100644 --- a/include/Nazara/Renderer/RenderPipeline.hpp +++ b/include/Nazara/Renderer/RenderPipeline.hpp @@ -9,31 +9,20 @@ #include #include -#include +//#include 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(); }; } diff --git a/include/Nazara/Renderer/RenderPipeline.inl b/include/Nazara/Renderer/RenderPipeline.inl index 2a1aef815..991e50a2c 100644 --- a/include/Nazara/Renderer/RenderPipeline.inl +++ b/include/Nazara/Renderer/RenderPipeline.inl @@ -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 diff --git a/include/Nazara/Renderer/RenderStates.hpp b/include/Nazara/Renderer/RenderStates.hpp index 642f9e93f..5fec08981 100644 --- a/include/Nazara/Renderer/RenderStates.hpp +++ b/include/Nazara/Renderer/RenderStates.hpp @@ -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; diff --git a/include/Nazara/Renderer/RenderStates.inl b/include/Nazara/Renderer/RenderStates.inl index 7f976ff13..4d521e65c 100644 --- a/include/Nazara/Renderer/RenderStates.inl +++ b/include/Nazara/Renderer/RenderStates.inl @@ -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(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); diff --git a/include/Nazara/Renderer/RenderWindow.hpp b/include/Nazara/Renderer/RenderWindow.hpp index 73dfa55a9..b15d3bb51 100644 --- a/include/Nazara/Renderer/RenderWindow.hpp +++ b/include/Nazara/Renderer/RenderWindow.hpp @@ -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 GetRenderDevice(); inline bool IsValid() const; diff --git a/include/Nazara/Renderer/RenderWindowImpl.hpp b/include/Nazara/Renderer/RenderWindowImpl.hpp index e5abd0c98..df67001c5 100644 --- a/include/Nazara/Renderer/RenderWindowImpl.hpp +++ b/include/Nazara/Renderer/RenderWindowImpl.hpp @@ -11,6 +11,7 @@ #include #include #include +#include #include #include @@ -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 GetRenderDevice() = 0; }; } diff --git a/include/Nazara/Utility.hpp b/include/Nazara/Utility.hpp index 97deaca58..735b83c32 100644 --- a/include/Nazara/Utility.hpp +++ b/include/Nazara/Utility.hpp @@ -63,6 +63,7 @@ #include #include #include +#include #include #include #include diff --git a/include/Nazara/VulkanRenderer.hpp b/include/Nazara/VulkanRenderer.hpp index ed3a8c88f..71c764abf 100644 --- a/include/Nazara/VulkanRenderer.hpp +++ b/include/Nazara/VulkanRenderer.hpp @@ -37,6 +37,7 @@ #include #include #include +#include #include #include diff --git a/include/Nazara/VulkanRenderer/Utils.hpp b/include/Nazara/VulkanRenderer/Utils.hpp index 5fa483b5c..bd4ea0563 100644 --- a/include/Nazara/VulkanRenderer/Utils.hpp +++ b/include/Nazara/VulkanRenderer/Utils.hpp @@ -9,11 +9,16 @@ #include #include +#include #include namespace Nz { + inline VkCompareOp ToVulkan(RendererComparison comparison); + inline VkStencilOp ToVulkan(StencilOperation stencilOp); NAZARA_VULKANRENDERER_API String TranslateVulkanError(VkResult code); } +#include + #endif // NAZARA_UTILS_VULKAN_HPP diff --git a/include/Nazara/VulkanRenderer/Utils.inl b/include/Nazara/VulkanRenderer/Utils.inl new file mode 100644 index 000000000..dfc13cd1f --- /dev/null +++ b/include/Nazara/VulkanRenderer/Utils.inl @@ -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 +#include +#include +#include + +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 diff --git a/include/Nazara/VulkanRenderer/VkRenderWindow.hpp b/include/Nazara/VulkanRenderer/VkRenderWindow.hpp index 38c464986..1ed643149 100644 --- a/include/Nazara/VulkanRenderer/VkRenderWindow.hpp +++ b/include/Nazara/VulkanRenderer/VkRenderWindow.hpp @@ -51,6 +51,8 @@ namespace Nz inline UInt32 GetPresentableFamilyQueue() const; inline const Vk::Swapchain& GetSwapchain() const; + std::shared_ptr GetRenderDevice() override; + void Present(UInt32 imageIndex) override; VkRenderWindow& operator=(const VkRenderWindow&) = delete; diff --git a/include/Nazara/VulkanRenderer/VkRenderWindow.inl b/include/Nazara/VulkanRenderer/VkRenderWindow.inl index 0721f4762..11310e89b 100644 --- a/include/Nazara/VulkanRenderer/VkRenderWindow.inl +++ b/include/Nazara/VulkanRenderer/VkRenderWindow.inl @@ -37,6 +37,11 @@ namespace Nz return m_swapchain; } + inline std::shared_ptr Nz::VkRenderWindow::GetRenderDevice() + { + return m_device; + } + inline void VkRenderWindow::Present(UInt32 imageIndex) { NazaraAssert(imageIndex < m_frameBuffers.size(), "Invalid image index"); diff --git a/include/Nazara/VulkanRenderer/VulkanDevice.hpp b/include/Nazara/VulkanRenderer/VulkanDevice.hpp index 5ec2a891c..291aa7b3e 100644 --- a/include/Nazara/VulkanRenderer/VulkanDevice.hpp +++ b/include/Nazara/VulkanRenderer/VulkanDevice.hpp @@ -24,6 +24,7 @@ namespace Nz ~VulkanDevice(); std::unique_ptr InstantiateBuffer(Buffer* parent, BufferType type) override; + std::unique_ptr InstantiateRenderPipeline(RenderPipelineInfo pipelineInfo) override; VulkanDevice& operator=(const VulkanDevice&) = delete; VulkanDevice& operator=(VulkanDevice&&) = delete; ///TODO? diff --git a/include/Nazara/VulkanRenderer/VulkanRenderPipeline.hpp b/include/Nazara/VulkanRenderer/VulkanRenderPipeline.hpp new file mode 100644 index 000000000..34e39a990 --- /dev/null +++ b/include/Nazara/VulkanRenderer/VulkanRenderPipeline.hpp @@ -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 +#include +#include +#include + +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 + +#endif // NAZARA_VULKANRENDERER_VULKANRENDERPIPELINE_HPP diff --git a/include/Nazara/VulkanRenderer/VulkanRenderPipeline.inl b/include/Nazara/VulkanRenderer/VulkanRenderPipeline.inl new file mode 100644 index 000000000..180aaa736 --- /dev/null +++ b/include/Nazara/VulkanRenderer/VulkanRenderPipeline.inl @@ -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 +#include + +namespace Nz +{ +} + +#include diff --git a/src/Nazara/Renderer/RenderPipeline.cpp b/src/Nazara/Renderer/RenderPipeline.cpp new file mode 100644 index 000000000..c5faed12b --- /dev/null +++ b/src/Nazara/Renderer/RenderPipeline.cpp @@ -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 +#include + +namespace Nz +{ + RenderPipeline::~RenderPipeline() = default; +} diff --git a/src/Nazara/Renderer/RenderWindow.cpp b/src/Nazara/Renderer/RenderWindow.cpp index bd720c01c..2fe2f99cb 100644 --- a/src/Nazara/Renderer/RenderWindow.cpp +++ b/src/Nazara/Renderer/RenderWindow.cpp @@ -28,6 +28,14 @@ namespace Nz ///TODO } + std::shared_ptr RenderWindow::GetRenderDevice() + { + if (!m_impl) + return std::shared_ptr(); + + return m_impl->GetRenderDevice(); + } + bool RenderWindow::OnWindowCreated() { RendererImpl* rendererImpl = Renderer::GetRendererImpl(); diff --git a/src/Nazara/VulkanRenderer/VulkanDevice.cpp b/src/Nazara/VulkanRenderer/VulkanDevice.cpp index d1c0e736e..43bb964fc 100644 --- a/src/Nazara/VulkanRenderer/VulkanDevice.cpp +++ b/src/Nazara/VulkanRenderer/VulkanDevice.cpp @@ -3,6 +3,7 @@ // For conditions of distribution and use, see copyright notice in Config.hpp #include +#include #include namespace Nz @@ -13,4 +14,9 @@ namespace Nz { return std::make_unique(shared_from_this(), parent, type); } + + std::unique_ptr VulkanDevice::InstantiateRenderPipeline(RenderPipelineInfo pipelineInfo) + { + return std::make_unique(shared_from_this(), std::move(pipelineInfo)); + } } diff --git a/src/Nazara/VulkanRenderer/VulkanRenderPipeline.cpp b/src/Nazara/VulkanRenderer/VulkanRenderPipeline.cpp new file mode 100644 index 000000000..ad4b43a5a --- /dev/null +++ b/src/Nazara/VulkanRenderer/VulkanRenderPipeline.cpp @@ -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 +#include +#include +#include +#include + +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; + } +}