//- shaders, compiled by compile.sh with glslc -mfmt=c global_variable const u32 vk_ui_vert_spv[] = #include "ui_vert.spv.h" ; global_variable const u32 vk_ui_frag_spv[] = #include "ui_frag.spv.h" ; #define VkCheck(expression) \ do { \ VkResult vk_check_result = (expression); \ if(vk_check_result != VK_SUCCESS) { \ Log("%s:%d: %s failed: %d", __FILE__, __LINE__, #expression, vk_check_result); \ return false; \ } \ } while(0) #define VK_INSTANCE_BUFFER_SIZE (sizeof(DrawInstance) * DRAW_MAX_INSTANCES) #define VK_STAGING_BUFFER_SIZE (FONT_ATLAS_SIZE * FONT_ATLAS_SIZE) //- debug internal VKAPI_ATTR VkBool32 VKAPI_CALL vk_debug_callback(VkDebugUtilsMessageSeverityFlagBitsEXT severity, VkDebugUtilsMessageTypeFlagsEXT type, const VkDebugUtilsMessengerCallbackDataEXT *data, void *user) { if(severity >= VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) { Log("vulkan: %s", data->pMessage); } return VK_FALSE; } //- memory internal u32 vk_memory_type(VulkanRenderer *renderer, u32 type_bits, VkMemoryPropertyFlags flags) { for(u32 index = 0; index < renderer->memory.memoryTypeCount; ++index) { if((type_bits & (1u << index)) && (renderer->memory.memoryTypes[index].propertyFlags & flags) == flags) { return index; } } return UINT32_MAX; } internal b32 vk_create_buffer(VulkanRenderer *renderer, u64 size, VkBufferUsageFlags usage, VkBuffer *buffer, VkDeviceMemory *memory, void **mapped) { VkBufferCreateInfo info = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO}; info.size = size; info.usage = usage; info.sharingMode = VK_SHARING_MODE_EXCLUSIVE; VkCheck(vkCreateBuffer(renderer->device, &info, NULL, buffer)); VkMemoryRequirements requirements; vkGetBufferMemoryRequirements(renderer->device, *buffer, &requirements); // NOTE: apple silicon is unified memory, host visible memory is also device local. we ask // for coherent so writes never need a flush. VkMemoryAllocateInfo allocate = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO}; allocate.allocationSize = requirements.size; allocate.memoryTypeIndex = vk_memory_type(renderer, requirements.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT); VkCheck(vkAllocateMemory(renderer->device, &allocate, NULL, memory)); VkCheck(vkBindBufferMemory(renderer->device, *buffer, *memory, 0)); renderer->gpu_bytes += requirements.size; VkCheck(vkMapMemory(renderer->device, *memory, 0, size, 0, mapped)); return true; } //- swapchain internal void vk_destroy_swapchain_views(VulkanRenderer *renderer) { for(u32 index = 0; index < renderer->image_count; ++index) { vkDestroyImageView(renderer->device, renderer->views[index], NULL); vkDestroySemaphore(renderer->device, renderer->rendered[index], NULL); renderer->views[index] = VK_NULL_HANDLE; renderer->rendered[index] = VK_NULL_HANDLE; } } internal b32 vk_create_swapchain(VulkanRenderer *renderer, u32 width, u32 height) { VkSurfaceCapabilitiesKHR caps; VkCheck(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(renderer->gpu, renderer->surface, &caps)); // NOTE: on wayland currentExtent is 0xFFFFFFFF, we pick the size VkExtent2D extent = caps.currentExtent; if(extent.width == UINT32_MAX) { extent.width = Clamp(width, caps.minImageExtent.width, caps.maxImageExtent.width); extent.height = Clamp(height, caps.minImageExtent.height, caps.maxImageExtent.height); } if(extent.width == 0 || extent.height == 0) { return false; } u32 image_count = caps.minImageCount + 1; if(caps.maxImageCount > 0) image_count = Min(image_count, caps.maxImageCount); image_count = Min(image_count, (u32)VK_MAX_SWAPCHAIN_IMAGES); renderer->composite_alpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR; renderer->transparent = false; if(caps.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR) { renderer->composite_alpha = VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR; renderer->transparent = true; } else if(!(caps.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR)) { renderer->composite_alpha = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR; } VkSwapchainKHR old = renderer->swapchain; VkSwapchainCreateInfoKHR info = {VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR}; info.surface = renderer->surface; info.minImageCount = image_count; info.imageFormat = renderer->format; info.imageColorSpace = renderer->color_space; info.imageExtent = extent; info.imageArrayLayers = 1; renderer->can_capture = (caps.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_SRC_BIT) != 0; info.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | (renderer->can_capture ? VK_IMAGE_USAGE_TRANSFER_SRC_BIT : 0); info.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE; info.preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR; info.compositeAlpha = renderer->composite_alpha; info.presentMode = renderer->present_mode; info.clipped = VK_TRUE; info.oldSwapchain = old; VkCheck(vkCreateSwapchainKHR(renderer->device, &info, NULL, &renderer->swapchain)); if(old) { vk_destroy_swapchain_views(renderer); vkDestroySwapchainKHR(renderer->device, old, NULL); } renderer->extent = extent; renderer->image_count = VK_MAX_SWAPCHAIN_IMAGES; VkCheck(vkGetSwapchainImagesKHR(renderer->device, renderer->swapchain, &renderer->image_count, renderer->images)); for(u32 index = 0; index < renderer->image_count; ++index) { VkImageViewCreateInfo view = {VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO}; view.image = renderer->images[index]; view.viewType = VK_IMAGE_VIEW_TYPE_2D; view.format = renderer->format; view.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}; VkCheck(vkCreateImageView(renderer->device, &view, NULL, &renderer->views[index])); VkSemaphoreCreateInfo semaphore = {VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO}; VkCheck(vkCreateSemaphore(renderer->device, &semaphore, NULL, &renderer->rendered[index])); } renderer->swapchain_dirty = false; return true; } internal void vk_resize(VulkanRenderer *renderer, u32 width, u32 height) { vkDeviceWaitIdle(renderer->device); vk_create_swapchain(renderer, width, height); } //- pipeline internal b32 vk_create_pipeline(VulkanRenderer *renderer) { VkDevice device = renderer->device; VkShaderModule vert, frag; VkShaderModuleCreateInfo module = {VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO}; module.codeSize = sizeof(vk_ui_vert_spv); module.pCode = vk_ui_vert_spv; VkCheck(vkCreateShaderModule(device, &module, NULL, &vert)); module.codeSize = sizeof(vk_ui_frag_spv); module.pCode = vk_ui_frag_spv; VkCheck(vkCreateShaderModule(device, &module, NULL, &frag)); VkPipelineShaderStageCreateInfo stages[2] = {}; stages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; stages[0].stage = VK_SHADER_STAGE_VERTEX_BIT; stages[0].module = vert; stages[0].pName = "main"; stages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; stages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT; stages[1].module = frag; stages[1].pName = "main"; VkVertexInputBindingDescription binding = {0, sizeof(DrawInstance), VK_VERTEX_INPUT_RATE_INSTANCE}; VkVertexInputAttributeDescription attributes[3] = { {0, 0, VK_FORMAT_R32G32B32A32_SFLOAT, offsetof(DrawInstance, rect)}, {1, 0, VK_FORMAT_R32G32_UINT, offsetof(DrawInstance, data)}, {2, 0, VK_FORMAT_R32G32_UINT, offsetof(DrawInstance, colors)}, }; VkPipelineVertexInputStateCreateInfo vertex_input = {VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO}; vertex_input.vertexBindingDescriptionCount = 1; vertex_input.pVertexBindingDescriptions = &binding; vertex_input.vertexAttributeDescriptionCount = ArrayCount(attributes); vertex_input.pVertexAttributeDescriptions = attributes; VkPipelineInputAssemblyStateCreateInfo assembly = {VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO}; assembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP; VkPipelineViewportStateCreateInfo viewport = {VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO}; viewport.viewportCount = 1; viewport.scissorCount = 1; VkPipelineRasterizationStateCreateInfo raster = {VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO}; raster.polygonMode = VK_POLYGON_MODE_FILL; raster.cullMode = VK_CULL_MODE_NONE; raster.lineWidth = 1.0f; VkPipelineMultisampleStateCreateInfo multisample = {VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO}; multisample.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT; // sdf aa, no msaa needed // NOTE: premultiplied alpha everywhere VkPipelineColorBlendAttachmentState blend = {}; blend.blendEnable = VK_TRUE; blend.srcColorBlendFactor = VK_BLEND_FACTOR_ONE; blend.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA; blend.colorBlendOp = VK_BLEND_OP_ADD; blend.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; blend.dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA; blend.alphaBlendOp = VK_BLEND_OP_ADD; blend.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT; VkPipelineColorBlendStateCreateInfo blend_state = {VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO}; blend_state.attachmentCount = 1; blend_state.pAttachments = &blend; VkDynamicState dynamic_states[] = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR}; VkPipelineDynamicStateCreateInfo dynamic = {VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO}; dynamic.dynamicStateCount = ArrayCount(dynamic_states); dynamic.pDynamicStates = dynamic_states; VkPipelineRenderingCreateInfo rendering = {VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO}; rendering.colorAttachmentCount = 1; rendering.pColorAttachmentFormats = &renderer->format; VkGraphicsPipelineCreateInfo info = {VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO}; info.pNext = &rendering; info.stageCount = 2; info.pStages = stages; info.pVertexInputState = &vertex_input; info.pInputAssemblyState = &assembly; info.pViewportState = &viewport; info.pRasterizationState = &raster; info.pMultisampleState = &multisample; info.pColorBlendState = &blend_state; info.pDynamicState = &dynamic; info.layout = renderer->pipeline_layout; VkCheck(vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &info, NULL, &renderer->pipeline)); vkDestroyShaderModule(device, vert, NULL); vkDestroyShaderModule(device, frag, NULL); return true; } //- atlas internal b32 vk_create_atlas(VulkanRenderer *renderer) { VkDevice device = renderer->device; VkImageCreateInfo image = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO}; image.imageType = VK_IMAGE_TYPE_2D; image.format = VK_FORMAT_R8_UNORM; image.extent = {FONT_ATLAS_SIZE, FONT_ATLAS_SIZE, 1}; image.mipLevels = 1; image.arrayLayers = 1; image.samples = VK_SAMPLE_COUNT_1_BIT; image.tiling = VK_IMAGE_TILING_OPTIMAL; image.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; image.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; VkCheck(vkCreateImage(device, &image, NULL, &renderer->atlas)); VkMemoryRequirements requirements; vkGetImageMemoryRequirements(device, renderer->atlas, &requirements); VkMemoryAllocateInfo allocate = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO}; allocate.allocationSize = requirements.size; allocate.memoryTypeIndex = vk_memory_type(renderer, requirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); VkCheck(vkAllocateMemory(device, &allocate, NULL, &renderer->atlas_memory)); renderer->gpu_bytes += requirements.size; VkCheck(vkBindImageMemory(device, renderer->atlas, renderer->atlas_memory, 0)); VkImageViewCreateInfo view = {VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO}; view.image = renderer->atlas; view.viewType = VK_IMAGE_VIEW_TYPE_2D; view.format = VK_FORMAT_R8_UNORM; view.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}; VkCheck(vkCreateImageView(device, &view, NULL, &renderer->atlas_view)); VkSamplerCreateInfo sampler = {VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO}; sampler.magFilter = VK_FILTER_NEAREST; // glyphs are drawn 1:1 on the pixel grid sampler.minFilter = VK_FILTER_NEAREST; sampler.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; sampler.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; sampler.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; VkCheck(vkCreateSampler(device, &sampler, NULL, &renderer->sampler)); //- descriptor VkDescriptorSetLayoutBinding binding = {0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_FRAGMENT_BIT, NULL}; VkDescriptorSetLayoutCreateInfo layout = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO}; layout.bindingCount = 1; layout.pBindings = &binding; VkCheck(vkCreateDescriptorSetLayout(device, &layout, NULL, &renderer->set_layout)); VkDescriptorPoolSize pool_size = {VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1}; VkDescriptorPoolCreateInfo pool = {VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO}; pool.maxSets = 1; pool.poolSizeCount = 1; pool.pPoolSizes = &pool_size; VkCheck(vkCreateDescriptorPool(device, &pool, NULL, &renderer->descriptor_pool)); VkDescriptorSetAllocateInfo set = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO}; set.descriptorPool = renderer->descriptor_pool; set.descriptorSetCount = 1; set.pSetLayouts = &renderer->set_layout; VkCheck(vkAllocateDescriptorSets(device, &set, &renderer->descriptor_set)); VkDescriptorImageInfo image_info = {renderer->sampler, renderer->atlas_view, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL}; VkWriteDescriptorSet write = {VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET}; write.dstSet = renderer->descriptor_set; write.descriptorCount = 1; write.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; write.pImageInfo = &image_info; vkUpdateDescriptorSets(device, 1, &write, 0, NULL); VkPushConstantRange push = {VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(f32) * 4}; VkPipelineLayoutCreateInfo pipeline_layout = {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO}; pipeline_layout.setLayoutCount = 1; pipeline_layout.pSetLayouts = &renderer->set_layout; pipeline_layout.pushConstantRangeCount = 1; pipeline_layout.pPushConstantRanges = &push; VkCheck(vkCreatePipelineLayout(device, &pipeline_layout, NULL, &renderer->pipeline_layout)); return true; } internal void vk_image_barrier(VkCommandBuffer cmd, VkImage image, VkPipelineStageFlags2 src_stage, VkAccessFlags2 src_access, VkImageLayout old_layout, VkPipelineStageFlags2 dst_stage, VkAccessFlags2 dst_access, VkImageLayout new_layout) { VkImageMemoryBarrier2 barrier = {VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2}; barrier.srcStageMask = src_stage; barrier.srcAccessMask = src_access; barrier.dstStageMask = dst_stage; barrier.dstAccessMask = dst_access; barrier.oldLayout = old_layout; barrier.newLayout = new_layout; barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; barrier.image = image; barrier.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}; VkDependencyInfo dependency = {VK_STRUCTURE_TYPE_DEPENDENCY_INFO}; dependency.imageMemoryBarrierCount = 1; dependency.pImageMemoryBarriers = &barrier; vkCmdPipelineBarrier2(cmd, &dependency); } // NOTE: only the rows that changed since the last upload, usually a few glyphs worth internal void vk_upload_atlas(VulkanRenderer *renderer, VulkanFrame *frame, FontSystem *fonts) { if(fonts->dirty_y0 >= fonts->dirty_y1) { return; } u32 y0 = (u32)fonts->dirty_y0; u32 rows = (u32)(fonts->dirty_y1 - fonts->dirty_y0); MemCpy(frame->staging_mapped, fonts->atlas + (u64)y0 * FONT_ATLAS_SIZE, (u64)rows * FONT_ATLAS_SIZE); fonts->dirty_y0 = fonts->dirty_y1 = 0; VkImageLayout old_layout = renderer->atlas_ready ? VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL : VK_IMAGE_LAYOUT_UNDEFINED; vk_image_barrier(frame->cmd, renderer->atlas, VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT, VK_ACCESS_2_SHADER_SAMPLED_READ_BIT, old_layout, VK_PIPELINE_STAGE_2_COPY_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); VkBufferImageCopy region = {}; region.imageSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}; region.imageOffset = {0, (s32)y0, 0}; region.imageExtent = {FONT_ATLAS_SIZE, rows, 1}; vkCmdCopyBufferToImage(frame->cmd, frame->staging, renderer->atlas, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion); vk_image_barrier(frame->cmd, renderer->atlas, VK_PIPELINE_STAGE_2_COPY_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT, VK_ACCESS_2_SHADER_SAMPLED_READ_BIT, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); renderer->atlas_ready = true; } //- init internal b32 vk_has_layer(const char *name) { u32 count = 0; vkEnumerateInstanceLayerProperties(&count, NULL); VkLayerProperties layers[64]; count = Min(count, (u32)ArrayCount(layers)); vkEnumerateInstanceLayerProperties(&count, layers); for(u32 index = 0; index < count; ++index) { if(strcmp(layers[index].layerName, name) == 0) { return true; } } return false; } internal b32 vk_init(VulkanRenderer *renderer, struct wl_display *display, struct wl_surface *surface, u32 width, u32 height) { MemSetZero(renderer, sizeof(*renderer)); //- instance const char *extensions[3] = {VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME, VK_EXT_DEBUG_UTILS_EXTENSION_NAME}; const char *validation = "VK_LAYER_KHRONOS_validation"; b32 debug = DEBUG && vk_has_layer(validation); VkApplicationInfo app = {VK_STRUCTURE_TYPE_APPLICATION_INFO}; app.pApplicationName = "mp3_player"; app.pEngineName = "mp3_player"; app.apiVersion = VK_API_VERSION_1_3; VkInstanceCreateInfo instance_info = {VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO}; instance_info.pApplicationInfo = &app; instance_info.enabledExtensionCount = debug ? 3 : 2; instance_info.ppEnabledExtensionNames = extensions; instance_info.enabledLayerCount = debug ? 1 : 0; instance_info.ppEnabledLayerNames = &validation; VkCheck(vkCreateInstance(&instance_info, NULL, &renderer->instance)); if(debug) { PFN_vkCreateDebugUtilsMessengerEXT create_messenger = (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(renderer->instance, "vkCreateDebugUtilsMessengerEXT"); VkDebugUtilsMessengerCreateInfoEXT messenger = {VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT}; messenger.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT; messenger.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; messenger.pfnUserCallback = vk_debug_callback; if(create_messenger) { create_messenger(renderer->instance, &messenger, NULL, &renderer->messenger); } } //- surface VkWaylandSurfaceCreateInfoKHR surface_info = {VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR}; surface_info.display = display; surface_info.surface = surface; VkCheck(vkCreateWaylandSurfaceKHR(renderer->instance, &surface_info, NULL, &renderer->surface)); //- physical device: first 1.3 device with a graphics queue that can present VkPhysicalDevice gpus[8]; u32 gpu_count = ArrayCount(gpus); VkCheck(vkEnumeratePhysicalDevices(renderer->instance, &gpu_count, gpus)); for(u32 gpu = 0; gpu < gpu_count && !renderer->gpu; ++gpu) { VkPhysicalDeviceProperties properties; vkGetPhysicalDeviceProperties(gpus[gpu], &properties); if(properties.apiVersion < VK_API_VERSION_1_3) { continue; } VkQueueFamilyProperties families[16]; u32 family_count = ArrayCount(families); vkGetPhysicalDeviceQueueFamilyProperties(gpus[gpu], &family_count, families); for(u32 family = 0; family < family_count; ++family) { VkBool32 present = VK_FALSE; vkGetPhysicalDeviceSurfaceSupportKHR(gpus[gpu], family, renderer->surface, &present); if((families[family].queueFlags & VK_QUEUE_GRAPHICS_BIT) && present) { renderer->gpu = gpus[gpu]; renderer->queue_family = family; Log("vulkan: %s", properties.deviceName); break; } } } if(!renderer->gpu) { Log("no vulkan 1.3 device that can present to wayland"); return false; } vkGetPhysicalDeviceMemoryProperties(renderer->gpu, &renderer->memory); //- device f32 priority = 1.0f; VkDeviceQueueCreateInfo queue_info = {VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO}; queue_info.queueFamilyIndex = renderer->queue_family; queue_info.queueCount = 1; queue_info.pQueuePriorities = &priority; VkPhysicalDeviceVulkan13Features features13 = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES}; features13.dynamicRendering = VK_TRUE; features13.synchronization2 = VK_TRUE; const char *device_extensions[] = {VK_KHR_SWAPCHAIN_EXTENSION_NAME}; VkDeviceCreateInfo device_info = {VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO}; device_info.pNext = &features13; device_info.queueCreateInfoCount = 1; device_info.pQueueCreateInfos = &queue_info; device_info.enabledExtensionCount = ArrayCount(device_extensions); device_info.ppEnabledExtensionNames = device_extensions; VkCheck(vkCreateDevice(renderer->gpu, &device_info, NULL, &renderer->device)); vkGetDeviceQueue(renderer->device, renderer->queue_family, 0, &renderer->queue); //- surface format: plain 8 bit unorm. the ui colors are authored in srgb and blended in // srgb, like every other desktop toolkit, so text weight matches what you'd expect. VkSurfaceFormatKHR formats[32]; u32 format_count = ArrayCount(formats); VkCheck(vkGetPhysicalDeviceSurfaceFormatsKHR(renderer->gpu, renderer->surface, &format_count, formats)); renderer->format = formats[0].format; renderer->color_space = formats[0].colorSpace; for(u32 index = 0; index < format_count; ++index) { if((formats[index].format == VK_FORMAT_B8G8R8A8_UNORM || formats[index].format == VK_FORMAT_R8G8B8A8_UNORM) && formats[index].colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) { renderer->format = formats[index].format; renderer->color_space = formats[index].colorSpace; break; } } // NOTE: pacing comes from wayland frame callbacks (see the platform layer), so prefer mailbox: // present never blocks the ui thread. fifo is the always-available fallback. { VkPresentModeKHR modes[8]; u32 mode_count = ArrayCount(modes); vkGetPhysicalDeviceSurfacePresentModesKHR(renderer->gpu, renderer->surface, &mode_count, modes); renderer->present_mode = VK_PRESENT_MODE_FIFO_KHR; for(u32 index = 0; index < mode_count; ++index) { if(modes[index] == VK_PRESENT_MODE_MAILBOX_KHR) renderer->present_mode = VK_PRESENT_MODE_MAILBOX_KHR; } } if(!vk_create_swapchain(renderer, width, height)) { return false; } //- per frame resources VkCommandPoolCreateInfo pool = {VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO}; pool.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; pool.queueFamilyIndex = renderer->queue_family; VkCheck(vkCreateCommandPool(renderer->device, &pool, NULL, &renderer->pool)); for(u32 index = 0; index < VK_FRAMES_IN_FLIGHT; ++index) { VulkanFrame *frame = &renderer->frames[index]; VkCommandBufferAllocateInfo allocate = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO}; allocate.commandPool = renderer->pool; allocate.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; allocate.commandBufferCount = 1; VkCheck(vkAllocateCommandBuffers(renderer->device, &allocate, &frame->cmd)); VkFenceCreateInfo fence = {VK_STRUCTURE_TYPE_FENCE_CREATE_INFO}; fence.flags = VK_FENCE_CREATE_SIGNALED_BIT; VkCheck(vkCreateFence(renderer->device, &fence, NULL, &frame->fence)); VkSemaphoreCreateInfo semaphore = {VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO}; VkCheck(vkCreateSemaphore(renderer->device, &semaphore, NULL, &frame->acquired)); if(!vk_create_buffer(renderer, VK_INSTANCE_BUFFER_SIZE, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, &frame->instances, &frame->instances_memory, &frame->instances_mapped) || !vk_create_buffer(renderer, VK_STAGING_BUFFER_SIZE, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, &frame->staging, &frame->staging_memory, &frame->staging_mapped)) { return false; } } return vk_create_atlas(renderer) && vk_create_pipeline(renderer); } //- frame internal void vk_write_capture(VulkanRenderer *renderer) { FILE *file = fopen(renderer->capture_path, "wb"); renderer->captured = true; if(!file) { return; } u32 w = renderer->extent.width, h = renderer->extent.height; fprintf(file, "P6\n%u %u\n255\n", w, h); b32 bgra = (renderer->format == VK_FORMAT_B8G8R8A8_UNORM || renderer->format == VK_FORMAT_B8G8R8A8_SRGB); u8 *pixels = (u8 *)renderer->readback_mapped; u8 row[3 * 4096]; for(u32 y = 0; y < h; ++y) { for(u32 x = 0; x < w && x < 4096; ++x) { u8 *p = pixels + ((u64)y * w + x) * 4; // NOTE: composite over the desktop-ish dark grey so transparent corners are visible u32 a = p[3]; u8 r = bgra ? p[2] : p[0], g = p[1], b = bgra ? p[0] : p[2]; row[x * 3 + 0] = (u8)(r + (0x30 * (255 - a)) / 255); row[x * 3 + 1] = (u8)(g + (0x30 * (255 - a)) / 255); row[x * 3 + 2] = (u8)(b + (0x30 * (255 - a)) / 255); } fwrite(row, 3, Min(w, 4096u), file); } fclose(file); Log("wrote %s (%ux%u)", renderer->capture_path, w, h); } internal DrawInstance *vk_frame_begin(VulkanRenderer *renderer) { VulkanFrame *frame = &renderer->frames[renderer->frame_index]; u64 t0 = time_now_ns(); if(vkWaitForFences(renderer->device, 1, &frame->fence, VK_TRUE, UINT64_MAX) != VK_SUCCESS) { return NULL; } u64 t1 = time_now_ns(); renderer->wait_ms += ((f32)(t1 - t0) / 1e6f - renderer->wait_ms) * 0.05f; return (DrawInstance *)frame->instances_mapped; } internal b32 vk_render(VulkanRenderer *renderer, DrawList *list, FontSystem *fonts, u32 clear_rgba) { VkDevice device = renderer->device; VulkanFrame *frame = &renderer->frames[renderer->frame_index]; // NOTE: normally vk_frame_begin already waited and the ui wrote straight into the mapped buffer u64 t1 = time_now_ns(); if(list->instances != frame->instances_mapped) { VkCheck(vkWaitForFences(device, 1, &frame->fence, VK_TRUE, UINT64_MAX)); } u32 image_index = 0; VkResult acquire = vkAcquireNextImageKHR(device, renderer->swapchain, UINT64_MAX, frame->acquired, VK_NULL_HANDLE, &image_index); u64 t2 = time_now_ns(); if(acquire == VK_ERROR_OUT_OF_DATE_KHR) { renderer->swapchain_dirty = true; return false; } if(acquire != VK_SUCCESS && acquire != VK_SUBOPTIMAL_KHR) { Log("vkAcquireNextImageKHR: %d", acquire); return false; } VkCheck(vkResetFences(device, 1, &frame->fence)); if(list->instances != frame->instances_mapped) { MemCpy(frame->instances_mapped, list->instances, sizeof(DrawInstance) * list->count); } VkCommandBuffer cmd = frame->cmd; VkCheck(vkResetCommandBuffer(cmd, 0)); VkCommandBufferBeginInfo begin = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO}; begin.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; VkCheck(vkBeginCommandBuffer(cmd, &begin)); vk_upload_atlas(renderer, frame, fonts); VkImage image = renderer->images[image_index]; vk_image_barrier(cmd, image, VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT, 0, VK_IMAGE_LAYOUT_UNDEFINED, VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT, VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); f32 clear_alpha = renderer->transparent ? (f32)(clear_rgba & 0xFF) / 255.0f : 1.0f; VkRenderingAttachmentInfo color = {VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO}; color.imageView = renderer->views[image_index]; color.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; color.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; color.storeOp = VK_ATTACHMENT_STORE_OP_STORE; color.clearValue.color = {{(f32)((clear_rgba >> 24) & 0xFF) / 255.0f * clear_alpha, (f32)((clear_rgba >> 16) & 0xFF) / 255.0f * clear_alpha, (f32)((clear_rgba >> 8) & 0xFF) / 255.0f * clear_alpha, clear_alpha}}; VkRenderingInfo rendering = {VK_STRUCTURE_TYPE_RENDERING_INFO}; rendering.renderArea = {{0, 0}, renderer->extent}; rendering.layerCount = 1; rendering.colorAttachmentCount = 1; rendering.pColorAttachments = &color; vkCmdBeginRendering(cmd, &rendering); if(list->count > 0) { VkViewport viewport = {0, 0, (f32)renderer->extent.width, (f32)renderer->extent.height, 0, 1}; vkCmdSetViewport(cmd, 0, 1, &viewport); vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, renderer->pipeline); vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, renderer->pipeline_layout, 0, 1, &renderer->descriptor_set, 0, NULL); VkDeviceSize offset = 0; vkCmdBindVertexBuffers(cmd, 0, 1, &frame->instances, &offset); f32 push[4] = {(f32)renderer->extent.width, (f32)renderer->extent.height, list->text_gamma > 0 ? list->text_gamma : 0.8f, 1.0f / FONT_ATLAS_SIZE}; vkCmdPushConstants(cmd, renderer->pipeline_layout, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(push), push); for(u32 index = 0; index < list->batch_count; ++index) { DrawBatch *batch = &list->batches[index]; if(batch->count == 0 || batch->clip[2] <= 0 || batch->clip[3] <= 0) { continue; } VkRect2D scissor = {{batch->clip[0], batch->clip[1]}, {(u32)batch->clip[2], (u32)batch->clip[3]}}; scissor.extent.width = Min(scissor.extent.width, renderer->extent.width - (u32)scissor.offset.x); scissor.extent.height = Min(scissor.extent.height, renderer->extent.height - (u32)scissor.offset.y); vkCmdSetScissor(cmd, 0, 1, &scissor); vkCmdDraw(cmd, 4, batch->count, 0, batch->first); } } vkCmdEndRendering(cmd); b32 capture = renderer->capture_path && !renderer->captured && renderer->can_capture; if(capture && !renderer->readback) { u64 size = (u64)renderer->extent.width * renderer->extent.height * 4; capture = vk_create_buffer(renderer, size, VK_BUFFER_USAGE_TRANSFER_DST_BIT, &renderer->readback, &renderer->readback_memory, &renderer->readback_mapped); } VkImageLayout present_from = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; if(capture) { vk_image_barrier(cmd, image, VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT, VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_PIPELINE_STAGE_2_COPY_BIT, VK_ACCESS_2_TRANSFER_READ_BIT, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL); VkBufferImageCopy region = {}; region.imageSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}; region.imageExtent = {renderer->extent.width, renderer->extent.height, 1}; vkCmdCopyImageToBuffer(cmd, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, renderer->readback, 1, ®ion); present_from = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; } vk_image_barrier(cmd, image, capture ? VK_PIPELINE_STAGE_2_COPY_BIT : VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT, capture ? VK_ACCESS_2_TRANSFER_READ_BIT : VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT, present_from, VK_PIPELINE_STAGE_2_NONE, 0, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR); VkCheck(vkEndCommandBuffer(cmd)); VkSemaphoreSubmitInfo wait = {VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO}; wait.semaphore = frame->acquired; wait.stageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT; VkSemaphoreSubmitInfo signal = {VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO}; signal.semaphore = renderer->rendered[image_index]; signal.stageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT; VkCommandBufferSubmitInfo command = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO}; command.commandBuffer = cmd; VkSubmitInfo2 submit = {VK_STRUCTURE_TYPE_SUBMIT_INFO_2}; submit.waitSemaphoreInfoCount = 1; submit.pWaitSemaphoreInfos = &wait; submit.commandBufferInfoCount = 1; submit.pCommandBufferInfos = &command; submit.signalSemaphoreInfoCount = 1; submit.pSignalSemaphoreInfos = &signal; u64 t3 = time_now_ns(); VkCheck(vkQueueSubmit2(renderer->queue, 1, &submit, frame->fence)); VkPresentInfoKHR present = {VK_STRUCTURE_TYPE_PRESENT_INFO_KHR}; present.waitSemaphoreCount = 1; present.pWaitSemaphores = &renderer->rendered[image_index]; present.swapchainCount = 1; present.pSwapchains = &renderer->swapchain; present.pImageIndices = &image_index; VkResult presented = vkQueuePresentKHR(renderer->queue, &present); if(presented == VK_ERROR_OUT_OF_DATE_KHR || presented == VK_SUBOPTIMAL_KHR || acquire == VK_SUBOPTIMAL_KHR) { renderer->swapchain_dirty = true; } u64 t4 = time_now_ns(); f32 k = 0.05f; renderer->acquire_ms += ((f32)(t2 - t1) / 1e6f - renderer->acquire_ms) * k; renderer->record_ms += ((f32)(t3 - t2) / 1e6f - renderer->record_ms) * k; renderer->submit_ms += ((f32)(t4 - t3) / 1e6f - renderer->submit_ms) * k; renderer->batches = list->batch_count; if(capture) { vkQueueWaitIdle(renderer->queue); vk_write_capture(renderer); } renderer->frame_index = (renderer->frame_index + 1) % VK_FRAMES_IN_FLIGHT; return true; } internal void vk_shutdown(VulkanRenderer *renderer) { VkDevice device = renderer->device; if(!device) { return; } vkDeviceWaitIdle(device); for(u32 index = 0; index < VK_FRAMES_IN_FLIGHT; ++index) { VulkanFrame *frame = &renderer->frames[index]; vkDestroyBuffer(device, frame->instances, NULL); vkFreeMemory(device, frame->instances_memory, NULL); vkDestroyBuffer(device, frame->staging, NULL); vkFreeMemory(device, frame->staging_memory, NULL); vkDestroyFence(device, frame->fence, NULL); vkDestroySemaphore(device, frame->acquired, NULL); } if(renderer->readback) { vkDestroyBuffer(device, renderer->readback, NULL); vkFreeMemory(device, renderer->readback_memory, NULL); } vkDestroyCommandPool(device, renderer->pool, NULL); vkDestroyPipeline(device, renderer->pipeline, NULL); vkDestroyPipelineLayout(device, renderer->pipeline_layout, NULL); vkDestroyDescriptorPool(device, renderer->descriptor_pool, NULL); vkDestroyDescriptorSetLayout(device, renderer->set_layout, NULL); vkDestroySampler(device, renderer->sampler, NULL); vkDestroyImageView(device, renderer->atlas_view, NULL); vkDestroyImage(device, renderer->atlas, NULL); vkFreeMemory(device, renderer->atlas_memory, NULL); vk_destroy_swapchain_views(renderer); vkDestroySwapchainKHR(device, renderer->swapchain, NULL); vkDestroyDevice(device, NULL); vkDestroySurfaceKHR(renderer->instance, renderer->surface, NULL); if(renderer->messenger) { PFN_vkDestroyDebugUtilsMessengerEXT destroy = (PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr(renderer->instance, "vkDestroyDebugUtilsMessengerEXT"); if(destroy) destroy(renderer->instance, renderer->messenger, NULL); } vkDestroyInstance(renderer->instance, NULL); }