pipeline.c

#include <kiba/gpu/pipeline.h>
#include <kiba/gpu/vulkan/allocator.h>
#include <kiba/gpu/vulkan/conv.h>
#include <kiba/gpu/vulkan/device.h>
#include <kiba/gpu/vulkan/util.h>
 
b8 gpu_backend_pipeline_layout_create(struct gpu_backend_pipeline_layout   *layout,
                                      struct gpu_backend_device            *device,
                                      struct gpu_pipeline_layout_descriptor desc) {
    VkPipelineLayoutCreateInfo info = {
        .sType                  = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
        .setLayoutCount         = desc.bind_group_layouts ? (u32) array_size(desc.bind_group_layouts) : 0,
        .pSetLayouts            = desc.bind_group_layouts,
        .pushConstantRangeCount = 0,  // TODO
        .pPushConstantRanges    = NULL,
    };
    VK_CALL_B8(vkCreatePipelineLayout(device->logical, &info, &vk_alloc.vulkan_callbacks, &layout->raw));
    vk_device_set_object_name(device->logical, VK_OBJECT_TYPE_PIPELINE_LAYOUT, layout->raw, desc.label);
    return true;
}
 
void gpu_backend_pipeline_layout_destroy(struct gpu_backend_pipeline_layout *layout,
                                         struct gpu_backend_device          *device) {
    if (layout->raw != VK_NULL_HANDLE) {
        vkDestroyPipelineLayout(device->logical, layout->raw, &vk_alloc.vulkan_callbacks);
        layout->raw = VK_NULL_HANDLE;
    }
}
 
KB_LOCAL b8 gpu_backend_render_pipeline_create(struct gpu_backend_pipeline          *pipeline,
                                               struct gpu_backend_device            *device,
                                               struct gpu_render_pipeline_descriptor desc) {
    VkDynamicState dynamic_states[] = {
        VK_DYNAMIC_STATE_VIEWPORT,
        VK_DYNAMIC_STATE_SCISSOR,
        // TODO may need more, e.g. blend state, stencil reference etc.
    };
 
    // state that can be changed after pipeline creation
    VkPipelineDynamicStateCreateInfo dynamic_state_info = {
        .sType             = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
        .dynamicStateCount = sizeof(dynamic_states) / sizeof(dynamic_states[0]),
        .pDynamicStates    = dynamic_states,
    };
 
    // vertex layouts
    array_of(VkVertexInputBindingDescription) vertex_input_bindings = KB_NULL;
    array_of(VkVertexInputAttributeDescription) vertex_attributes   = KB_NULL;
    VkPipelineVertexInputStateCreateInfo vertex_input_info          = {
                 .sType                           = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
                 .vertexBindingDescriptionCount   = 0,
                 .pVertexBindingDescriptions      = vertex_input_bindings,
                 .vertexAttributeDescriptionCount = 0,
                 .pVertexAttributeDescriptions    = vertex_attributes,
    };
    if (desc.vertex.buffers != KB_NULL) {
        usize attribute_count = 0;
        array_for_each(struct gpu_vertex_buffer_layout, layout, desc.vertex.buffers) {
            attribute_count += array_size(layout->attributes);
        }
        vertex_input_bindings =
            array_create(VkVertexInputBindingDescription, array_size(desc.vertex.buffers), &vk_alloc.kiba_alloc);
        if (vertex_input_bindings == KB_NULL) {
            KB_ERROR("could not allocate list of pipeline vertex inputs");
            return false;
        }
        vertex_attributes = array_create(VkVertexInputAttributeDescription, attribute_count, &vk_alloc.kiba_alloc);
        if (vertex_attributes == KB_NULL) {
            KB_ERROR("could not allocate list of pipeline vertex input's attribute descriptions");
            array_destroy(vertex_input_bindings);
            return false;
        }
        u32 binding = 0;
        array_for_each(struct gpu_vertex_buffer_layout, layout, desc.vertex.buffers) {
            VkVertexInputBindingDescription input_binding_description = {
                .binding   = binding,
                .inputRate = vk_convert_step_mode(layout->step_mode),
                .stride    = (u32) layout->stride,
            };
            array_push(vertex_input_bindings, input_binding_description);
            u32 location = 0;
            array_for_each(struct gpu_vertex_buffer_layout_attribute, attribute, layout->attributes) {
                VkVertexInputAttributeDescription attribute_description = {
                    .binding  = binding,
                    .location = location++,
                    .format   = vk_convert_vertex_format(attribute->format),
                    .offset   = (u32) attribute->offset,
                };
                array_push(vertex_attributes, attribute_description);
            }
            ++binding;
        }
        vertex_input_info.vertexBindingDescriptionCount   = (u32) array_size(vertex_input_bindings);
        vertex_input_info.pVertexBindingDescriptions      = vertex_input_bindings;
        vertex_input_info.vertexAttributeDescriptionCount = (u32) array_size(vertex_attributes);
        vertex_input_info.pVertexAttributeDescriptions    = vertex_attributes;
    }
 
    // kind of geometry
    VkPipelineInputAssemblyStateCreateInfo input_assembly_info = {
        .sType                  = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
        .topology               = vk_convert_primitive_topology(desc.primitive.topology),
        .primitiveRestartEnable = VK_FALSE,
    };
 
    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_convert_polygon_mode(desc.primitive.polygon_mode),
        .lineWidth               = 1.0f,
        .cullMode                = vk_convert_cull_mode(desc.primitive.cull_mode),
        .frontFace               = vk_convert_front_face(desc.primitive.front_face),
        .depthBiasEnable         = VK_FALSE,  // TODO when to toggle on
 
        .depthBiasConstantFactor = desc.depth_stencil.depth_bias.constant,
        .depthBiasClamp          = desc.depth_stencil.depth_bias.clamp,
        .depthBiasSlopeFactor    = desc.depth_stencil.depth_bias.slope_scale,
    };
 
    // multisampling TODO
    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,
    };
 
    // key to find compatible renderpass
    struct vk_renderpass_key rp_key = {
        0  // TODO would fill sample_count and multiview here
    };
 
    // TODO descriptor.fragment.active not yet respected
    // color blending
    array_of(VkPipelineColorBlendAttachmentState) color_blend_attachments =
        array_create(VkPipelineColorBlendAttachmentState, array_size(desc.fragment.targets), &vk_alloc.kiba_alloc);
    if (color_blend_attachments == KB_NULL) {
        KB_ERROR("failed to allocate list of color blend attachments");
        return false;
    }
    array_for_each(struct gpu_color_target_state, target_state, desc.fragment.targets) {
        VkPipelineColorBlendAttachmentState color_blend_attachment = {
            .colorWriteMask      = target_state->write_mask,
            .blendEnable         = target_state->blend.active,
            .srcColorBlendFactor = VK_BLEND_FACTOR_ONE,  // TODO not yet implemented in the struct
            .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,
        };
        array_push(color_blend_attachments, color_blend_attachment);
        struct vk_attachment_key cak = {
            .format = vk_convert_texture_format(target_state->format),
            .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
            .ops    = GPU_ATTACHMENT_OP_ALL,
        };
        rp_key.colors[rp_key.color_count++].base = cak;
    }
 
    VkPipelineColorBlendStateCreateInfo color_blend_info = {
        .sType           = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
        .logicOpEnable   = VK_FALSE,
        .logicOp         = VK_LOGIC_OP_COPY,
        .attachmentCount = (u32) array_size(color_blend_attachments),
        .pAttachments    = color_blend_attachments,
        .blendConstants  = {0.0f, 0.0f, 0.0f, 0.0f},
    };
 
    // TODO use stencil components? also rest of depth stuff
    VkPipelineDepthStencilStateCreateInfo depth_info = {
        .sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
        .depthTestEnable =
            desc.depth_stencil.depth_compare != GPU_COMPARE_FUNC_ALWAYS || desc.depth_stencil.depth_write_enabled,
        .depthWriteEnable      = desc.depth_stencil.depth_write_enabled,
        .depthCompareOp        = vk_convert_compare_function(desc.depth_stencil.depth_compare),
        .depthBoundsTestEnable = VK_FALSE,  // could be used to discard fragments outside of bounds
        .minDepthBounds        = 0.f,
        .maxDepthBounds        = 1.f,
        .stencilTestEnable = VK_FALSE,  // TODO could be used to perform stencil tests, uses `front` and `back` fields
    };
    // TODO fill rp_key with depth info in case it's needed
 
    // get appropriate render pass
    VkRenderPass renderpass;
    if (!vk_device_create_renderpass(device, rp_key, &renderpass)) {
        KB_ERROR("could not create renderpass for pipeline");
        return false;
    }
 
    // shaders
    VkPipelineShaderStageCreateInfo shader_stages[2] = {
        {
         .sType  = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
         .stage  = VK_SHADER_STAGE_VERTEX_BIT,
         .module = desc.vertex.shader->bs.raw,
         .pName  = desc.vertex.entry_point,
         },
        {
         .sType  = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
         .stage  = VK_SHADER_STAGE_FRAGMENT_BIT,
         .module = desc.fragment.shader->bs.raw,
         .pName  = desc.fragment.entry_point,
         },
    };
 
    VkGraphicsPipelineCreateInfo pipeline_info = {
        .sType               = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
        .stageCount          = sizeof(shader_stages) / sizeof(shader_stages[0]),
        .pStages             = shader_stages,
        .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              = desc.layout->bl.raw,
        .renderPass          = renderpass,
        .subpass             = 0,
        .basePipelineHandle  = VK_NULL_HANDLE,
        .basePipelineIndex   = -1,
    };
    VK_CALL_B8(vkCreateGraphicsPipelines(device->logical,
                                         VK_NULL_HANDLE,
                                         1,
                                         &pipeline_info,
                                         &vk_alloc.vulkan_callbacks,
                                         &pipeline->raw));
    vk_device_set_object_name(device->logical, VK_OBJECT_TYPE_PIPELINE, pipeline->raw, desc.label);
    array_destroy(&color_blend_attachments);
    array_destroy(&vertex_attributes);
    array_destroy(&vertex_input_bindings);
 
    return true;
}
 
void gpu_backend_render_pipeline_destroy(struct gpu_backend_pipeline *pipeline, struct gpu_backend_device *device) {
    if (pipeline->raw != VK_NULL_HANDLE) {
        vkDestroyPipeline(device->logical, pipeline->raw, &vk_alloc.vulkan_callbacks);
        pipeline->raw = VK_NULL_HANDLE;
    }
}