Add Vulkan triangle integration path
This commit is contained in:
384
engine/src/RHI/Vulkan/VulkanPipelineState.cpp
Normal file
384
engine/src/RHI/Vulkan/VulkanPipelineState.cpp
Normal file
@@ -0,0 +1,384 @@
|
||||
#include "XCEngine/RHI/Vulkan/VulkanPipelineState.h"
|
||||
|
||||
#include "XCEngine/RHI/Vulkan/VulkanDevice.h"
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstring>
|
||||
#include <filesystem>
|
||||
#include <fstream>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
|
||||
namespace XCEngine {
|
||||
namespace RHI {
|
||||
|
||||
namespace {
|
||||
|
||||
std::string NarrowAscii(const std::wstring& value) {
|
||||
std::string result;
|
||||
result.reserve(value.size());
|
||||
for (wchar_t ch : value) {
|
||||
result.push_back(static_cast<char>(ch));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
bool LoadSpirvBytes(const ShaderCompileDesc& desc, std::vector<uint32_t>& words, std::string& entryPoint) {
|
||||
entryPoint = NarrowAscii(desc.entryPoint);
|
||||
if (entryPoint.empty()) {
|
||||
entryPoint = "main";
|
||||
}
|
||||
|
||||
if (desc.sourceLanguage != ShaderLanguage::SPIRV) {
|
||||
return false;
|
||||
}
|
||||
|
||||
std::vector<char> bytes;
|
||||
if (!desc.source.empty()) {
|
||||
bytes.assign(desc.source.begin(), desc.source.end());
|
||||
} else if (!desc.fileName.empty()) {
|
||||
std::ifstream file(std::filesystem::path(desc.fileName), std::ios::binary | std::ios::ate);
|
||||
if (!file.is_open()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const std::streamsize fileSize = file.tellg();
|
||||
if (fileSize <= 0 || (fileSize % 4) != 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
bytes.resize(static_cast<size_t>(fileSize));
|
||||
file.seekg(0, std::ios::beg);
|
||||
if (!file.read(bytes.data(), fileSize)) {
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
|
||||
if ((bytes.size() % sizeof(uint32_t)) != 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
words.resize(bytes.size() / sizeof(uint32_t));
|
||||
std::memcpy(words.data(), bytes.data(), bytes.size());
|
||||
return !words.empty();
|
||||
}
|
||||
|
||||
VkShaderModule CreateShaderModule(VkDevice device, const std::vector<uint32_t>& words) {
|
||||
VkShaderModuleCreateInfo createInfo = {};
|
||||
createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
|
||||
createInfo.codeSize = words.size() * sizeof(uint32_t);
|
||||
createInfo.pCode = words.data();
|
||||
|
||||
VkShaderModule module = VK_NULL_HANDLE;
|
||||
if (vkCreateShaderModule(device, &createInfo, nullptr, &module) != VK_SUCCESS) {
|
||||
return VK_NULL_HANDLE;
|
||||
}
|
||||
|
||||
return module;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
VulkanPipelineState::~VulkanPipelineState() {
|
||||
Shutdown();
|
||||
}
|
||||
|
||||
bool VulkanPipelineState::Initialize(VulkanDevice* device, const GraphicsPipelineDesc& desc) {
|
||||
if (device == nullptr || device->GetDevice() == VK_NULL_HANDLE) {
|
||||
return false;
|
||||
}
|
||||
|
||||
m_deviceOwner = device;
|
||||
m_device = device->GetDevice();
|
||||
m_inputLayoutDesc = desc.inputLayout;
|
||||
m_rasterizerDesc = desc.rasterizerState;
|
||||
m_blendDesc = desc.blendState;
|
||||
m_depthStencilDesc = desc.depthStencilState;
|
||||
m_topologyType = desc.topologyType;
|
||||
m_renderTargetCount = desc.renderTargetCount;
|
||||
m_depthStencilFormat = desc.depthStencilFormat;
|
||||
m_sampleCount = desc.sampleCount > 0 ? desc.sampleCount : 1;
|
||||
for (uint32_t i = 0; i < 8; ++i) {
|
||||
m_renderTargetFormats[i] = desc.renderTargetFormats[i];
|
||||
}
|
||||
|
||||
if (m_renderTargetCount != 1 || m_renderTargetFormats[0] == 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
std::vector<uint32_t> vertexWords;
|
||||
std::vector<uint32_t> fragmentWords;
|
||||
std::string vertexEntryPoint;
|
||||
std::string fragmentEntryPoint;
|
||||
if (!LoadSpirvBytes(desc.vertexShader, vertexWords, vertexEntryPoint) ||
|
||||
!LoadSpirvBytes(desc.fragmentShader, fragmentWords, fragmentEntryPoint)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const VkShaderModule vertexModule = CreateShaderModule(m_device, vertexWords);
|
||||
const VkShaderModule fragmentModule = CreateShaderModule(m_device, fragmentWords);
|
||||
if (vertexModule == VK_NULL_HANDLE || fragmentModule == VK_NULL_HANDLE) {
|
||||
if (vertexModule != VK_NULL_HANDLE) {
|
||||
vkDestroyShaderModule(m_device, vertexModule, nullptr);
|
||||
}
|
||||
if (fragmentModule != VK_NULL_HANDLE) {
|
||||
vkDestroyShaderModule(m_device, fragmentModule, nullptr);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
VkPipelineLayoutCreateInfo pipelineLayoutInfo = {};
|
||||
pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
|
||||
if (vkCreatePipelineLayout(m_device, &pipelineLayoutInfo, nullptr, &m_pipelineLayout) != VK_SUCCESS) {
|
||||
vkDestroyShaderModule(m_device, fragmentModule, nullptr);
|
||||
vkDestroyShaderModule(m_device, vertexModule, nullptr);
|
||||
return false;
|
||||
}
|
||||
|
||||
VkAttachmentDescription colorAttachment = {};
|
||||
colorAttachment.format = ToVulkanFormat(static_cast<Format>(m_renderTargetFormats[0]));
|
||||
colorAttachment.samples = ToVulkanSampleCount(m_sampleCount);
|
||||
colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
|
||||
colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
|
||||
colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
|
||||
colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
||||
colorAttachment.initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
|
||||
colorAttachment.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
|
||||
|
||||
VkAttachmentReference colorAttachmentRef = {};
|
||||
colorAttachmentRef.attachment = 0;
|
||||
colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
|
||||
|
||||
VkSubpassDescription subpass = {};
|
||||
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
|
||||
subpass.colorAttachmentCount = 1;
|
||||
subpass.pColorAttachments = &colorAttachmentRef;
|
||||
|
||||
VkRenderPassCreateInfo renderPassInfo = {};
|
||||
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
|
||||
renderPassInfo.attachmentCount = 1;
|
||||
renderPassInfo.pAttachments = &colorAttachment;
|
||||
renderPassInfo.subpassCount = 1;
|
||||
renderPassInfo.pSubpasses = &subpass;
|
||||
|
||||
if (vkCreateRenderPass(m_device, &renderPassInfo, nullptr, &m_renderPass) != VK_SUCCESS) {
|
||||
vkDestroyPipelineLayout(m_device, m_pipelineLayout, nullptr);
|
||||
m_pipelineLayout = VK_NULL_HANDLE;
|
||||
vkDestroyShaderModule(m_device, fragmentModule, nullptr);
|
||||
vkDestroyShaderModule(m_device, vertexModule, nullptr);
|
||||
return false;
|
||||
}
|
||||
|
||||
std::map<uint32_t, uint32_t> strideBySlot;
|
||||
for (const InputElementDesc& element : m_inputLayoutDesc.elements) {
|
||||
const uint32_t attributeSize = GetFormatSize(static_cast<Format>(element.format));
|
||||
strideBySlot[element.inputSlot] = (std::max)(strideBySlot[element.inputSlot], element.alignedByteOffset + attributeSize);
|
||||
}
|
||||
|
||||
std::vector<VkVertexInputBindingDescription> bindings;
|
||||
bindings.reserve(strideBySlot.size());
|
||||
for (const auto& entry : strideBySlot) {
|
||||
VkVertexInputBindingDescription binding = {};
|
||||
binding.binding = entry.first;
|
||||
binding.stride = entry.second;
|
||||
binding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
|
||||
bindings.push_back(binding);
|
||||
}
|
||||
|
||||
std::vector<VkVertexInputAttributeDescription> attributes;
|
||||
attributes.reserve(m_inputLayoutDesc.elements.size());
|
||||
for (uint32_t location = 0; location < m_inputLayoutDesc.elements.size(); ++location) {
|
||||
const InputElementDesc& element = m_inputLayoutDesc.elements[location];
|
||||
VkVertexInputAttributeDescription attribute = {};
|
||||
attribute.location = location;
|
||||
attribute.binding = element.inputSlot;
|
||||
attribute.format = ToVulkanFormat(static_cast<Format>(element.format));
|
||||
attribute.offset = element.alignedByteOffset;
|
||||
attributes.push_back(attribute);
|
||||
}
|
||||
|
||||
VkPipelineShaderStageCreateInfo shaderStages[2] = {};
|
||||
shaderStages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
|
||||
shaderStages[0].stage = VK_SHADER_STAGE_VERTEX_BIT;
|
||||
shaderStages[0].module = vertexModule;
|
||||
shaderStages[0].pName = vertexEntryPoint.c_str();
|
||||
|
||||
shaderStages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
|
||||
shaderStages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
|
||||
shaderStages[1].module = fragmentModule;
|
||||
shaderStages[1].pName = fragmentEntryPoint.c_str();
|
||||
|
||||
VkPipelineVertexInputStateCreateInfo vertexInputInfo = {};
|
||||
vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
|
||||
vertexInputInfo.vertexBindingDescriptionCount = static_cast<uint32_t>(bindings.size());
|
||||
vertexInputInfo.pVertexBindingDescriptions = bindings.data();
|
||||
vertexInputInfo.vertexAttributeDescriptionCount = static_cast<uint32_t>(attributes.size());
|
||||
vertexInputInfo.pVertexAttributeDescriptions = attributes.data();
|
||||
|
||||
VkPipelineInputAssemblyStateCreateInfo inputAssembly = {};
|
||||
inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
|
||||
inputAssembly.topology = ToVulkanPrimitiveTopology(static_cast<PrimitiveTopologyType>(m_topologyType));
|
||||
inputAssembly.primitiveRestartEnable = VK_FALSE;
|
||||
|
||||
VkPipelineViewportStateCreateInfo viewportState = {};
|
||||
viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
|
||||
viewportState.viewportCount = 1;
|
||||
viewportState.scissorCount = 1;
|
||||
|
||||
VkPipelineRasterizationStateCreateInfo rasterizer = {};
|
||||
rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
|
||||
rasterizer.depthClampEnable = m_rasterizerDesc.depthClipEnable ? VK_FALSE : VK_TRUE;
|
||||
rasterizer.rasterizerDiscardEnable = VK_FALSE;
|
||||
rasterizer.polygonMode = ToVulkanPolygonMode(static_cast<FillMode>(m_rasterizerDesc.fillMode));
|
||||
rasterizer.lineWidth = 1.0f;
|
||||
rasterizer.cullMode = ToVulkanCullMode(static_cast<CullMode>(m_rasterizerDesc.cullMode));
|
||||
rasterizer.frontFace = ToVulkanFrontFace(static_cast<FrontFace>(m_rasterizerDesc.frontFace));
|
||||
rasterizer.depthBiasEnable = m_rasterizerDesc.depthBias != 0 || m_rasterizerDesc.slopeScaledDepthBias != 0.0f;
|
||||
rasterizer.depthBiasConstantFactor = static_cast<float>(m_rasterizerDesc.depthBias);
|
||||
rasterizer.depthBiasClamp = m_rasterizerDesc.depthBiasClamp;
|
||||
rasterizer.depthBiasSlopeFactor = m_rasterizerDesc.slopeScaledDepthBias;
|
||||
|
||||
VkPipelineMultisampleStateCreateInfo multisampling = {};
|
||||
multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
|
||||
multisampling.rasterizationSamples = ToVulkanSampleCount(m_sampleCount);
|
||||
multisampling.sampleShadingEnable = VK_FALSE;
|
||||
|
||||
VkPipelineColorBlendAttachmentState colorBlendAttachment = {};
|
||||
colorBlendAttachment.colorWriteMask =
|
||||
VK_COLOR_COMPONENT_R_BIT |
|
||||
VK_COLOR_COMPONENT_G_BIT |
|
||||
VK_COLOR_COMPONENT_B_BIT |
|
||||
VK_COLOR_COMPONENT_A_BIT;
|
||||
colorBlendAttachment.blendEnable = m_blendDesc.blendEnable ? VK_TRUE : VK_FALSE;
|
||||
colorBlendAttachment.srcColorBlendFactor = ToVulkanBlendFactor(static_cast<BlendFactor>(m_blendDesc.srcBlend));
|
||||
colorBlendAttachment.dstColorBlendFactor = ToVulkanBlendFactor(static_cast<BlendFactor>(m_blendDesc.dstBlend));
|
||||
colorBlendAttachment.colorBlendOp = ToVulkanBlendOp(static_cast<BlendOp>(m_blendDesc.blendOp));
|
||||
colorBlendAttachment.srcAlphaBlendFactor = ToVulkanBlendFactor(static_cast<BlendFactor>(m_blendDesc.srcBlendAlpha));
|
||||
colorBlendAttachment.dstAlphaBlendFactor = ToVulkanBlendFactor(static_cast<BlendFactor>(m_blendDesc.dstBlendAlpha));
|
||||
colorBlendAttachment.alphaBlendOp = ToVulkanBlendOp(static_cast<BlendOp>(m_blendDesc.blendOpAlpha));
|
||||
|
||||
VkPipelineColorBlendStateCreateInfo colorBlending = {};
|
||||
colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
|
||||
colorBlending.logicOpEnable = VK_FALSE;
|
||||
colorBlending.attachmentCount = 1;
|
||||
colorBlending.pAttachments = &colorBlendAttachment;
|
||||
|
||||
VkPipelineDepthStencilStateCreateInfo depthStencil = {};
|
||||
depthStencil.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
|
||||
depthStencil.depthTestEnable = m_depthStencilDesc.depthTestEnable ? VK_TRUE : VK_FALSE;
|
||||
depthStencil.depthWriteEnable = m_depthStencilDesc.depthWriteEnable ? VK_TRUE : VK_FALSE;
|
||||
depthStencil.depthCompareOp = ToVulkanCompareOp(static_cast<ComparisonFunc>(m_depthStencilDesc.depthFunc));
|
||||
depthStencil.depthBoundsTestEnable = m_depthStencilDesc.depthBoundsEnable ? VK_TRUE : VK_FALSE;
|
||||
depthStencil.stencilTestEnable = m_depthStencilDesc.stencilEnable ? VK_TRUE : VK_FALSE;
|
||||
|
||||
VkDynamicState dynamicStates[] = {
|
||||
VK_DYNAMIC_STATE_VIEWPORT,
|
||||
VK_DYNAMIC_STATE_SCISSOR
|
||||
};
|
||||
VkPipelineDynamicStateCreateInfo dynamicState = {};
|
||||
dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
|
||||
dynamicState.dynamicStateCount = static_cast<uint32_t>(std::size(dynamicStates));
|
||||
dynamicState.pDynamicStates = dynamicStates;
|
||||
|
||||
VkGraphicsPipelineCreateInfo pipelineInfo = {};
|
||||
pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
|
||||
pipelineInfo.stageCount = 2;
|
||||
pipelineInfo.pStages = shaderStages;
|
||||
pipelineInfo.pVertexInputState = &vertexInputInfo;
|
||||
pipelineInfo.pInputAssemblyState = &inputAssembly;
|
||||
pipelineInfo.pViewportState = &viewportState;
|
||||
pipelineInfo.pRasterizationState = &rasterizer;
|
||||
pipelineInfo.pMultisampleState = &multisampling;
|
||||
pipelineInfo.pDepthStencilState = &depthStencil;
|
||||
pipelineInfo.pColorBlendState = &colorBlending;
|
||||
pipelineInfo.pDynamicState = &dynamicState;
|
||||
pipelineInfo.layout = m_pipelineLayout;
|
||||
pipelineInfo.renderPass = m_renderPass;
|
||||
pipelineInfo.subpass = 0;
|
||||
|
||||
const bool success = vkCreateGraphicsPipelines(
|
||||
m_device,
|
||||
VK_NULL_HANDLE,
|
||||
1,
|
||||
&pipelineInfo,
|
||||
nullptr,
|
||||
&m_pipeline) == VK_SUCCESS;
|
||||
|
||||
vkDestroyShaderModule(m_device, fragmentModule, nullptr);
|
||||
vkDestroyShaderModule(m_device, vertexModule, nullptr);
|
||||
|
||||
if (!success) {
|
||||
Shutdown();
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void VulkanPipelineState::SetInputLayout(const InputLayoutDesc& layout) {
|
||||
m_inputLayoutDesc = layout;
|
||||
}
|
||||
|
||||
void VulkanPipelineState::SetRasterizerState(const RasterizerDesc& state) {
|
||||
m_rasterizerDesc = state;
|
||||
}
|
||||
|
||||
void VulkanPipelineState::SetBlendState(const BlendDesc& state) {
|
||||
m_blendDesc = state;
|
||||
}
|
||||
|
||||
void VulkanPipelineState::SetDepthStencilState(const DepthStencilStateDesc& state) {
|
||||
m_depthStencilDesc = state;
|
||||
}
|
||||
|
||||
void VulkanPipelineState::SetTopology(uint32_t topologyType) {
|
||||
m_topologyType = topologyType;
|
||||
}
|
||||
|
||||
void VulkanPipelineState::SetRenderTargetFormats(uint32_t count, const uint32_t* formats, uint32_t depthFormat) {
|
||||
m_renderTargetCount = count;
|
||||
m_depthStencilFormat = depthFormat;
|
||||
for (uint32_t i = 0; i < count && i < 8; ++i) {
|
||||
m_renderTargetFormats[i] = formats[i];
|
||||
}
|
||||
}
|
||||
|
||||
void VulkanPipelineState::SetSampleCount(uint32_t count) {
|
||||
m_sampleCount = count > 0 ? count : 1;
|
||||
}
|
||||
|
||||
void VulkanPipelineState::SetComputeShader(RHIShader* shader) {
|
||||
(void)shader;
|
||||
}
|
||||
|
||||
PipelineStateHash VulkanPipelineState::GetHash() const {
|
||||
PipelineStateHash hash = {};
|
||||
hash.topologyHash = m_topologyType;
|
||||
hash.renderTargetHash = m_renderTargetCount ^ (m_renderTargetFormats[0] << 8);
|
||||
return hash;
|
||||
}
|
||||
|
||||
void VulkanPipelineState::Shutdown() {
|
||||
if (m_pipeline != VK_NULL_HANDLE && m_device != VK_NULL_HANDLE) {
|
||||
vkDestroyPipeline(m_device, m_pipeline, nullptr);
|
||||
m_pipeline = VK_NULL_HANDLE;
|
||||
}
|
||||
|
||||
if (m_renderPass != VK_NULL_HANDLE && m_device != VK_NULL_HANDLE) {
|
||||
vkDestroyRenderPass(m_device, m_renderPass, nullptr);
|
||||
m_renderPass = VK_NULL_HANDLE;
|
||||
}
|
||||
|
||||
if (m_pipelineLayout != VK_NULL_HANDLE && m_device != VK_NULL_HANDLE) {
|
||||
vkDestroyPipelineLayout(m_device, m_pipelineLayout, nullptr);
|
||||
m_pipelineLayout = VK_NULL_HANDLE;
|
||||
}
|
||||
|
||||
m_deviceOwner = nullptr;
|
||||
m_device = VK_NULL_HANDLE;
|
||||
}
|
||||
|
||||
} // namespace RHI
|
||||
} // namespace XCEngine
|
||||
Reference in New Issue
Block a user