From 8a47e70846c89ab17b06583fcb8106d673819ef0 Mon Sep 17 00:00:00 2001 From: Robert Konrad Date: Sun, 9 Feb 2025 01:05:43 +0100 Subject: [PATCH] Make pipeline initialization compile --- .../Vulkan/Sources/kope/vulkan/pipeline.c | 539 ++++++++++++------ .../Sources/kope/vulkan/pipeline_structs.h | 2 +- 2 files changed, 356 insertions(+), 185 deletions(-) diff --git a/Backends/Graphics5/Vulkan/Sources/kope/vulkan/pipeline.c b/Backends/Graphics5/Vulkan/Sources/kope/vulkan/pipeline.c index 2f02a790c..de3ed07ae 100644 --- a/Backends/Graphics5/Vulkan/Sources/kope/vulkan/pipeline.c +++ b/Backends/Graphics5/Vulkan/Sources/kope/vulkan/pipeline.c @@ -3,7 +3,212 @@ #include -void kope_vulkan_render_pipeline_init(kope_vulkan_device *device, kope_vulkan_render_pipeline *pipe, const kope_vulkan_render_pipeline_parameters *parameters) { +static uint32_t vertex_attribute_size(kope_vulkan_vertex_format format) { + switch (format) { + case KOPE_VULKAN_VERTEX_FORMAT_UINT8X2: + return 2; + case KOPE_VULKAN_VERTEX_FORMAT_UINT8X4: + return 4; + case KOPE_VULKAN_VERTEX_FORMAT_SINT8X2: + return 2; + case KOPE_VULKAN_VERTEX_FORMAT_SINT8X4: + return 4; + case KOPE_VULKAN_VERTEX_FORMAT_UNORM8X2: + return 2; + case KOPE_VULKAN_VERTEX_FORMAT_UNORM8X4: + return 4; + case KOPE_VULKAN_VERTEX_FORMAT_SNORM8X2: + return 2; + case KOPE_VULKAN_VERTEX_FORMAT_SNORM8X4: + return 4; + case KOPE_VULKAN_VERTEX_FORMAT_UINT16X2: + return 4; + case KOPE_VULKAN_VERTEX_FORMAT_UINT16X4: + return 8; + case KOPE_VULKAN_VERTEX_FORMAT_SINT16X2: + return 4; + case KOPE_VULKAN_VERTEX_FORMAT_SINT16X4: + return 8; + case KOPE_VULKAN_VERTEX_FORMAT_UNORM16X2: + return 4; + case KOPE_VULKAN_VERTEX_FORMAT_UNORM16X4: + return 8; + case KOPE_VULKAN_VERTEX_FORMAT_SNORM16X2: + return 4; + case KOPE_VULKAN_VERTEX_FORMAT_SNORM16X4: + return 8; + case KOPE_VULKAN_VERTEX_FORMAT_FLOAT16X2: + return 4; + case KOPE_VULKAN_VERTEX_FORMAT_FLOAT16X4: + return 8; + case KOPE_VULKAN_VERTEX_FORMAT_FLOAT32: + return 4; + case KOPE_VULKAN_VERTEX_FORMAT_FLOAT32X2: + return 8; + case KOPE_VULKAN_VERTEX_FORMAT_FLOAT32X3: + return 12; + case KOPE_VULKAN_VERTEX_FORMAT_FLOAT32X4: + return 16; + case KOPE_VULKAN_VERTEX_FORMAT_UINT32: + return 4; + case KOPE_VULKAN_VERTEX_FORMAT_UINT32X2: + return 8; + case KOPE_VULKAN_VERTEX_FORMAT_UINT32X3: + return 12; + case KOPE_VULKAN_VERTEX_FORMAT_UINT32X4: + return 16; + case KOPE_VULKAN_VERTEX_FORMAT_SINT32: + return 4; + case KOPE_VULKAN_VERTEX_FORMAT_SINT32X2: + return 8; + case KOPE_VULKAN_VERTEX_FORMAT_SINT32X3: + return 12; + case KOPE_VULKAN_VERTEX_FORMAT_SINT32X4: + return 16; + case KOPE_VULKAN_VERTEX_FORMAT_UNORM10_10_10_2: + return 4; + } + + return 0; +} + +static VkCullModeFlags convert_cull_mode(kope_vulkan_cull_mode mode) { + switch (mode) { + case KOPE_VULKAN_CULL_MODE_NONE: + return VK_CULL_MODE_NONE; + case KOPE_VULKAN_CULL_MODE_FRONT: + return VK_CULL_MODE_FRONT_BIT; + case KOPE_VULKAN_CULL_MODE_BACK: + return VK_CULL_MODE_BACK_BIT; + } + + return VK_CULL_MODE_NONE; +} + +static VkBlendFactor convert_blend_factor(kope_vulkan_blend_factor factor) { + switch (factor) { + case KOPE_VULKAN_BLEND_FACTOR_ZERO: + return VK_BLEND_FACTOR_ZERO; + case KOPE_VULKAN_BLEND_FACTOR_ONE: + return VK_BLEND_FACTOR_ONE; + case KOPE_VULKAN_BLEND_FACTOR_SRC: + return VK_BLEND_FACTOR_SRC_COLOR; + case KOPE_VULKAN_BLEND_FACTOR_ONE_MINUS_SRC: + return VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR; + case KOPE_VULKAN_BLEND_FACTOR_SRC_ALPHA: + return VK_BLEND_FACTOR_SRC_ALPHA; + case KOPE_VULKAN_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA: + return VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA; + case KOPE_VULKAN_BLEND_FACTOR_DST: + return VK_BLEND_FACTOR_DST_COLOR; + case KOPE_VULKAN_BLEND_FACTOR_ONE_MINUS_DST: + return VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR; + case KOPE_VULKAN_BLEND_FACTOR_DST_ALPHA: + return VK_BLEND_FACTOR_DST_ALPHA; + case KOPE_VULKAN_BLEND_FACTOR_ONE_MINUS_DST_ALPHA: + return VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA; + case KOPE_VULKAN_BLEND_FACTOR_SRC_ALPHA_SATURATED: + return VK_BLEND_FACTOR_SRC_ALPHA_SATURATE; + case KOPE_VULKAN_BLEND_FACTOR_CONSTANT: + return VK_BLEND_FACTOR_CONSTANT_COLOR; + case KOPE_VULKAN_BLEND_FACTOR_ONE_MINUS_CONSTANT: + return VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR; + } + + return VK_BLEND_FACTOR_ONE; +} + +static VkBlendOp convert_blend_operation(kope_vulkan_blend_operation operation) { + switch (operation) { + case KOPE_VULKAN_BLEND_OPERATION_ADD: + return VK_BLEND_OP_ADD; + case KOPE_VULKAN_BLEND_OPERATION_SUBTRACT: + return VK_BLEND_OP_SUBTRACT; + case KOPE_VULKAN_BLEND_OPERATION_REVERSE_SUBTRACT: + return VK_BLEND_OP_REVERSE_SUBTRACT; + case KOPE_VULKAN_BLEND_OPERATION_MIN: + return VK_BLEND_OP_MIN; + case KOPE_VULKAN_BLEND_OPERATION_MAX: + return VK_BLEND_OP_MAX; + } + + return VK_BLEND_OP_ADD; +} + +static VkCompareOp convert_compare_mode(kope_g5_compare_function compare) { + switch (compare) { + case KOPE_G5_COMPARE_FUNCTION_NEVER: + return VK_COMPARE_OP_NEVER; + case KOPE_G5_COMPARE_FUNCTION_LESS: + return VK_COMPARE_OP_LESS; + case KOPE_G5_COMPARE_FUNCTION_EQUAL: + return VK_COMPARE_OP_EQUAL; + case KOPE_G5_COMPARE_FUNCTION_LESS_EQUAL: + return VK_COMPARE_OP_LESS_OR_EQUAL; + case KOPE_G5_COMPARE_FUNCTION_GREATER: + return VK_COMPARE_OP_GREATER; + case KOPE_G5_COMPARE_FUNCTION_NOT_EQUAL: + return VK_COMPARE_OP_NOT_EQUAL; + case KOPE_G5_COMPARE_FUNCTION_GREATER_EQUAL: + return VK_COMPARE_OP_GREATER_OR_EQUAL; + case KOPE_G5_COMPARE_FUNCTION_ALWAYS: + return VK_COMPARE_OP_ALWAYS; + } + + return VK_COMPARE_OP_ALWAYS; +} + +static VkShaderModule create_shader_module(kope_vulkan_device *device, const kope_vulkan_shader *shader) { + const VkShaderModuleCreateInfo shader_module_create_info = { + .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, + .pNext = NULL, + .codeSize = shader->size, + .pCode = (const uint32_t *)shader->data, + .flags = 0, + }; + + VkShaderModule module; + VkResult result = vkCreateShaderModule(device->device, &shader_module_create_info, NULL, &module); + assert(result == VK_SUCCESS); + + return module; +} + +void kope_vulkan_render_pipeline_init(kope_vulkan_device *device, kope_vulkan_render_pipeline *pipeline, + const kope_vulkan_render_pipeline_parameters *parameters) { + VkDescriptorSetLayoutBinding layoutBindings[18]; + memset(layoutBindings, 0, sizeof(layoutBindings)); + + layoutBindings[0].binding = 0; + layoutBindings[0].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + layoutBindings[0].descriptorCount = 1; + layoutBindings[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT; + layoutBindings[0].pImmutableSamplers = NULL; + + layoutBindings[1].binding = 1; + layoutBindings[1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + layoutBindings[1].descriptorCount = 1; + layoutBindings[1].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT; + layoutBindings[1].pImmutableSamplers = NULL; + + for (int i = 2; i < 18; ++i) { + layoutBindings[i].binding = i; + layoutBindings[i].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + layoutBindings[i].descriptorCount = 1; + layoutBindings[i].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_VERTEX_BIT; + layoutBindings[i].pImmutableSamplers = NULL; + } + + VkDescriptorSetLayoutCreateInfo descriptor_layout = {0}; + descriptor_layout.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + descriptor_layout.pNext = NULL; + descriptor_layout.bindingCount = 18; + descriptor_layout.pBindings = layoutBindings; + + VkDescriptorSetLayout descriptor_set_layout; + VkResult result = vkCreateDescriptorSetLayout(device->device, &descriptor_layout, NULL, &descriptor_set_layout); + assert(result == VK_SUCCESS); + /*memset(pipeline->impl.vertexLocations, 0, sizeof(kinc_internal_named_number) * KINC_INTERNAL_NAMED_NUMBER_COUNT); memset(pipeline->impl.vertexOffsets, 0, sizeof(kinc_internal_named_number) * KINC_INTERNAL_NAMED_NUMBER_COUNT); memset(pipeline->impl.fragmentLocations, 0, sizeof(kinc_internal_named_number) * KINC_INTERNAL_NAMED_NUMBER_COUNT); @@ -18,191 +223,148 @@ void kope_vulkan_render_pipeline_init(kope_vulkan_device *device, kope_vulkan_re .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, .pNext = NULL, .setLayoutCount = 1, - .pSetLayouts = &desc_layout, + .pSetLayouts = &descriptor_set_layout, }; - VkResult result = vkCreatePipelineLayout(device->device, &pipeline_layout_create_info, NULL, &pipe->pipeline_layout); + result = vkCreatePipelineLayout(device->device, &pipeline_layout_create_info, NULL, &pipeline->pipeline_layout); assert(result == VK_SUCCESS); - VkPipelineInputAssemblyStateCreateInfo ia = {0}; -#define dynamicStatesCount 2 - VkDynamicState dynamicStateEnables[dynamicStatesCount]; - VkPipelineDynamicStateCreateInfo dynamicState = {0}; + uint32_t attributes_count = 0; + uint32_t bindings_count = 0; + for (int i = 0; i < parameters->vertex.buffers_count; ++i) { + attributes_count += (uint32_t)parameters->vertex.buffers[i].attributes_count; + ++bindings_count; + } - memset(dynamicStateEnables, 0, sizeof(dynamicStateEnables)); - memset(&dynamicState, 0, sizeof(dynamicState)); - dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; - dynamicState.pDynamicStates = dynamicStateEnables; + VkVertexInputBindingDescription vi_bindings[64]; + VkVertexInputAttributeDescription vi_attrs[256]; - VkGraphicsPipelineCreateInfo pipeline_create_info = { - .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, - .layout = pipe->pipeline_layout, - .renderPass = VK_NULL_HANDLE, + const VkPipelineVertexInputStateCreateInfo vertex_input_state_create_info = { + .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, + .pNext = NULL, + .vertexBindingDescriptionCount = bindings_count, + .pVertexBindingDescriptions = vi_bindings, + .vertexAttributeDescriptionCount = attributes_count, + .pVertexAttributeDescriptions = vi_attrs, }; - int vertexAttributeCount = 0; - int vertexBindingCount = 0; - for (int i = 0; i < 16; ++i) { - if (pipeline->inputLayout[i] == NULL) { - break; - } - vertexAttributeCount += pipeline->inputLayout[i]->size; - vertexBindingCount++; - } - - VkVertexInputBindingDescription *vi_bindings = (VkVertexInputBindingDescription *)alloca(sizeof(VkVertexInputBindingDescription) * vertexBindingCount); - VkVertexInputAttributeDescription *vi_attrs = (VkVertexInputAttributeDescription *)alloca(sizeof(VkVertexInputAttributeDescription) * vertexAttributeCount); - - VkPipelineVertexInputStateCreateInfo vi = {0}; - memset(&vi, 0, sizeof(vi)); - vi.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; - vi.pNext = NULL; - vi.vertexBindingDescriptionCount = vertexBindingCount; - vi.pVertexBindingDescriptions = vi_bindings; - vi.vertexAttributeDescriptionCount = vertexAttributeCount; - vi.pVertexAttributeDescriptions = vi_attrs; - - uint32_t attr = 0; - for (int binding = 0; binding < vertexBindingCount; ++binding) { - uint32_t offset = 0; + uint32_t attribute_index = 0; + for (uint32_t binding_index = 0; binding_index < bindings_count; ++binding_index) { uint32_t stride = 0; - for (int i = 0; i < pipeline->inputLayout[binding]->size; ++i) { - kinc_g5_vertex_element_t element = pipeline->inputLayout[binding]->elements[i]; - - vi_attrs[attr].binding = binding; - vi_attrs[attr].location = find_number(pipeline->impl.vertexLocations, element.name); - vi_attrs[attr].offset = offset; - offset += kinc_g4_vertex_data_size(element.data); - stride += kinc_g4_vertex_data_size(element.data); - - switch (element.data) { - case KINC_G4_VERTEX_DATA_F32_1X: - vi_attrs[attr].format = VK_FORMAT_R32_SFLOAT; - break; - case KINC_G4_VERTEX_DATA_F32_2X: - vi_attrs[attr].format = VK_FORMAT_R32G32_SFLOAT; - break; - case KINC_G4_VERTEX_DATA_F32_3X: - vi_attrs[attr].format = VK_FORMAT_R32G32B32_SFLOAT; - break; - case KINC_G4_VERTEX_DATA_F32_4X: - vi_attrs[attr].format = VK_FORMAT_R32G32B32A32_SFLOAT; - break; - case KINC_G4_VERTEX_DATA_I8_1X: - vi_attrs[attr].format = VK_FORMAT_R8_SINT; - break; - case KINC_G4_VERTEX_DATA_U8_1X: - vi_attrs[attr].format = VK_FORMAT_R8_UINT; - break; - case KINC_G4_VERTEX_DATA_I8_1X_NORMALIZED: - vi_attrs[attr].format = VK_FORMAT_R8_SNORM; - break; - case KINC_G4_VERTEX_DATA_U8_1X_NORMALIZED: - vi_attrs[attr].format = VK_FORMAT_R8_UNORM; - break; - case KINC_G4_VERTEX_DATA_I8_2X: - vi_attrs[attr].format = VK_FORMAT_R8G8_SINT; + for (uint32_t attribute_index = 0; attribute_index < parameters->vertex.buffers[binding_index].attributes_count; ++attribute_index) { + kope_vulkan_vertex_attribute attribute = parameters->vertex.buffers[binding_index].attributes[attribute_index]; + vi_attrs[attribute_index].binding = binding_index; + vi_attrs[attribute_index].location = attribute.shader_location; + vi_attrs[attribute_index].offset = (uint32_t)attribute.offset; + stride += vertex_attribute_size(attribute.format); + + switch (attribute.format) { + case KOPE_VULKAN_VERTEX_FORMAT_FLOAT32: + vi_attrs[attribute_index].format = VK_FORMAT_R32_SFLOAT; break; - case KINC_G4_VERTEX_DATA_U8_2X: - vi_attrs[attr].format = VK_FORMAT_R8G8_UINT; + case KOPE_VULKAN_VERTEX_FORMAT_FLOAT32X2: + vi_attrs[attribute_index].format = VK_FORMAT_R32G32_SFLOAT; break; - case KINC_G4_VERTEX_DATA_I8_2X_NORMALIZED: - vi_attrs[attr].format = VK_FORMAT_R8G8_SNORM; + case KOPE_VULKAN_VERTEX_FORMAT_FLOAT32X3: + vi_attrs[attribute_index].format = VK_FORMAT_R32G32B32_SFLOAT; break; - case KINC_G4_VERTEX_DATA_U8_2X_NORMALIZED: - vi_attrs[attr].format = VK_FORMAT_R8G8_UNORM; + case KOPE_VULKAN_VERTEX_FORMAT_FLOAT32X4: + vi_attrs[attribute_index].format = VK_FORMAT_R32G32B32A32_SFLOAT; break; - case KINC_G4_VERTEX_DATA_I8_4X: - vi_attrs[attr].format = VK_FORMAT_R8G8B8A8_SINT; + case KOPE_VULKAN_VERTEX_FORMAT_SINT8X2: + vi_attrs[attribute_index].format = VK_FORMAT_R8G8_SINT; break; - case KINC_G4_VERTEX_DATA_U8_4X: - vi_attrs[attr].format = VK_FORMAT_R8G8B8A8_UINT; + case KOPE_VULKAN_VERTEX_FORMAT_UINT8X2: + vi_attrs[attribute_index].format = VK_FORMAT_R8G8_UINT; break; - case KINC_G4_VERTEX_DATA_I8_4X_NORMALIZED: - vi_attrs[attr].format = VK_FORMAT_R8G8B8A8_SNORM; + case KOPE_VULKAN_VERTEX_FORMAT_SNORM8X2: + vi_attrs[attribute_index].format = VK_FORMAT_R8G8_SNORM; break; - case KINC_G4_VERTEX_DATA_U8_4X_NORMALIZED: - vi_attrs[attr].format = VK_FORMAT_R8G8B8A8_UNORM; + case KOPE_VULKAN_VERTEX_FORMAT_UNORM8X2: + vi_attrs[attribute_index].format = VK_FORMAT_R8G8_UNORM; break; - case KINC_G4_VERTEX_DATA_I16_1X: - vi_attrs[attr].format = VK_FORMAT_R16_SINT; + case KOPE_VULKAN_VERTEX_FORMAT_SINT8X4: + vi_attrs[attribute_index].format = VK_FORMAT_R8G8B8A8_SINT; break; - case KINC_G4_VERTEX_DATA_U16_1X: - vi_attrs[attr].format = VK_FORMAT_R16_UINT; + case KOPE_VULKAN_VERTEX_FORMAT_UINT8X4: + vi_attrs[attribute_index].format = VK_FORMAT_R8G8B8A8_UINT; break; - case KINC_G4_VERTEX_DATA_I16_1X_NORMALIZED: - vi_attrs[attr].format = VK_FORMAT_R16_SNORM; + case KOPE_VULKAN_VERTEX_FORMAT_SNORM8X4: + vi_attrs[attribute_index].format = VK_FORMAT_R8G8B8A8_SNORM; break; - case KINC_G4_VERTEX_DATA_U16_1X_NORMALIZED: - vi_attrs[attr].format = VK_FORMAT_R16_UNORM; + case KOPE_VULKAN_VERTEX_FORMAT_UNORM8X4: + vi_attrs[attribute_index].format = VK_FORMAT_R8G8B8A8_UNORM; break; - case KINC_G4_VERTEX_DATA_I16_2X: - vi_attrs[attr].format = VK_FORMAT_R16G16_SINT; + case KOPE_VULKAN_VERTEX_FORMAT_SINT16X2: + vi_attrs[attribute_index].format = VK_FORMAT_R16G16_SINT; break; - case KINC_G4_VERTEX_DATA_U16_2X: - vi_attrs[attr].format = VK_FORMAT_R16G16_UINT; + case KOPE_VULKAN_VERTEX_FORMAT_UINT16X2: + vi_attrs[attribute_index].format = VK_FORMAT_R16G16_UINT; break; - case KINC_G4_VERTEX_DATA_I16_2X_NORMALIZED: - vi_attrs[attr].format = VK_FORMAT_R16G16_SNORM; + case KOPE_VULKAN_VERTEX_FORMAT_SNORM16X2: + vi_attrs[attribute_index].format = VK_FORMAT_R16G16_SNORM; break; - case KINC_G4_VERTEX_DATA_U16_2X_NORMALIZED: - vi_attrs[attr].format = VK_FORMAT_R16G16_UNORM; + case KOPE_VULKAN_VERTEX_FORMAT_UNORM16X2: + vi_attrs[attribute_index].format = VK_FORMAT_R16G16_UNORM; break; - case KINC_G4_VERTEX_DATA_I16_4X: - vi_attrs[attr].format = VK_FORMAT_R16G16B16A16_SINT; + case KOPE_VULKAN_VERTEX_FORMAT_SINT16X4: + vi_attrs[attribute_index].format = VK_FORMAT_R16G16B16A16_SINT; break; - case KINC_G4_VERTEX_DATA_U16_4X: - vi_attrs[attr].format = VK_FORMAT_R16G16B16A16_UINT; + case KOPE_VULKAN_VERTEX_FORMAT_UINT16X4: + vi_attrs[attribute_index].format = VK_FORMAT_R16G16B16A16_UINT; break; - case KINC_G4_VERTEX_DATA_I16_4X_NORMALIZED: - vi_attrs[attr].format = VK_FORMAT_R16G16B16A16_SNORM; + case KOPE_VULKAN_VERTEX_FORMAT_SNORM16X4: + vi_attrs[attribute_index].format = VK_FORMAT_R16G16B16A16_SNORM; break; - case KINC_G4_VERTEX_DATA_U16_4X_NORMALIZED: - vi_attrs[attr].format = VK_FORMAT_R16G16B16A16_UNORM; + case KOPE_VULKAN_VERTEX_FORMAT_UNORM16X4: + vi_attrs[attribute_index].format = VK_FORMAT_R16G16B16A16_UNORM; break; - case KINC_G4_VERTEX_DATA_I32_1X: - vi_attrs[attr].format = VK_FORMAT_R32_SINT; + case KOPE_VULKAN_VERTEX_FORMAT_SINT32: + vi_attrs[attribute_index].format = VK_FORMAT_R32_SINT; break; - case KINC_G4_VERTEX_DATA_U32_1X: - vi_attrs[attr].format = VK_FORMAT_R32_UINT; + case KOPE_VULKAN_VERTEX_FORMAT_UINT32: + vi_attrs[attribute_index].format = VK_FORMAT_R32_UINT; break; - case KINC_G4_VERTEX_DATA_I32_2X: - vi_attrs[attr].format = VK_FORMAT_R32G32_SINT; + case KOPE_VULKAN_VERTEX_FORMAT_SINT32X2: + vi_attrs[attribute_index].format = VK_FORMAT_R32G32_SINT; break; - case KINC_G4_VERTEX_DATA_U32_2X: - vi_attrs[attr].format = VK_FORMAT_R32G32_UINT; + case KOPE_VULKAN_VERTEX_FORMAT_UINT32X2: + vi_attrs[attribute_index].format = VK_FORMAT_R32G32_UINT; break; - case KINC_G4_VERTEX_DATA_I32_3X: - vi_attrs[attr].format = VK_FORMAT_R32G32B32_SINT; + case KOPE_VULKAN_VERTEX_FORMAT_SINT32X3: + vi_attrs[attribute_index].format = VK_FORMAT_R32G32B32_SINT; break; - case KINC_G4_VERTEX_DATA_U32_3X: - vi_attrs[attr].format = VK_FORMAT_R32G32B32_UINT; + case KOPE_VULKAN_VERTEX_FORMAT_UINT32X3: + vi_attrs[attribute_index].format = VK_FORMAT_R32G32B32_UINT; break; - case KINC_G4_VERTEX_DATA_I32_4X: - vi_attrs[attr].format = VK_FORMAT_R32G32B32A32_SINT; + case KOPE_VULKAN_VERTEX_FORMAT_SINT32X4: + vi_attrs[attribute_index].format = VK_FORMAT_R32G32B32A32_SINT; break; - case KINC_G4_VERTEX_DATA_U32_4X: - vi_attrs[attr].format = VK_FORMAT_R32G32B32A32_UINT; + case KOPE_VULKAN_VERTEX_FORMAT_UINT32X4: + vi_attrs[attribute_index].format = VK_FORMAT_R32G32B32A32_UINT; break; default: assert(false); break; } - attr++; } - vi_bindings[binding].binding = binding; - vi_bindings[binding].stride = stride; - vi_bindings[binding].inputRate = pipeline->inputLayout[binding]->instanced ? VK_VERTEX_INPUT_RATE_INSTANCE : VK_VERTEX_INPUT_RATE_VERTEX; + + vi_bindings[binding_index].binding = binding_index; + vi_bindings[binding_index].stride = stride; + vi_bindings[binding_index].inputRate = (parameters->vertex.buffers[binding_index].step_mode == KOPE_VULKAN_VERTEX_STEP_MODE_INSTANCE) + ? VK_VERTEX_INPUT_RATE_INSTANCE + : VK_VERTEX_INPUT_RATE_VERTEX; } - memset(&ia, 0, sizeof(ia)); - ia.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; - ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; + const VkPipelineInputAssemblyStateCreateInfo input_assembly_state_create_info = { + .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, + .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, + }; const VkPipelineRasterizationStateCreateInfo rasterization_state_create_info = { .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, .polygonMode = VK_POLYGON_MODE_FILL, - .cullMode = convert_cull_mode(pipeline->cullMode), + .cullMode = convert_cull_mode(parameters->primitive.cull_mode), .frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE, .depthClampEnable = VK_FALSE, .rasterizerDiscardEnable = VK_FALSE, @@ -212,26 +374,26 @@ void kope_vulkan_render_pipeline_init(kope_vulkan_device *device, kope_vulkan_re VkPipelineColorBlendAttachmentState att_state[8]; memset(att_state, 0, sizeof(att_state)); - for (int i = 0; i < pipeline->colorAttachmentCount; ++i) { + for (int i = 0; i < parameters->fragment.targets_count; ++i) { VkPipelineColorBlendAttachmentState a = { - .colorWriteMask = - (pipeline->colorWriteMaskRed[i] ? VK_COLOR_COMPONENT_R_BIT : 0) | (pipeline->colorWriteMaskGreen[i] ? VK_COLOR_COMPONENT_G_BIT : 0) | - (pipeline->colorWriteMaskBlue[i] ? VK_COLOR_COMPONENT_B_BIT : 0) | (pipeline->colorWriteMaskAlpha[i] ? VK_COLOR_COMPONENT_A_BIT : 0), - .blendEnable = pipeline->blend_source != KINC_G5_BLEND_ONE || pipeline->blend_destination != KINC_G5_BLEND_ZERO || - pipeline->alpha_blend_source != KINC_G5_BLEND_ONE || pipeline->alpha_blend_destination != KINC_G5_BLEND_ZERO, - .srcColorBlendFactor = convert_blend_factor(pipeline->blend_source), - .dstColorBlendFactor = convert_blend_factor(pipeline->blend_destination), - .colorBlendOp = convert_blend_operation(pipeline->blend_operation), - .srcAlphaBlendFactor = convert_blend_factor(pipeline->alpha_blend_source), - .dstAlphaBlendFactor = convert_blend_factor(pipeline->alpha_blend_destination), - .alphaBlendOp = convert_blend_operation(pipeline->alpha_blend_operation), + .colorWriteMask = parameters->fragment.targets[i].write_mask, + .blendEnable = parameters->fragment.targets[i].blend.color.src_factor != KOPE_VULKAN_BLEND_FACTOR_ONE || + parameters->fragment.targets[i].blend.color.dst_factor != KOPE_VULKAN_BLEND_FACTOR_ZERO || + parameters->fragment.targets[i].blend.alpha.src_factor != KOPE_VULKAN_BLEND_FACTOR_ONE || + parameters->fragment.targets[i].blend.alpha.dst_factor != KOPE_VULKAN_BLEND_FACTOR_ZERO, + .srcColorBlendFactor = convert_blend_factor(parameters->fragment.targets[i].blend.color.src_factor), + .dstColorBlendFactor = convert_blend_factor(parameters->fragment.targets[i].blend.color.dst_factor), + .colorBlendOp = convert_blend_operation(parameters->fragment.targets[i].blend.color.operation), + .srcAlphaBlendFactor = convert_blend_factor(parameters->fragment.targets[i].blend.alpha.src_factor), + .dstAlphaBlendFactor = convert_blend_factor(parameters->fragment.targets[i].blend.alpha.dst_factor), + .alphaBlendOp = convert_blend_operation(parameters->fragment.targets[i].blend.alpha.operation), }; att_state[i] = a; } const VkPipelineColorBlendStateCreateInfo color_blend_state_create_info = { .sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, - .attachmentCount = pipeline->colorAttachmentCount, + .attachmentCount = (uint32_t)parameters->fragment.targets_count, .pAttachments = att_state, }; @@ -241,14 +403,19 @@ void kope_vulkan_render_pipeline_init(kope_vulkan_device *device, kope_vulkan_re .scissorCount = 1, }; - dynamicStateEnables[dynamicState.dynamicStateCount++] = VK_DYNAMIC_STATE_VIEWPORT; - dynamicStateEnables[dynamicState.dynamicStateCount++] = VK_DYNAMIC_STATE_SCISSOR; + const VkDynamicState dynamic_states[] = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR}; + + const VkPipelineDynamicStateCreateInfo dynamic_state_create_info = { + .sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, + .pDynamicStates = dynamic_states, + .dynamicStateCount = sizeof(dynamic_states) / sizeof(dynamic_states[0]), + }; - VkPipelineDepthStencilStateCreateInfo depth_stencil_state_create_info = { + const VkPipelineDepthStencilStateCreateInfo depth_stencil_state_create_info = { .sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, - .depthTestEnable = pipeline->depthMode != KINC_G5_COMPARE_MODE_ALWAYS, - .depthWriteEnable = pipeline->depthWrite, - .depthCompareOp = convert_compare_mode(pipeline->depthMode), + .depthTestEnable = parameters->depth_stencil.depth_compare != KOPE_G5_COMPARE_FUNCTION_ALWAYS, + .depthWriteEnable = parameters->depth_stencil.depth_write_enabled, + .depthCompareOp = convert_compare_mode(parameters->depth_stencil.depth_compare), .depthBoundsTestEnable = VK_FALSE, .back = { @@ -265,42 +432,46 @@ void kope_vulkan_render_pipeline_init(kope_vulkan_device *device, kope_vulkan_re }, }; - VkPipelineMultisampleStateCreateInfo multi_sample_state_create_info = { + const VkPipelineMultisampleStateCreateInfo multisample_state_create_info = { .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, .pSampleMask = NULL, .rasterizationSamples = VK_SAMPLE_COUNT_1_BIT, }; - pipeline_create_info.stageCount = 2; - - VkPipelineShaderStageCreateInfo shaderStages[2] = {{ - .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, - .stage = VK_SHADER_STAGE_VERTEX_BIT, - .module = prepare_vs(&pipeline->impl.vert_shader_module, pipeline->vertexShader), - .pName = "main", - }, - { - .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, - .stage = VK_SHADER_STAGE_FRAGMENT_BIT, - .module = prepare_fs(&pipeline->impl.frag_shader_module, pipeline->fragmentShader), - .pName = "main", - }}; - - pipeline_create_info.pVertexInputState = &vi; - pipeline_create_info.pInputAssemblyState = &ia; - pipeline_create_info.pRasterizationState = &rasterization_state_create_info; - pipeline_create_info.pColorBlendState = &color_blend_state_create_info; - pipeline_create_info.pMultisampleState = &multi_sample_state_create_info; - pipeline_create_info.pViewportState = &viewport_state_create_info; - pipeline_create_info.pDepthStencilState = &depth_stencil_state_create_info; - pipeline_create_info.pStages = shaderStages; - pipeline_create_info.pDynamicState = &dynamicState; + const VkPipelineShaderStageCreateInfo shader_stages[2] = {{ + .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, + .stage = VK_SHADER_STAGE_VERTEX_BIT, + .module = create_shader_module(device, ¶meters->vertex.shader), + .pName = "main", + }, + { + .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, + .stage = VK_SHADER_STAGE_FRAGMENT_BIT, + .module = create_shader_module(device, ¶meters->fragment.shader), + .pName = "main", + }}; + + const VkGraphicsPipelineCreateInfo pipeline_create_info = { + .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, + .layout = pipeline->pipeline_layout, + .renderPass = VK_NULL_HANDLE, + .stageCount = 2, + .pVertexInputState = &vertex_input_state_create_info, + .pInputAssemblyState = &input_assembly_state_create_info, + .pRasterizationState = &rasterization_state_create_info, + .pColorBlendState = &color_blend_state_create_info, + .pMultisampleState = &multisample_state_create_info, + .pViewportState = &viewport_state_create_info, + .pDepthStencilState = &depth_stencil_state_create_info, + .pStages = shader_stages, + .pDynamicState = &dynamic_state_create_info, + }; result = vkCreateGraphicsPipelines(device->device, VK_NULL_HANDLE, 1, &pipeline_create_info, NULL, &pipeline->pipeline); assert(result == VK_SUCCESS); - vkDestroyShaderModule(device->device, pipeline->impl.frag_shader_module, NULL); - vkDestroyShaderModule(device->device, pipeline->impl.vert_shader_module, NULL); + vkDestroyShaderModule(device->device, shader_stages[0].module, NULL); + vkDestroyShaderModule(device->device, shader_stages[1].module, NULL); } void kope_vulkan_render_pipeline_destroy(kope_vulkan_render_pipeline *pipe) {} diff --git a/Backends/Graphics5/Vulkan/Sources/kope/vulkan/pipeline_structs.h b/Backends/Graphics5/Vulkan/Sources/kope/vulkan/pipeline_structs.h index 133898c73..63e14e0eb 100644 --- a/Backends/Graphics5/Vulkan/Sources/kope/vulkan/pipeline_structs.h +++ b/Backends/Graphics5/Vulkan/Sources/kope/vulkan/pipeline_structs.h @@ -39,7 +39,7 @@ typedef enum kope_vulkan_vertex_format { KOPE_VULKAN_VERTEX_FORMAT_UINT32X2, KOPE_VULKAN_VERTEX_FORMAT_UINT32X3, KOPE_VULKAN_VERTEX_FORMAT_UINT32X4, - KOPE_VULKAN_VERTEX_FORMAT_SIN32, + KOPE_VULKAN_VERTEX_FORMAT_SINT32, KOPE_VULKAN_VERTEX_FORMAT_SINT32X2, KOPE_VULKAN_VERTEX_FORMAT_SINT32X3, KOPE_VULKAN_VERTEX_FORMAT_SINT32X4,