From 69ad926976ad3bee1b5890a4a2c01c06f164f9e5 Mon Sep 17 00:00:00 2001 From: Noah Metz Date: Thu, 11 Jan 2024 21:13:30 -0700 Subject: [PATCH] cleanup --- src/main.c | 606 ++++++++++++++++++++++++++++------------------------- 1 file changed, 324 insertions(+), 282 deletions(-) diff --git a/src/main.c b/src/main.c index b8633bf..a727609 100644 --- a/src/main.c +++ b/src/main.c @@ -322,9 +322,10 @@ VkSemaphore* create_semaphores(VkDevice device, VkSemaphoreCreateFlags flags, ui return 0; } - VkSemaphoreCreateInfo semaphore_info = {}; - semaphore_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; - semaphore_info.flags = flags; + VkSemaphoreCreateInfo semaphore_info = { + .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, + .flags = flags, + }; for(uint32_t i = 0; i < count; i++) { VkResult result = vkCreateSemaphore(device, &semaphore_info, 0, &semaphores[i]); @@ -411,11 +412,12 @@ VkDescriptorSet* create_descriptor_sets(VkDevice device, VkDescriptorSetLayout l layouts[i] = layout; } - VkDescriptorSetAllocateInfo alloc_info = {}; - alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; - alloc_info.descriptorPool = pool; - alloc_info.descriptorSetCount = count; - alloc_info.pSetLayouts = layouts; + VkDescriptorSetAllocateInfo alloc_info = { + .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, + .descriptorPool = pool, + .descriptorSetCount = count, + .pSetLayouts = layouts, + }; VkResult result = vkAllocateDescriptorSets(device, &alloc_info, sets); free(layouts); @@ -490,13 +492,14 @@ bool check_queue_indices(QueueIndices indices) { } QueueIndices get_queue_indices(VkPhysicalDevice physical_device, VkSurfaceKHR surface) { - QueueIndices indices = {}; - indices.graphics_family = 0xFFFFFFFF; - indices.graphics_index = 0xFFFFFFFF; - indices.present_family = 0xFFFFFFFF; - indices.present_index = 0xFFFFFFFF; - indices.transfer_family = 0xFFFFFFFF; - indices.transfer_index = 0xFFFFFFFF; + QueueIndices indices = { + .graphics_family = 0xFFFFFFFF, + .graphics_index = 0xFFFFFFFF, + .present_family = 0xFFFFFFFF, + .present_index = 0xFFFFFFFF, + .transfer_family = 0xFFFFFFFF, + .transfer_index = 0xFFFFFFFF, + }; uint32_t queue_family_count; vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_family_count, 0); @@ -547,12 +550,13 @@ QueueIndices get_queue_indices(VkPhysicalDevice physical_device, VkSurfaceKHR su VkDebugUtilsMessengerEXT create_debug_messenger(VkInstance instance) { VkDebugUtilsMessengerEXT debug_messenger; - VkDebugUtilsMessengerCreateInfoEXT messenger_info = {}; - messenger_info.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT; - messenger_info.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT; - messenger_info.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_DEVICE_ADDRESS_BINDING_BIT_EXT; - messenger_info.pfnUserCallback = debug_callback; - messenger_info.pUserData = 0; + VkDebugUtilsMessengerCreateInfoEXT messenger_info = { + .sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT, + .messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT, + .messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_DEVICE_ADDRESS_BINDING_BIT_EXT, + .pfnUserCallback = debug_callback, + .pUserData = 0, + }; PFN_vkCreateDebugUtilsMessengerEXT func = (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT"); @@ -574,20 +578,14 @@ VkInstance create_instance() { return VK_NULL_HANDLE; } - VkApplicationInfo app_info = {}; - app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; - app_info.pApplicationName = "spacegame"; - app_info.applicationVersion = VK_MAKE_VERSION(0, 0, 1); - app_info.pEngineName = "spacegame"; - app_info.engineVersion = VK_MAKE_VERSION(0, 0, 1); - app_info.apiVersion = VK_API_VERSION_1_2; - - VkInstanceCreateInfo instance_info = {}; - instance_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; - instance_info.pApplicationInfo = &app_info; - - instance_info.enabledLayerCount = validation_layer_count; - instance_info.ppEnabledLayerNames = validation_layers; + VkApplicationInfo app_info = { + .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO, + .pApplicationName = "spacegame", + .applicationVersion = VK_MAKE_VERSION(0, 0, 1), + .pEngineName = "spacegame", + .engineVersion = VK_MAKE_VERSION(0, 0, 1), + .apiVersion = VK_API_VERSION_1_2, + }; uint32_t glfwExtensionCount = 0; const char** glfwExtensions; @@ -603,10 +601,17 @@ VkInstance create_instance() { requested_extensions[glfwExtensionCount + i] = instance_extensions[i]; } - instance_info.enabledExtensionCount = glfwExtensionCount + instance_extension_count; - instance_info.ppEnabledExtensionNames = requested_extensions; + VkInstanceCreateInfo instance_info = { + .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, + .pApplicationInfo = &app_info, + .enabledLayerCount = validation_layer_count, + .ppEnabledLayerNames = validation_layers, + .enabledExtensionCount = glfwExtensionCount + instance_extension_count, + .ppEnabledExtensionNames = requested_extensions, + .flags = VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR, + }; + - instance_info.flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR; VkResult result = vkCreateInstance(&instance_info, 0, &instance); if(result != VK_SUCCESS) { @@ -664,17 +669,16 @@ VkDevice create_logical_device(VkPhysicalDevice physical_device, QueueIndices qu .samplerAnisotropy = VK_TRUE, }; - VkDeviceCreateInfo device_create_info = {}; - device_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; - device_create_info.pQueueCreateInfos = queue_create_info; - device_create_info.queueCreateInfoCount = unique_family_count; - device_create_info.pEnabledFeatures = &device_features; - - device_create_info.enabledExtensionCount = device_extension_count; - device_create_info.ppEnabledExtensionNames = device_extensions; - - device_create_info.enabledLayerCount = validation_layer_count; - device_create_info.ppEnabledLayerNames = validation_layers; + VkDeviceCreateInfo device_create_info = { + .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, + .pQueueCreateInfos = queue_create_info, + .queueCreateInfoCount = unique_family_count, + .pEnabledFeatures = &device_features, + .enabledExtensionCount = device_extension_count, + .ppEnabledExtensionNames = device_extensions, + .enabledLayerCount = validation_layer_count, + .ppEnabledLayerNames = validation_layers, + }; VkResult result = vkCreateDevice(physical_device, &device_create_info, 0, &device); if(result != VK_SUCCESS) { @@ -758,15 +762,21 @@ VkSwapchainKHR create_swapchain(VkDevice device, VkSurfaceFormatKHR format, VkPr image_count = max_images; } - VkSwapchainCreateInfoKHR swapchain_info = {}; - swapchain_info.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; - swapchain_info.surface = surface; - swapchain_info.minImageCount = image_count; - swapchain_info.imageFormat = format.format; - swapchain_info.imageColorSpace = format.colorSpace; - swapchain_info.imageExtent = extent; - swapchain_info.imageArrayLayers = 1; - swapchain_info.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; + VkSwapchainCreateInfoKHR swapchain_info = { + .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, + .surface = surface, + .minImageCount = image_count, + .imageFormat = format.format, + .imageColorSpace = format.colorSpace, + .imageExtent = extent, + .imageArrayLayers = 1, + .imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, + .preTransform = capabilities.currentTransform, + .compositeAlpha = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR, + .presentMode = present_mode, + .clipped = VK_TRUE, + .oldSwapchain = old_swapchain, + }; uint32_t queue_families[2] = {indices.graphics_family, indices.present_index}; if(indices.graphics_family != indices.present_family) { @@ -779,11 +789,6 @@ VkSwapchainKHR create_swapchain(VkDevice device, VkSurfaceFormatKHR format, VkPr swapchain_info.pQueueFamilyIndices = 0; } - swapchain_info.preTransform = capabilities.currentTransform; - swapchain_info.compositeAlpha = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR; - swapchain_info.presentMode = present_mode; - swapchain_info.clipped = VK_TRUE; - swapchain_info.oldSwapchain = old_swapchain; VkSwapchainKHR swapchain; VkResult result; @@ -796,9 +801,10 @@ VkSwapchainKHR create_swapchain(VkDevice device, VkSurfaceFormatKHR format, VkPr } SwapchainImages get_swapchain_images(VkDevice device, VkSwapchainKHR swapchain) { - SwapchainImages images; - images.images = 0; - images.count = 0; + SwapchainImages images = { + .images = NULL, + .count = 0, + }; VkResult result; result = vkGetSwapchainImagesKHR(device, swapchain, &images.count, 0); @@ -829,22 +835,25 @@ VkImageView* create_image_views(VkDevice device, uint32_t image_count, VkImage* } for(uint32_t i = 0; i < image_count; i++) { - VkImageViewCreateInfo view_info = {}; - view_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; - view_info.image = images[i]; - view_info.viewType = VK_IMAGE_VIEW_TYPE_2D; - view_info.format = format.format; - - view_info.components.r = VK_COMPONENT_SWIZZLE_IDENTITY; - view_info.components.g = VK_COMPONENT_SWIZZLE_IDENTITY; - view_info.components.b = VK_COMPONENT_SWIZZLE_IDENTITY; - view_info.components.a = VK_COMPONENT_SWIZZLE_IDENTITY; - - view_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; - view_info.subresourceRange.baseMipLevel = 0; - view_info.subresourceRange.levelCount = 1; - view_info.subresourceRange.baseArrayLayer = 0; - view_info.subresourceRange.layerCount = 1; + VkImageViewCreateInfo view_info = { + .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, + .image = images[i], + .viewType = VK_IMAGE_VIEW_TYPE_2D, + .format = format.format, + .components = { + .r = VK_COMPONENT_SWIZZLE_IDENTITY, + .g = VK_COMPONENT_SWIZZLE_IDENTITY, + .b = VK_COMPONENT_SWIZZLE_IDENTITY, + .a = VK_COMPONENT_SWIZZLE_IDENTITY, + }, + .subresourceRange = { + .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, + .baseMipLevel = 0, + .levelCount = 1, + .baseArrayLayer = 0, + .layerCount = 1, + }, + }; VkResult result = vkCreateImageView(device, &view_info, 0, &image_views[i]); if(result != VK_SUCCESS) { @@ -868,14 +877,15 @@ VkFramebuffer* create_swapchain_framebuffers(VkDevice device, uint32_t image_cou depth_image_view, }; - VkFramebufferCreateInfo framebuffer_info = {}; - framebuffer_info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; - framebuffer_info.renderPass = render_pass; - framebuffer_info.attachmentCount = 2; - framebuffer_info.pAttachments = attachments; - framebuffer_info.width = extent.width; - framebuffer_info.height = extent.height; - framebuffer_info.layers = 1; + VkFramebufferCreateInfo framebuffer_info = { + .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, + .renderPass = render_pass, + .attachmentCount = 2, + .pAttachments = attachments, + .width = extent.width, + .height = extent.height, + .layers = 1, + }; VkResult result = vkCreateFramebuffer(device, &framebuffer_info, 0, &framebuffers[i]); if(result != VK_SUCCESS) { @@ -888,10 +898,11 @@ VkFramebuffer* create_swapchain_framebuffers(VkDevice device, uint32_t image_cou } VkShaderModule create_shader_module(VkDevice device, const char * code, uint32_t code_size) { - VkShaderModuleCreateInfo shader_info = {}; - shader_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; - shader_info.codeSize = code_size; - shader_info.pCode = (uint32_t*)code; + VkShaderModuleCreateInfo shader_info = { + .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, + .codeSize = code_size, + .pCode = (uint32_t*)code, + }; VkShaderModule shader; VkResult result; @@ -1048,16 +1059,17 @@ AllocatedImage allocate_image(VkPhysicalDeviceMemoryProperties memories, VkDevic } AllocatedBuffer allocate_buffer(VkPhysicalDeviceMemoryProperties memories, VkDevice device, VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags include, VkMemoryPropertyFlags exclude) { - AllocatedBuffer ret = {}; - ret.memory = VK_NULL_HANDLE; - ret.buffer = VK_NULL_HANDLE; - + AllocatedBuffer ret = { + .memory = VK_NULL_HANDLE, + .buffer = VK_NULL_HANDLE, + }; - VkBufferCreateInfo buffer_info = {}; - buffer_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; - buffer_info.size = size; - buffer_info.usage = usage; - buffer_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE; + VkBufferCreateInfo buffer_info = { + .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, + .size = size, + .usage = usage, + .sharingMode = VK_SHARING_MODE_EXCLUSIVE, + }; VkResult result = vkCreateBuffer(device, &buffer_info, 0, &ret.buffer); if(result != VK_SUCCESS) { @@ -1069,10 +1081,11 @@ AllocatedBuffer allocate_buffer(VkPhysicalDeviceMemoryProperties memories, VkDev VkMemoryRequirements memory_requirements; vkGetBufferMemoryRequirements(device, ret.buffer, &memory_requirements); - VkMemoryAllocateInfo alloc_info = {}; - alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; - alloc_info.allocationSize = memory_requirements.size; - alloc_info.memoryTypeIndex = pick_memory(memories, memory_requirements.memoryTypeBits, include, exclude); + VkMemoryAllocateInfo alloc_info = { + .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, + .allocationSize = memory_requirements.size, + .memoryTypeIndex = pick_memory(memories, memory_requirements.memoryTypeBits, include, exclude), + }; result = vkAllocateMemory(device, &alloc_info, 0, &ret.memory); if(result != VK_SUCCESS) { @@ -1125,11 +1138,12 @@ AllocatedBuffer* allocate_buffers(VkPhysicalDeviceMemoryProperties memories, VkD } VkCommandBuffer command_begin_single(VkDevice device, VkCommandPool transfer_pool) { - VkCommandBufferAllocateInfo command_info = {}; - command_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; - command_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; - command_info.commandPool = transfer_pool; - command_info.commandBufferCount = 1; + VkCommandBufferAllocateInfo command_info = { + .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, + .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY, + .commandPool = transfer_pool, + .commandBufferCount = 1, + }; VkCommandBuffer command_buffer; VkResult result = vkAllocateCommandBuffers(device, &command_info, &command_buffer); @@ -1137,9 +1151,10 @@ VkCommandBuffer command_begin_single(VkDevice device, VkCommandPool transfer_poo return VK_NULL_HANDLE; } - VkCommandBufferBeginInfo begin_info = {}; - begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; - begin_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; + VkCommandBufferBeginInfo begin_info = { + .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, + .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, + }; result = vkBeginCommandBuffer(command_buffer, &begin_info); if(result != VK_SUCCESS) { @@ -1157,10 +1172,11 @@ VkResult command_end_single(VkDevice device, VkCommandBuffer command_buffer, VkC return result; } - VkSubmitInfo submit_info = {}; - submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; - submit_info.commandBufferCount = 1; - submit_info.pCommandBuffers = &command_buffer; + VkSubmitInfo submit_info = { + .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO, + .commandBufferCount = 1, + .pCommandBuffers = &command_buffer, + }; result = vkQueueSubmit(transfer_queue, 1, &submit_info, 0); if(result != VK_SUCCESS) { @@ -1176,10 +1192,11 @@ VkResult command_end_single(VkDevice device, VkCommandBuffer command_buffer, VkC VkResult command_copy_buffers(VkDevice device, VkCommandPool transfer_pool, VkQueue transfer_queue, VkBuffer source, VkBuffer dest, VkDeviceSize size) { VkCommandBuffer command_buffer = command_begin_single(device, transfer_pool); - VkBufferCopy copy_region = {}; - copy_region.srcOffset = 0; - copy_region.dstOffset = 0; - copy_region.size = size; + VkBufferCopy copy_region = { + .srcOffset = 0, + .dstOffset = 0, + .size = size, + }; vkCmdCopyBuffer(command_buffer, source, dest, 1, ©_region); @@ -1415,64 +1432,74 @@ VkPipeline create_graphics_pipeline( }; uint32_t dynamic_state_count = sizeof(dynamic_states)/sizeof(VkDynamicState); - VkPipelineDynamicStateCreateInfo dynamic_info = {}; - dynamic_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; - dynamic_info.dynamicStateCount = dynamic_state_count; - dynamic_info.pDynamicStates = dynamic_states; - - VkPipelineVertexInputStateCreateInfo vertex_input_info = {}; - vertex_input_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; - vertex_input_info.vertexBindingDescriptionCount = mesh_type.bindings_count; - vertex_input_info.pVertexBindingDescriptions = mesh_type.bindings; - vertex_input_info.vertexAttributeDescriptionCount = mesh_type.attributes_count; - vertex_input_info.pVertexAttributeDescriptions = mesh_type.attributes; - - VkPipelineInputAssemblyStateCreateInfo input_assembly_info = {}; - input_assembly_info.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; - input_assembly_info.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; - input_assembly_info.primitiveRestartEnable = VK_FALSE; - - VkViewport viewport = {}; - viewport.x = 0.0f; - viewport.y = 0.0f; - viewport.width = (float)(extent.width); - viewport.height = (float)(extent.height); - viewport.minDepth = 0.0f; - viewport.maxDepth = 1.0f; - - VkRect2D scissor = {}; - VkOffset2D scissor_offset = {.x = 0, .y = 0}; - scissor.offset = scissor_offset; - scissor.extent = extent; - - VkPipelineViewportStateCreateInfo viewport_state = {}; - viewport_state.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; - viewport_state.viewportCount = 1; - viewport_state.pViewports = &viewport; - viewport_state.scissorCount = 1; - viewport_state.pScissors = &scissor; - - VkPipelineRasterizationStateCreateInfo raster_info = {}; - raster_info.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; - raster_info.depthClampEnable = VK_FALSE; - raster_info.rasterizerDiscardEnable = VK_FALSE; - raster_info.polygonMode = VK_POLYGON_MODE_FILL; - raster_info.lineWidth = 1.0f; - raster_info.cullMode = VK_CULL_MODE_NONE; - raster_info.frontFace = VK_FRONT_FACE_CLOCKWISE; - raster_info.depthBiasEnable = VK_FALSE; - raster_info.depthBiasConstantFactor = 0.0f; - raster_info.depthBiasClamp = 0.0f; - raster_info.depthBiasSlopeFactor = 0.0f; - - VkPipelineMultisampleStateCreateInfo multisample_info = {}; - multisample_info.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; - multisample_info.sampleShadingEnable = VK_FALSE; - multisample_info.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT; - multisample_info.minSampleShading = 1.0f; - multisample_info.pSampleMask = 0; - multisample_info.alphaToCoverageEnable = VK_FALSE; - multisample_info.alphaToOneEnable = VK_FALSE; + VkPipelineDynamicStateCreateInfo dynamic_info = { + .sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, + .dynamicStateCount = dynamic_state_count, + .pDynamicStates = dynamic_states, + }; + + VkPipelineVertexInputStateCreateInfo vertex_input_info = { + .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, + .vertexBindingDescriptionCount = mesh_type.bindings_count, + .pVertexBindingDescriptions = mesh_type.bindings, + .vertexAttributeDescriptionCount = mesh_type.attributes_count, + .pVertexAttributeDescriptions = mesh_type.attributes, + }; + + VkPipelineInputAssemblyStateCreateInfo input_assembly_info = { + .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, + .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, + .primitiveRestartEnable = VK_FALSE, + }; + + VkViewport viewport = { + .x = 0.0f, + .y = 0.0f, + .width = (float)(extent.width), + .height = (float)(extent.height), + .minDepth = 0.0f, + .maxDepth = 1.0f, + }; + + VkRect2D scissor = { + .offset = { + .x = 0, + .y = 0, + }, + .extent = extent, + }; + + VkPipelineViewportStateCreateInfo viewport_state = { + .sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, + .viewportCount = 1, + .pViewports = &viewport, + .scissorCount = 1, + .pScissors = &scissor, + }; + + VkPipelineRasterizationStateCreateInfo raster_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_NONE, + .frontFace = VK_FRONT_FACE_CLOCKWISE, + .depthBiasEnable = VK_FALSE, + .depthBiasConstantFactor = 0.0f, + .depthBiasClamp = 0.0f, + .depthBiasSlopeFactor = 0.0f, + }; + + VkPipelineMultisampleStateCreateInfo multisample_info = { + .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, + .sampleShadingEnable = VK_FALSE, + .rasterizationSamples = VK_SAMPLE_COUNT_1_BIT, + .minSampleShading = 1.0f, + .pSampleMask = 0, + .alphaToCoverageEnable = VK_FALSE, + .alphaToOneEnable = VK_FALSE, + }; VkPipelineDepthStencilStateCreateInfo depth_info = { .sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, @@ -1487,46 +1514,47 @@ VkPipeline create_graphics_pipeline( .back = {}, }; - VkPipelineColorBlendAttachmentState color_blend_attachment = {}; - color_blend_attachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT; - color_blend_attachment.blendEnable = VK_TRUE; - color_blend_attachment.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA; - color_blend_attachment.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA; - color_blend_attachment.colorBlendOp = VK_BLEND_OP_ADD; - color_blend_attachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; - color_blend_attachment.alphaBlendOp = VK_BLEND_OP_ADD; - - VkPipelineColorBlendStateCreateInfo color_blend_info = {}; - color_blend_info.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; - color_blend_info.logicOpEnable = VK_FALSE; - color_blend_info.logicOp = VK_LOGIC_OP_COPY; - color_blend_info.attachmentCount = 1; - color_blend_info.pAttachments = &color_blend_attachment; - color_blend_info.blendConstants[0] = 0.0f; - color_blend_info.blendConstants[1] = 0.0f; - color_blend_info.blendConstants[2] = 0.0f; - color_blend_info.blendConstants[3] = 0.0f; - - VkGraphicsPipelineCreateInfo pipeline_info = {}; - pipeline_info.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; - pipeline_info.stageCount = shader_stage_count; - pipeline_info.pStages = shader_stages; - pipeline_info.pVertexInputState = &vertex_input_info; - pipeline_info.pInputAssemblyState = &input_assembly_info; - pipeline_info.pViewportState = &viewport_state; - pipeline_info.pRasterizationState = &raster_info; - pipeline_info.pDepthStencilState = 0; - pipeline_info.pColorBlendState = &color_blend_info; - pipeline_info.pDynamicState = &dynamic_info; - pipeline_info.pDepthStencilState = &depth_info; - pipeline_info.pMultisampleState = &multisample_info; - pipeline_info.layout = layout; - pipeline_info.renderPass = render_pass; - pipeline_info.subpass = 0; - - pipeline_info.basePipelineHandle = VK_NULL_HANDLE; - pipeline_info.basePipelineIndex = -1; + 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_TRUE, + .srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA, + .dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, + .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] = 0.0f, + .blendConstants[1] = 0.0f, + .blendConstants[2] = 0.0f, + .blendConstants[3] = 0.0f, + }; + + VkGraphicsPipelineCreateInfo pipeline_info = { + .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, + .stageCount = shader_stage_count, + .pStages = shader_stages, + .pVertexInputState = &vertex_input_info, + .pInputAssemblyState = &input_assembly_info, + .pViewportState = &viewport_state, + .pRasterizationState = &raster_info, + .pColorBlendState = &color_blend_info, + .pDynamicState = &dynamic_info, + .pDepthStencilState = &depth_info, + .pMultisampleState = &multisample_info, + .layout = layout, + .renderPass = render_pass, + .subpass = 0, + .basePipelineHandle = VK_NULL_HANDLE, + .basePipelineIndex = -1, + }; VkPipeline pipeline; VkResult result = vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipeline_info, 0, &pipeline); @@ -1640,8 +1668,6 @@ VkResult recreate_swapchain(VulkanContext* context) { vkDestroySemaphore(context->device, context->image_available_semaphores[i], 0); } - //vkDestroySwapchainKHR(context->device, context->swapchain, 0); - //free(context->swapchain_images); free(context->swapchain_image_views); free(context->swapchain_framebuffers); free(context->swapchain_details.formats); @@ -1748,23 +1774,17 @@ void command_draw_material(Material material, uint32_t object_count, Object* obj } VkResult command_draw_scene(uint32_t materials_count, Material* materials, uint32_t* object_counts, Object** objects, uint32_t frame_num, VkDescriptorSet* scene_descriptors, VkCommandBuffer command_buffer, VkRenderPass render_pass, VkFramebuffer framebuffer, VkExtent2D extent) { - VkCommandBufferBeginInfo begin_info = {}; - begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; - begin_info.flags = 0; - begin_info.pInheritanceInfo = 0; + VkCommandBufferBeginInfo begin_info = { + .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, + .flags = 0, + .pInheritanceInfo = 0, + }; VkResult result = vkBeginCommandBuffer(command_buffer, &begin_info); if(result != VK_SUCCESS) { return result; } - VkRenderPassBeginInfo render_pass_info = {}; - render_pass_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; - render_pass_info.renderPass = render_pass; - render_pass_info.framebuffer = framebuffer; - VkOffset2D render_offset = {.x = 0, .y = 0}; - render_pass_info.renderArea.offset = render_offset; - render_pass_info.renderArea.extent = extent; VkClearValue clear_colors[] = { { .color = { @@ -1775,24 +1795,41 @@ VkResult command_draw_scene(uint32_t materials_count, Material* materials, uint3 .depthStencil = {1.0f, 0.0f}, }, }; - render_pass_info.clearValueCount = sizeof(clear_colors)/sizeof(VkClearValue); - render_pass_info.pClearValues = clear_colors; + + VkRenderPassBeginInfo render_pass_info = { + .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, + .renderPass = render_pass, + .framebuffer = framebuffer, + .renderArea = { + .offset = { + .x = 0, + .y = 0, + }, + .extent = extent, + }, + .clearValueCount = sizeof(clear_colors)/sizeof(VkClearValue), + .pClearValues = clear_colors, + }; vkCmdBeginRenderPass(command_buffer, &render_pass_info, VK_SUBPASS_CONTENTS_INLINE); - VkViewport viewport = {}; - viewport.x = 0.0f; - viewport.y = 0.0f; - viewport.width = (float)(extent.width); - viewport.height = (float)(extent.height); - viewport.minDepth = 0.0f; - viewport.maxDepth = 1.0f; + VkViewport viewport = { + .x = 0.0f, + .y = 0.0f, + .width = (float)(extent.width), + .height = (float)(extent.height), + .minDepth = 0.0f, + .maxDepth = 1.0f, + }; vkCmdSetViewport(command_buffer, 0, 1, &viewport); - VkRect2D scissor = {}; - VkOffset2D scissor_offset = {.x = 0.0f, .y = 0.0f}; - scissor.offset = scissor_offset; - scissor.extent = extent; + VkRect2D scissor = { + .offset = { + .x = 0.0f, + .y = 0.0f, + }, + .extent = extent, + }; vkCmdSetScissor(command_buffer, 0, 1, &scissor); for(uint i = 0; i < materials_count; i++) { @@ -1805,11 +1842,12 @@ VkResult command_draw_scene(uint32_t materials_count, Material* materials, uint3 } VkCommandBuffer* create_command_buffers(VkDevice device, VkCommandPool command_pool, uint32_t image_count) { - VkCommandBufferAllocateInfo alloc_info = {}; - alloc_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; - alloc_info.commandPool = command_pool; - alloc_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; - alloc_info.commandBufferCount = image_count; + VkCommandBufferAllocateInfo alloc_info = { + .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, + .commandPool = command_pool, + .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY, + .commandBufferCount = image_count, + }; VkCommandBuffer* command_buffers = malloc(sizeof(VkCommandBuffer)*image_count); if(command_buffers == 0) { @@ -1830,9 +1868,10 @@ VkFence* create_fences(VkDevice device, VkFenceCreateFlags flags, uint32_t count return 0; } - VkFenceCreateInfo fence_info = {}; - fence_info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; - fence_info.flags = flags; + VkFenceCreateInfo fence_info = { + .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, + .flags = flags, + }; for(uint32_t i = 0; i < count; i++) { VkResult result = vkCreateFence(device, &fence_info, 0, &fences[i]); @@ -2926,30 +2965,32 @@ VkResult draw_frame(VulkanContext* context, SceneContext* scene, uint32_t materi return result; } - VkSubmitInfo submit_info = {}; VkPipelineStageFlags wait_stages[] = {VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT}; - submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; - submit_info.waitSemaphoreCount = 1; - submit_info.pWaitSemaphores = &context->image_available_semaphores[context->current_frame]; - submit_info.pWaitDstStageMask = wait_stages; - submit_info.commandBufferCount = 1; - submit_info.pCommandBuffers = &context->swapchain_command_buffers[context->current_frame]; - submit_info.signalSemaphoreCount = 1; - submit_info.pSignalSemaphores = &context->render_finished_semaphores[context->current_frame]; + VkSubmitInfo submit_info = { + .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO, + .waitSemaphoreCount = 1, + .pWaitSemaphores = &context->image_available_semaphores[context->current_frame], + .pWaitDstStageMask = wait_stages, + .commandBufferCount = 1, + .pCommandBuffers = &context->swapchain_command_buffers[context->current_frame], + .signalSemaphoreCount = 1, + .pSignalSemaphores = &context->render_finished_semaphores[context->current_frame], + }; result = vkQueueSubmit(context->queues.graphics, 1, &submit_info, context->in_flight_fences[context->current_frame]); if(result != VK_SUCCESS) { return result; } - VkPresentInfoKHR present_info = {}; - present_info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; - present_info.waitSemaphoreCount = 1; - present_info.pWaitSemaphores = &context->render_finished_semaphores[context->current_frame]; - present_info.swapchainCount = 1; - present_info.pSwapchains = &context->swapchain; - present_info.pImageIndices = &image_index; - present_info.pResults = 0; + VkPresentInfoKHR present_info = { + .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, + .waitSemaphoreCount = 1, + .pWaitSemaphores = &context->render_finished_semaphores[context->current_frame], + .swapchainCount = 1, + .pSwapchains = &context->swapchain, + .pImageIndices = &image_index, + .pResults = 0, + }; return vkQueuePresentKHR(context->queues.present, &present_info); } @@ -3179,16 +3220,17 @@ Object create_texture_mesh_object(Material* texture_mesh_material, VkPhysicalDev .imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, }; - VkWriteDescriptorSet descriptor_write = {}; - descriptor_write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; - descriptor_write.dstSet = sets[i]; - descriptor_write.dstBinding = 0; - descriptor_write.dstArrayElement = 0; - descriptor_write.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; - descriptor_write.descriptorCount = 1; - descriptor_write.pBufferInfo = 0; - descriptor_write.pImageInfo = &image_info; - descriptor_write.pTexelBufferView = 0; + VkWriteDescriptorSet descriptor_write = { + .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, + .dstSet = sets[i], + .dstBinding = 0, + .dstArrayElement = 0, + .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, + .descriptorCount = 1, + .pBufferInfo = 0, + .pImageInfo = &image_info, + .pTexelBufferView = 0, + }; vkUpdateDescriptorSets(device, 1, &descriptor_write, 0, 0); }