512 lines
25 KiB
C++
512 lines
25 KiB
C++
#include "Pipeline.hpp"
|
|
|
|
#include "PhysicalDeviceInfo.hpp"
|
|
#include "../../../core/data/file.hpp"
|
|
#include "../Renderer.hpp"
|
|
#include "api/Models.hpp"
|
|
#include <map>
|
|
|
|
#define CONTENT_DIR "content/"
|
|
#define SHADER_DIR CONTENT_DIR "shaders/"
|
|
|
|
constexpr auto BLENDING = true;
|
|
|
|
using namespace render::vk;
|
|
|
|
Pipeline::Pipeline(VkDevice device, const PhysicalDeviceInfo &info, const renderOptions &options): device(device) {
|
|
const auto hasSamples = info.samples > 1;
|
|
{ // Render pass
|
|
VkAttachmentDescription colorAttachment{};
|
|
colorAttachment.format = info.getSurfaceFormat().format;
|
|
colorAttachment.samples = info.samples;
|
|
colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
|
|
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_UNDEFINED;
|
|
colorAttachment.finalLayout = hasSamples ?
|
|
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
|
|
|
|
VkAttachmentReference colorAttachmentRef{};
|
|
colorAttachmentRef.attachment = 0; //TODO: layouts bind
|
|
colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
|
|
|
|
VkAttachmentDescription depthAttachment{};
|
|
depthAttachment.format = info.findDepthFormat();
|
|
depthAttachment.samples = info.samples;
|
|
depthAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
|
|
depthAttachment.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
|
depthAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
|
|
depthAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
|
depthAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
depthAttachment.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
|
|
|
|
VkAttachmentReference depthAttachmentRef{};
|
|
depthAttachmentRef.attachment = 1;
|
|
depthAttachmentRef.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
|
|
|
|
VkAttachmentDescription colorAttachmentResolve{};
|
|
colorAttachmentResolve.format = colorAttachment.format;
|
|
colorAttachmentResolve.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
colorAttachmentResolve.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
|
|
colorAttachmentResolve.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
|
|
colorAttachmentResolve.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
|
|
colorAttachmentResolve.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
|
colorAttachmentResolve.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
colorAttachmentResolve.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
|
|
|
|
VkAttachmentReference colorAttachmentResolveRef{};
|
|
colorAttachmentResolveRef.attachment = 2;
|
|
colorAttachmentResolveRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
|
|
|
|
VkSubpassDescription colorDepthSubpass{};
|
|
colorDepthSubpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
|
|
colorDepthSubpass.colorAttachmentCount = 1;
|
|
colorDepthSubpass.pColorAttachments = &colorAttachmentRef;
|
|
colorDepthSubpass.pDepthStencilAttachment = &depthAttachmentRef;
|
|
if (hasSamples) {
|
|
colorDepthSubpass.pResolveAttachments = &colorAttachmentResolveRef;
|
|
}
|
|
std::array<VkSubpassDescription, 3> subpasses = {colorDepthSubpass, colorDepthSubpass, colorDepthSubpass};
|
|
|
|
std::array<VkSubpassDependency, 5> dependencies{};
|
|
dependencies[0].srcSubpass = VK_SUBPASS_EXTERNAL;
|
|
dependencies[0].dstSubpass = 0;
|
|
dependencies[0].srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
|
|
dependencies[0].srcAccessMask = 0;
|
|
dependencies[0].dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
|
|
dependencies[0].dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
|
|
dependencies[0].dependencyFlags = 0;
|
|
|
|
dependencies[1].srcSubpass = 0;
|
|
dependencies[1].dstSubpass = 1;
|
|
dependencies[1].srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
|
|
dependencies[1].srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
|
|
dependencies[1].dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
|
|
dependencies[1].dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
|
|
dependencies[1].dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
|
|
|
|
dependencies[2].srcSubpass = 0;
|
|
dependencies[2].dstSubpass = 1;
|
|
dependencies[2].srcStageMask = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
|
|
dependencies[2].srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
|
|
dependencies[2].dstStageMask = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
|
|
dependencies[2].dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
|
|
dependencies[2].dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
|
|
|
|
dependencies[3].srcSubpass = 1;
|
|
dependencies[3].dstSubpass = 2;
|
|
dependencies[3].srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
|
|
dependencies[3].srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
|
|
dependencies[3].dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
|
|
dependencies[3].dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
|
|
dependencies[3].dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
|
|
|
|
dependencies[4].srcSubpass = 1;
|
|
dependencies[4].dstSubpass = 2;
|
|
dependencies[4].srcStageMask = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
|
|
dependencies[4].srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
|
|
dependencies[4].dstStageMask = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
|
|
dependencies[4].dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
|
|
dependencies[4].dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
|
|
|
|
VkRenderPassCreateInfo renderPassInfo{};
|
|
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
|
|
std::vector<VkAttachmentDescription> attachments = {colorAttachment, depthAttachment};
|
|
if (hasSamples) {
|
|
attachments.push_back(colorAttachmentResolve);
|
|
}
|
|
renderPassInfo.attachmentCount = attachments.size();
|
|
renderPassInfo.pAttachments = attachments.data();
|
|
renderPassInfo.subpassCount = subpasses.size();
|
|
renderPassInfo.pSubpasses = subpasses.data();
|
|
renderPassInfo.dependencyCount = dependencies.size();
|
|
renderPassInfo.pDependencies = dependencies.data();
|
|
|
|
if (vkCreateRenderPass(device, &renderPassInfo, ALLOC, &renderPass) != VK_SUCCESS) {
|
|
FATAL("Failed to create render pass!");
|
|
}
|
|
}
|
|
//MAYBE: use sets (ubo, (samplers, passInfos))
|
|
//MAYBE: reuse sub UBO
|
|
{ // Voxel descriptor
|
|
std::array<VkDescriptorSetLayoutBinding, 4> bindings{};
|
|
bindings[0] = VoxelUBO::getLayoutBinding();
|
|
bindings[1].binding = 1;
|
|
bindings[1].descriptorCount = 1;
|
|
bindings[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
|
|
bindings[1].pImmutableSamplers = nullptr; //TODO: set immuable samplers
|
|
bindings[1].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
|
|
bindings[2].binding = 2;
|
|
bindings[2].descriptorCount = 1;
|
|
bindings[2].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
|
|
bindings[2].pImmutableSamplers = nullptr;
|
|
bindings[2].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
|
|
bindings[3].binding = 3;
|
|
bindings[3].descriptorCount = 1;
|
|
bindings[3].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
|
|
bindings[3].pImmutableSamplers = nullptr;
|
|
bindings[3].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
|
|
|
|
VkDescriptorSetLayoutCreateInfo layoutInfo{};
|
|
layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
|
|
layoutInfo.bindingCount = bindings.size();
|
|
layoutInfo.pBindings = bindings.data();
|
|
|
|
if (vkCreateDescriptorSetLayout(device, &layoutInfo, ALLOC, &voxelDescriptorSet) != VK_SUCCESS) {
|
|
FATAL("Failed to create descriptor set layout!");
|
|
}
|
|
}
|
|
{ // Indicator descriptor
|
|
VkDescriptorSetLayoutCreateInfo layoutInfo{};
|
|
layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
|
|
auto binding = ViewProjUBO::getLayoutBinding();
|
|
layoutInfo.bindingCount = 1;
|
|
layoutInfo.pBindings = &binding;
|
|
|
|
if (vkCreateDescriptorSetLayout(device, &layoutInfo, ALLOC, &indicDescriptorSet) != VK_SUCCESS) {
|
|
FATAL("Failed to create descriptor set layout!");
|
|
}
|
|
}
|
|
{ // Sky descriptor
|
|
VkDescriptorSetLayoutBinding samplerLayoutBinding{};
|
|
samplerLayoutBinding.binding = 1;
|
|
samplerLayoutBinding.descriptorCount = 1;
|
|
samplerLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
|
|
samplerLayoutBinding.pImmutableSamplers = nullptr;
|
|
samplerLayoutBinding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
|
|
|
|
std::vector<VkDescriptorSetLayoutBinding> bindings = {ViewProjUBO::getLayoutBinding(), samplerLayoutBinding};
|
|
VkDescriptorSetLayoutCreateInfo layoutInfo{};
|
|
layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
|
|
layoutInfo.bindingCount = bindings.size();
|
|
layoutInfo.pBindings = bindings.data();
|
|
|
|
if (vkCreateDescriptorSetLayout(device, &layoutInfo, ALLOC, &skyDescriptorSet) != VK_SUCCESS) {
|
|
FATAL("Failed to create descriptor set layout!");
|
|
}
|
|
}
|
|
// Common pipeline settings
|
|
auto makeSpecialization = [](const std::map<uint32_t, data_view>& constants, std::vector<unsigned char>& speData, std::vector<VkSpecializationMapEntry>& speIndex) {
|
|
//MAYBE: create class
|
|
VkSpecializationInfo specialization;
|
|
speData.resize(0);
|
|
speIndex.resize(0);
|
|
speData.reserve(constants.size()); //NOTE: Lower bound
|
|
speIndex.reserve(constants.size());
|
|
for(auto& constant: constants) {
|
|
VkSpecializationMapEntry entry;
|
|
entry.constantID = constant.first;
|
|
entry.size = constant.second.size;
|
|
entry.offset = speData.size();
|
|
speData.resize(speData.size() + entry.size);
|
|
memcpy(speData.data() + entry.offset, static_cast<const uint8_t*>(constant.second.ptr), entry.size);
|
|
}
|
|
specialization.dataSize = speData.size();
|
|
specialization.pData = speData.data();
|
|
specialization.mapEntryCount = speIndex.size();
|
|
specialization.pMapEntries = speIndex.data();
|
|
return specialization;
|
|
};
|
|
auto setShaders = [&](Subpass &pass, const std::string &shaderName, bool geometry = false, const VkSpecializationInfo* specialization = nullptr) -> std::vector<VkPipelineShaderStageCreateInfo>
|
|
{
|
|
auto createShaderModule = [&](const data::file_content &code) {
|
|
VkShaderModuleCreateInfo createInfo{};
|
|
createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
|
|
createInfo.codeSize = code.size();
|
|
createInfo.pCode = reinterpret_cast<const uint32_t *>(code.data());
|
|
|
|
VkShaderModule shaderModule;
|
|
if (vkCreateShaderModule(device, &createInfo, ALLOC, &shaderModule) != VK_SUCCESS) {
|
|
FATAL("Failed to create shader module!");
|
|
}
|
|
return shaderModule;
|
|
};
|
|
|
|
VkPipelineShaderStageCreateInfo vertShaderStageInfo{};
|
|
vertShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
|
|
vertShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
|
|
data::file_content vsFile({SHADER_DIR + shaderName + ".vs.spv"});
|
|
vertShaderStageInfo.module = pass.vsShader = createShaderModule(vsFile);
|
|
vertShaderStageInfo.pName = "main";
|
|
vertShaderStageInfo.pSpecializationInfo = specialization;
|
|
|
|
VkPipelineShaderStageCreateInfo fragShaderStageInfo{};
|
|
fragShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
|
|
fragShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
|
|
data::file_content fsFile({SHADER_DIR + shaderName + ".fs.spv"});
|
|
fragShaderStageInfo.module = pass.fsShader = createShaderModule(fsFile);
|
|
fragShaderStageInfo.pName = "main";
|
|
fragShaderStageInfo.pSpecializationInfo = specialization;
|
|
|
|
if (geometry) {
|
|
VkPipelineShaderStageCreateInfo geomShaderStageInfo{};
|
|
geomShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
|
|
geomShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
|
|
data::file_content fsFile({SHADER_DIR + shaderName + ".gs.spv"});
|
|
geomShaderStageInfo.module = pass.fsShader = createShaderModule(fsFile);
|
|
geomShaderStageInfo.pName = "main";
|
|
geomShaderStageInfo.pSpecializationInfo = specialization;
|
|
|
|
return {vertShaderStageInfo, geomShaderStageInfo, fragShaderStageInfo};
|
|
} else {
|
|
return {vertShaderStageInfo, fragShaderStageInfo};
|
|
}
|
|
};
|
|
auto setLayout = [&](Subpass& pass, const std::vector<VkDescriptorSetLayout>& layout, const std::vector<VkPushConstantRange>& push = {}) {
|
|
VkPipelineLayoutCreateInfo pipelineLayoutInfo{};
|
|
pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
|
|
pipelineLayoutInfo.setLayoutCount = layout.size();
|
|
pipelineLayoutInfo.pSetLayouts = layout.data();
|
|
pipelineLayoutInfo.pushConstantRangeCount = push.size();
|
|
pipelineLayoutInfo.pPushConstantRanges = push.data();
|
|
|
|
if (vkCreatePipelineLayout(device, &pipelineLayoutInfo, ALLOC, &pass.layout) != VK_SUCCESS) {
|
|
FATAL("Failed to create pipeline layout!");
|
|
}
|
|
};
|
|
|
|
VkPipelineDepthStencilStateCreateInfo depthStencil{};
|
|
depthStencil.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
|
|
depthStencil.depthTestEnable = VK_TRUE;
|
|
depthStencil.depthWriteEnable = VK_TRUE;
|
|
depthStencil.depthCompareOp = VK_COMPARE_OP_LESS;
|
|
depthStencil.depthBoundsTestEnable = VK_FALSE; // Restrict sub depth area
|
|
depthStencil.minDepthBounds = 0.0f;
|
|
depthStencil.maxDepthBounds = 1.0f;
|
|
|
|
depthStencil.stencilTestEnable = VK_FALSE;
|
|
// Stencil options front/back
|
|
|
|
VkPipelineColorBlendAttachmentState colorBlendAttachment{};
|
|
colorBlendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
|
|
if constexpr (BLENDING) {
|
|
colorBlendAttachment.blendEnable = VK_TRUE;
|
|
colorBlendAttachment.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
|
|
colorBlendAttachment.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
|
|
colorBlendAttachment.colorBlendOp = VK_BLEND_OP_ADD;
|
|
colorBlendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
|
|
colorBlendAttachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
|
|
colorBlendAttachment.alphaBlendOp = VK_BLEND_OP_ADD;
|
|
} else {
|
|
colorBlendAttachment.blendEnable = VK_FALSE;
|
|
}
|
|
|
|
VkPipelineColorBlendStateCreateInfo colorBlending{};
|
|
colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
|
|
colorBlending.attachmentCount = 1; //NOTE: For multitarget
|
|
colorBlending.pAttachments = &colorBlendAttachment;
|
|
colorBlending.logicOpEnable = VK_FALSE;
|
|
colorBlending.logicOp = VK_LOGIC_OP_COPY;
|
|
colorBlending.blendConstants[0] = 0.0f;
|
|
colorBlending.blendConstants[1] = 0.0f;
|
|
colorBlending.blendConstants[2] = 0.0f;
|
|
colorBlending.blendConstants[3] = 0.0f;
|
|
|
|
VkPipelineInputAssemblyStateCreateInfo trisInputAssembly{};
|
|
trisInputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
|
|
trisInputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
|
|
trisInputAssembly.primitiveRestartEnable = VK_FALSE;
|
|
|
|
// Viewport
|
|
VkViewport viewport{};
|
|
viewport.x = 0.0f;
|
|
viewport.y = 0.0f;
|
|
viewport.width = (float)info.swapDetails.capabilities.currentExtent.width;
|
|
viewport.height = (float)info.swapDetails.capabilities.currentExtent.height;
|
|
viewport.minDepth = 0.0f;
|
|
viewport.maxDepth = 1.0f;
|
|
|
|
VkRect2D scissor{};
|
|
scissor.offset = {0, 0};
|
|
scissor.extent = info.swapDetails.capabilities.currentExtent;
|
|
|
|
VkPipelineViewportStateCreateInfo viewportState{};
|
|
viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
|
|
viewportState.viewportCount = 1;
|
|
viewportState.pViewports = &viewport;
|
|
viewportState.scissorCount = 1;
|
|
viewportState.pScissors = &scissor;
|
|
|
|
VkPipelineRasterizationStateCreateInfo rasterizer{};
|
|
rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
|
|
rasterizer.depthClampEnable = VK_FALSE;
|
|
rasterizer.rasterizerDiscardEnable = VK_FALSE;
|
|
rasterizer.polygonMode = options.wireframe ? VK_POLYGON_MODE_LINE : VK_POLYGON_MODE_FILL;
|
|
rasterizer.lineWidth = 1.0f;
|
|
rasterizer.cullMode = VK_CULL_MODE_BACK_BIT;
|
|
rasterizer.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
|
|
rasterizer.depthBiasEnable = VK_FALSE;
|
|
rasterizer.depthBiasConstantFactor = 0.0f;
|
|
rasterizer.depthBiasClamp = 0.0f;
|
|
rasterizer.depthBiasSlopeFactor = 0.0f;
|
|
|
|
VkPipelineMultisampleStateCreateInfo multisampling{};
|
|
multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
|
|
multisampling.rasterizationSamples = info.samples;
|
|
//MAYBE: add option
|
|
multisampling.sampleShadingEnable = info.features.sampleRateShading && hasSamples;
|
|
multisampling.minSampleShading = .2f;
|
|
multisampling.pSampleMask = nullptr;
|
|
multisampling.alphaToCoverageEnable = VK_FALSE;
|
|
multisampling.alphaToOneEnable = VK_FALSE;
|
|
|
|
{ // World pipeline
|
|
VkPushConstantRange pushRange{};
|
|
pushRange.offset = 0;
|
|
pushRange.size = sizeof(ModelPush);
|
|
pushRange.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
|
|
setLayout(worldPass, {voxelDescriptorSet}, {pushRange});
|
|
|
|
auto unitSize = 1; //TODO: load from world.voxel_density
|
|
std::vector<unsigned char> speData;
|
|
std::vector<VkSpecializationMapEntry> speIndex;
|
|
auto specialization = makeSpecialization({
|
|
{0, data_view(&options.voxel.fog, sizeof(bool))},
|
|
{1, data_view(&options.voxel.pbr, sizeof(bool))},
|
|
{2, data_view(&options.voxel.triplanar, sizeof(bool))},
|
|
{3, data_view(&options.voxel.stochastic, sizeof(bool))},
|
|
{4, data_view(&options.voxel.blend, sizeof(bool))},
|
|
{5, data_view(&options.voxel.curvature, sizeof(bool))},
|
|
{6, data_view(&options.voxel.curv_depth, sizeof(bool))},
|
|
{16, data_view(&unitSize, sizeof(int))}}, speData, speIndex);
|
|
|
|
auto withGeometry = options.voxel.geometry; //MAYBE: && features.geometry
|
|
auto shaderStages = setShaders(worldPass, withGeometry ? "Tris.geo" : "Tris", withGeometry, &specialization);
|
|
|
|
VkPipelineVertexInputStateCreateInfo vertexInputInfo{};
|
|
vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
|
|
|
|
auto bindingDescription = Model::getBindingDescription();
|
|
vertexInputInfo.vertexBindingDescriptionCount = 1;
|
|
vertexInputInfo.pVertexBindingDescriptions = &bindingDescription;
|
|
auto attributeDescriptions = Model::getAttributeDescriptions();
|
|
vertexInputInfo.vertexAttributeDescriptionCount = attributeDescriptions.size();
|
|
vertexInputInfo.pVertexAttributeDescriptions = attributeDescriptions.data();
|
|
|
|
VkGraphicsPipelineCreateInfo pipelineInfo{};
|
|
pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
|
|
pipelineInfo.stageCount = shaderStages.size();
|
|
pipelineInfo.pStages = shaderStages.data();
|
|
pipelineInfo.pVertexInputState = &vertexInputInfo;
|
|
pipelineInfo.pInputAssemblyState = &trisInputAssembly;
|
|
pipelineInfo.pViewportState = &viewportState;
|
|
pipelineInfo.pRasterizationState = &rasterizer;
|
|
pipelineInfo.pMultisampleState = &multisampling;
|
|
pipelineInfo.pDepthStencilState = &depthStencil;
|
|
pipelineInfo.pColorBlendState = &colorBlending;
|
|
pipelineInfo.pDynamicState = nullptr;
|
|
|
|
pipelineInfo.layout = worldPass.layout;
|
|
pipelineInfo.renderPass = renderPass;
|
|
pipelineInfo.subpass = 0;
|
|
|
|
pipelineInfo.basePipelineHandle = VK_NULL_HANDLE;
|
|
pipelineInfo.basePipelineIndex = -1;
|
|
|
|
if (vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipelineInfo, ALLOC, &worldPass.pipeline) != VK_SUCCESS) {
|
|
FATAL("Failed to create graphics pipeline!");
|
|
}
|
|
}
|
|
{ // Indicator pipeline
|
|
VkPushConstantRange pushRange{};
|
|
pushRange.offset = 0;
|
|
pushRange.size = sizeof(ModelPush);
|
|
pushRange.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
|
|
setLayout(indicPass, {indicDescriptorSet}, {pushRange});
|
|
auto shaderStages = setShaders(indicPass, "Color");
|
|
|
|
VkPipelineInputAssemblyStateCreateInfo lineInputAssembly{};
|
|
lineInputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
|
|
lineInputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
|
|
lineInputAssembly.primitiveRestartEnable = VK_FALSE;
|
|
|
|
VkPipelineVertexInputStateCreateInfo vertexInputInfo{};
|
|
vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
|
|
auto bindingDescription = Indicator::getBindingDescription();
|
|
vertexInputInfo.vertexBindingDescriptionCount = 1;
|
|
vertexInputInfo.pVertexBindingDescriptions = &bindingDescription;
|
|
auto attributeDescriptions = Indicator::getAttributeDescription();
|
|
vertexInputInfo.vertexAttributeDescriptionCount = attributeDescriptions.size();
|
|
vertexInputInfo.pVertexAttributeDescriptions = attributeDescriptions.data();
|
|
|
|
VkGraphicsPipelineCreateInfo pipelineInfo{};
|
|
pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
|
|
pipelineInfo.stageCount = shaderStages.size();
|
|
pipelineInfo.pStages = shaderStages.data();
|
|
pipelineInfo.pVertexInputState = &vertexInputInfo;
|
|
pipelineInfo.pInputAssemblyState = &lineInputAssembly;
|
|
pipelineInfo.pViewportState = &viewportState;
|
|
pipelineInfo.pRasterizationState = &rasterizer;
|
|
pipelineInfo.pMultisampleState = &multisampling;
|
|
pipelineInfo.pDepthStencilState = &depthStencil;
|
|
pipelineInfo.pColorBlendState = &colorBlending;
|
|
pipelineInfo.pDynamicState = nullptr;
|
|
|
|
pipelineInfo.layout = indicPass.layout;
|
|
pipelineInfo.renderPass = renderPass;
|
|
pipelineInfo.subpass = 1;
|
|
|
|
pipelineInfo.basePipelineHandle = VK_NULL_HANDLE;
|
|
pipelineInfo.basePipelineIndex = -1;
|
|
|
|
if (vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipelineInfo, ALLOC, &indicPass.pipeline) != VK_SUCCESS) {
|
|
FATAL("Failed to create graphics pipeline!");
|
|
}
|
|
}
|
|
{ // Sky pipeline
|
|
setLayout(skyPass, {skyDescriptorSet}, {});
|
|
auto shaderStages = setShaders(skyPass, "Sky");
|
|
|
|
depthStencil.depthCompareOp = VK_COMPARE_OP_LESS_OR_EQUAL;
|
|
|
|
VkPipelineVertexInputStateCreateInfo vertexInputInfo{};
|
|
vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
|
|
auto bindingDescription = Shape::getBindingDescription();
|
|
vertexInputInfo.vertexBindingDescriptionCount = 1;
|
|
vertexInputInfo.pVertexBindingDescriptions = &bindingDescription;
|
|
auto attributeDescription = Shape::getAttributeDescription();
|
|
vertexInputInfo.vertexAttributeDescriptionCount = 1;
|
|
vertexInputInfo.pVertexAttributeDescriptions = &attributeDescription;
|
|
|
|
VkGraphicsPipelineCreateInfo pipelineInfo{};
|
|
pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
|
|
pipelineInfo.stageCount = shaderStages.size();
|
|
pipelineInfo.pStages = shaderStages.data();
|
|
pipelineInfo.pVertexInputState = &vertexInputInfo;
|
|
pipelineInfo.pInputAssemblyState = &trisInputAssembly;
|
|
pipelineInfo.pViewportState = &viewportState;
|
|
pipelineInfo.pRasterizationState = &rasterizer;
|
|
pipelineInfo.pMultisampleState = &multisampling;
|
|
pipelineInfo.pDepthStencilState = &depthStencil;
|
|
pipelineInfo.pColorBlendState = &colorBlending;
|
|
pipelineInfo.pDynamicState = nullptr;
|
|
|
|
pipelineInfo.layout = skyPass.layout;
|
|
pipelineInfo.renderPass = renderPass;
|
|
pipelineInfo.subpass = 2;
|
|
|
|
pipelineInfo.basePipelineHandle = VK_NULL_HANDLE;
|
|
pipelineInfo.basePipelineIndex = -1;
|
|
|
|
if (vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipelineInfo, ALLOC, &skyPass.pipeline) != VK_SUCCESS) {
|
|
FATAL("Failed to create graphics pipeline!");
|
|
}
|
|
}
|
|
}
|
|
Pipeline::~Pipeline() {
|
|
auto destroy = [&](Subpass &pass) {
|
|
vkDestroyShaderModule(device, pass.fsShader, ALLOC);
|
|
vkDestroyShaderModule(device, pass.vsShader, ALLOC);
|
|
vkDestroyPipeline(device, pass.pipeline, ALLOC);
|
|
vkDestroyPipelineLayout(device, pass.layout, ALLOC);
|
|
};
|
|
|
|
destroy(worldPass);
|
|
destroy(skyPass);
|
|
|
|
vkDestroyDescriptorSetLayout(device, voxelDescriptorSet, ALLOC);
|
|
vkDestroyDescriptorSetLayout(device, indicDescriptorSet, ALLOC);
|
|
vkDestroyDescriptorSetLayout(device, skyDescriptorSet, ALLOC);
|
|
vkDestroyRenderPass(device, renderPass, ALLOC);
|
|
} |