pipeline.c

#include <kiba/renderer/vulkan/pipeline.h>
 
#include <kiba/renderer/vulkan/shader.h>
#include <kiba/renderer/vulkan/vertex_buffer.h>
 
b8 vulkan_pipeline_create(vulkan_context *context) {
    if ((context->pipeline.shaders = array_create(VkPipelineShaderStageCreateInfo, 2, &context->alloc.kiba_alloc))
        == KB_NULL) {
        KB_ERROR("could not create array to hold shader info");
        return false;
    }
    if (!vulkan_shader_create(context, "assets/shaders/builtin.test-shader.vert.spv", SHADER_TYPE_VERTEX)) {
        KB_ERROR("could not load vertex shader code");
        return false;
    }
    if (!vulkan_shader_create(context, "assets/shaders/builtin.test-shader.frag.spv", SHADER_TYPE_FRAGMENT)) {
        KB_ERROR("could not load fragment shader code");
        return false;
    }
 
    VkDynamicState dynamic_states[] = {
        VK_DYNAMIC_STATE_VIEWPORT,
        VK_DYNAMIC_STATE_SCISSOR,
    };
 
    // state that can be changed after pipeline creation
    VkPipelineDynamicStateCreateInfo dynamic_state_info = {
        .sType             = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
        .dynamicStateCount = 2,
        .pDynamicStates    = dynamic_states,
    };
 
    // format of vertex data
    VkVertexInputBindingDescription input_binding_description = {
        .binding   = 0,
        .inputRate = VK_VERTEX_INPUT_RATE_VERTEX,
        .stride    = sizeof(vulkan_vertex),
    };
    VkVertexInputAttributeDescription attribute_descriptions[3] = {
        {
         .binding  = 0,
         .location = 0,
         .format   = VK_FORMAT_R32G32B32_SFLOAT,
         .offset   = 0,
         },
        {
         .binding  = 0,
         .location = 1,
         .format   = VK_FORMAT_R32G32B32_SFLOAT,
         .offset   = sizeof(float) * 3,
         },
        {
         .binding  = 0,
         .location = 2,
         .format   = VK_FORMAT_R32G32_SFLOAT,
         .offset   = sizeof(float) * 6,
         },
    };
    VkPipelineVertexInputStateCreateInfo vertex_input_info = {
        .sType                           = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
        .vertexBindingDescriptionCount   = 1,
        .pVertexBindingDescriptions      = &input_binding_description,
        .vertexAttributeDescriptionCount = sizeof(attribute_descriptions) / sizeof(attribute_descriptions[0]),
        .pVertexAttributeDescriptions    = attribute_descriptions,
    };
 
    // kind of geometry
    VkPipelineInputAssemblyStateCreateInfo input_assembly_info = {
        .sType                  = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
        .topology               = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
        .primitiveRestartEnable = VK_FALSE,
    };
 
    // viewports and scissors, if dynamic must be added before drawing instead of here
    /*VkViewport viewport = {
        .x        = 0.0f,
        .y        = 0.0f,
        .width    = (float) context->swap_chain.extent.width,
        .height   = (float) context->swap_chain.extent.height,
        .minDepth = 0.0f,
        .maxDepth = 1.0f,
    };
    VkRect2D scissors = {
        .offset = {0, 0},
        .extent = context->swap_chain.extent,
    };*/
    VkPipelineViewportStateCreateInfo viewport_state_info = {
        .sType         = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
        .viewportCount = 1,
        .scissorCount  = 1,
    };
 
    // rasterization
    VkPipelineRasterizationStateCreateInfo rasterizer_info = {
        .sType                   = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
        .depthClampEnable        = VK_FALSE,
        .rasterizerDiscardEnable = VK_FALSE,
        .polygonMode             = VK_POLYGON_MODE_FILL,
        .lineWidth               = 1.0f,
        .cullMode                = VK_CULL_MODE_BACK_BIT,
        .frontFace               = VK_FRONT_FACE_COUNTER_CLOCKWISE,
        .depthBiasEnable         = VK_FALSE,
        .depthBiasConstantFactor = 0.0f,
        .depthBiasClamp          = 0.0f,
        .depthBiasSlopeFactor    = 0.0f,
    };
 
    // multisampling
    VkPipelineMultisampleStateCreateInfo multisampling_info = {
        .sType                 = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
        .sampleShadingEnable   = VK_FALSE,
        .rasterizationSamples  = VK_SAMPLE_COUNT_1_BIT,
        .minSampleShading      = 1.0f,
        .pSampleMask           = NULL,
        .alphaToCoverageEnable = VK_FALSE,
        .alphaToOneEnable      = VK_FALSE,
    };
 
    // color blending
    VkPipelineColorBlendAttachmentState color_blend_attachment = {
        .colorWriteMask =
            VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT,
        .blendEnable         = VK_FALSE,
        .srcColorBlendFactor = VK_BLEND_FACTOR_ONE,
        .dstColorBlendFactor = VK_BLEND_FACTOR_ZERO,
        .colorBlendOp        = VK_BLEND_OP_ADD,
        .srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE,
        .dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO,
        .alphaBlendOp        = VK_BLEND_OP_ADD,
    };
    VkPipelineColorBlendStateCreateInfo color_blend_info = {
        .sType           = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
        .logicOpEnable   = VK_FALSE,
        .logicOp         = VK_LOGIC_OP_COPY,
        .attachmentCount = 1,
        .pAttachments    = &color_blend_attachment,
        .blendConstants  = {0.0f, 0.0f, 0.0f, 0.0f},
    };
 
    // pipeline layout (uniforms etc)
    VkPipelineLayoutCreateInfo pipeline_layout_info = {
        .sType                  = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
        .setLayoutCount         = 1,
        .pSetLayouts            = &context->pipeline.descriptor_set_layout,
        .pushConstantRangeCount = 0,
        .pPushConstantRanges    = NULL,
    };
    VK_CALL_B8(vkCreatePipelineLayout(context->device.logical,
                                      &pipeline_layout_info,
                                      &context->alloc.vulkan_callbacks,
                                      &context->pipeline.layout));
 
    VkPipelineDepthStencilStateCreateInfo depth_info = {
        .sType                 = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
        .depthTestEnable       = VK_TRUE,
        .depthWriteEnable      = VK_TRUE,
        .depthCompareOp        = VK_COMPARE_OP_LESS,
        .depthBoundsTestEnable = VK_FALSE,  // could be used to discard fragments outside of bounds
        .minDepthBounds        = 0.f,
        .maxDepthBounds        = 1.f,
        .stencilTestEnable     = VK_FALSE,  // could be used to perform stencil tests, uses `front` and `back` fields
    };
 
    VkGraphicsPipelineCreateInfo pipeline_info = {
        .sType               = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
        .stageCount          = 2,
        .pStages             = context->pipeline.shaders,
        .pVertexInputState   = &vertex_input_info,
        .pInputAssemblyState = &input_assembly_info,
        .pViewportState      = &viewport_state_info,
        .pRasterizationState = &rasterizer_info,
        .pMultisampleState   = &multisampling_info,
        .pDepthStencilState  = &depth_info,
        .pColorBlendState    = &color_blend_info,
        .pDynamicState       = &dynamic_state_info,
        .layout              = context->pipeline.layout,
        .renderPass          = context->pipeline.renderpass,
        .subpass             = 0,
        .basePipelineHandle  = VK_NULL_HANDLE,
        .basePipelineIndex   = -1,
    };
    VK_CALL_B8(vkCreateGraphicsPipelines(context->device.logical,
                                         VK_NULL_HANDLE,
                                         1,
                                         &pipeline_info,
                                         &context->alloc.vulkan_callbacks,
                                         &context->pipeline.graphics_pipeline));
 
    return true;
}
 
void vulkan_pipeline_destroy(vulkan_context *context) {
    vkDestroyPipeline(context->device.logical, context->pipeline.graphics_pipeline, &context->alloc.vulkan_callbacks);
    vkDestroyPipelineLayout(context->device.logical, context->pipeline.layout, &context->alloc.vulkan_callbacks);
    array_for_each(VkPipelineShaderStageCreateInfo, shader_create_info, context->pipeline.shaders) {
        vkDestroyShaderModule(context->device.logical, shader_create_info->module, &context->alloc.vulkan_callbacks);
    }
    array_destroy(&context->pipeline.shaders);
}