diff --git a/src/engine/renderer/tr_backend.c b/src/engine/renderer/tr_backend.c index 66431df..6644bf6 100644 --- a/src/engine/renderer/tr_backend.c +++ b/src/engine/renderer/tr_backend.c @@ -465,7 +465,7 @@ void RB_BeginDrawingView (void) { clear_rect.baseArrayLayer = 0; clear_rect.layerCount = 1; - vkCmdClearAttachments(vk_instance.command_buffer, attachment_count, attachments, 1, &clear_rect); + vkCmdClearAttachments(vk.command_buffer, attachment_count, attachments, 1, &clear_rect); } if ( ( backEnd.refdef.rdflags & RDF_HYPERSPACE ) ) @@ -722,8 +722,8 @@ void RE_StretchRaw (int x, int y, int w, int h, int cols, int rows, const byte * qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP ); // VULKAN - vkDestroyImage(vk_instance.device, tr.scratchImage[client]->vk_image, nullptr); - vkDestroyImageView(vk_instance.device, tr.scratchImage[client]->vk_image_view, nullptr); + vkDestroyImage(vk.device, tr.scratchImage[client]->vk_image, nullptr); + vkDestroyImageView(vk.device, tr.scratchImage[client]->vk_image_view, nullptr); tr.scratchImage[client]->vk_image = vk_create_cinematic_image(cols, rows, tr.scratchImage[client]->vk_staging_buffer); tr.scratchImage[client]->vk_image_view = create_image_view(tr.scratchImage[client]->vk_image, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_ASPECT_COLOR_BIT); vk_update_cinematic_image(tr.scratchImage[client]->vk_image, tr.scratchImage[client]->vk_staging_buffer, cols, rows, data); @@ -745,7 +745,7 @@ void RE_StretchRaw (int x, int y, int w, int h, int cols, int rows, const byte * descriptor_writes[0].pBufferInfo = nullptr; descriptor_writes[0].pTexelBufferView = nullptr; - vkUpdateDescriptorSets(vk_instance.device, (uint32_t)descriptor_writes.size(), descriptor_writes.data(), 0, nullptr); + vkUpdateDescriptorSets(vk.device, (uint32_t)descriptor_writes.size(), descriptor_writes.data(), 0, nullptr); } else { if (dirty) { // otherwise, just subimage upload it so that drivers can tell we are going to be changing @@ -929,12 +929,12 @@ const void *RB_DrawBuffer( const void *data ) { } // VULKAN - VkResult result = vkAcquireNextImageKHR(vk_instance.device, vk_instance.swapchain, UINT64_MAX, vulkan_demo->image_acquired, VK_NULL_HANDLE, &vulkan_demo->swapchain_image_index); + VkResult result = vkAcquireNextImageKHR(vk.device, vk.swapchain, UINT64_MAX, vulkan_demo->image_acquired, VK_NULL_HANDLE, &vulkan_demo->swapchain_image_index); check_vk_result(result, "vkAcquireNextImageKHR"); - result = vkWaitForFences(vk_instance.device, 1, &vulkan_demo->rendering_finished_fence, VK_FALSE, 1e9); + result = vkWaitForFences(vk.device, 1, &vulkan_demo->rendering_finished_fence, VK_FALSE, 1e9); check_vk_result(result, "vkWaitForFences"); - result = vkResetFences(vk_instance.device, 1, &vulkan_demo->rendering_finished_fence); + result = vkResetFences(vk.device, 1, &vulkan_demo->rendering_finished_fence); check_vk_result(result, "vkResetFences"); VkCommandBufferBeginInfo begin_info; @@ -947,7 +947,7 @@ const void *RB_DrawBuffer( const void *data ) { fprintf(logfile, "begin\n"); fflush(logfile); - result = vkBeginCommandBuffer(vk_instance.command_buffer, &begin_info); + result = vkBeginCommandBuffer(vk.command_buffer, &begin_info); check_vk_result(result, "vkBeginCommandBuffer"); vulkan_demo->begin_frame(); @@ -1064,7 +1064,7 @@ const void *RB_SwapBuffers( const void *data ) { extern FILE* logfile; vulkan_demo->end_frame(); - VkResult result = vkEndCommandBuffer(vk_instance.command_buffer); + VkResult result = vkEndCommandBuffer(vk.command_buffer); check_vk_result(result, "vkEndCommandBuffer"); fprintf(logfile, "present\n"); @@ -1078,11 +1078,11 @@ const void *RB_SwapBuffers( const void *data ) { submit_info.pWaitSemaphores = &vulkan_demo->image_acquired; submit_info.pWaitDstStageMask = &wait_dst_stage_mask; submit_info.commandBufferCount = 1; - submit_info.pCommandBuffers = &vk_instance.command_buffer; + submit_info.pCommandBuffers = &vk.command_buffer; submit_info.signalSemaphoreCount = 1; submit_info.pSignalSemaphores = &vulkan_demo->rendering_finished; - result = vkQueueSubmit(vk_instance.queue, 1, &submit_info, vulkan_demo->rendering_finished_fence); + result = vkQueueSubmit(vk.queue, 1, &submit_info, vulkan_demo->rendering_finished_fence); check_vk_result(result, "vkQueueSubmit"); VkPresentInfoKHR present_info; @@ -1091,10 +1091,10 @@ const void *RB_SwapBuffers( const void *data ) { present_info.waitSemaphoreCount = 1; present_info.pWaitSemaphores = &vulkan_demo->rendering_finished; present_info.swapchainCount = 1; - present_info.pSwapchains = &vk_instance.swapchain; + present_info.pSwapchains = &vk.swapchain; present_info.pImageIndices = &vulkan_demo->swapchain_image_index; present_info.pResults = nullptr; - result = vkQueuePresentKHR(vk_instance.queue, &present_info); + result = vkQueuePresentKHR(vk.queue, &present_info); check_vk_result(result, "vkQueuePresentKHR"); return (const void *)(cmd + 1); diff --git a/src/engine/renderer/tr_image.c b/src/engine/renderer/tr_image.c index c2aabf4..52d5771 100644 --- a/src/engine/renderer/tr_image.c +++ b/src/engine/renderer/tr_image.c @@ -1846,16 +1846,16 @@ void R_DeleteTextures( void ) { int i; // VULKAN - vkDeviceWaitIdle(vk_instance.device); + vkDeviceWaitIdle(vk.device); for ( i=0; itexnum ); // VULKAN - vkDestroyImage(vk_instance.device, tr.images[i]->vk_image, nullptr); - vkDestroyImageView(vk_instance.device, tr.images[i]->vk_image_view, nullptr); + vkDestroyImage(vk.device, tr.images[i]->vk_image, nullptr); + vkDestroyImageView(vk.device, tr.images[i]->vk_image_view, nullptr); if (tr.images[i]->vk_staging_buffer.handle != VK_NULL_HANDLE) - vkDestroyBuffer(vk_instance.device, tr.images[i]->vk_staging_buffer.handle, nullptr); + vkDestroyBuffer(vk.device, tr.images[i]->vk_staging_buffer.handle, nullptr); } Com_Memset( tr.images, 0, sizeof( tr.images ) ); diff --git a/src/engine/renderer/tr_init.c b/src/engine/renderer/tr_init.c index ae04204..165f24c 100644 --- a/src/engine/renderer/tr_init.c +++ b/src/engine/renderer/tr_init.c @@ -27,7 +27,7 @@ glconfig_t glConfig; glstate_t glState; // VULKAN -Vulkan_Instance vk_instance; +Vulkan_Instance vk; static void GfxInfo_f( void ); diff --git a/src/engine/renderer/tr_local.h b/src/engine/renderer/tr_local.h index 62992ed..e6f6895 100644 --- a/src/engine/renderer/tr_local.h +++ b/src/engine/renderer/tr_local.h @@ -945,7 +945,7 @@ typedef struct { float fogTable[FOG_TABLE_SIZE]; // VULKAN - Vulkan_Resources vk; + Vulkan_Resources vk_resources; } trGlobals_t; @@ -955,7 +955,7 @@ extern glconfig_t glConfig; // outside of TR since it shouldn't be cleared duri extern glstate_t glState; // outside of TR since it shouldn't be cleared during ref re-init // VULKAN -extern Vulkan_Instance vk_instance; // same as above - shouldn't be cleared during ref re-init +extern Vulkan_Instance vk; // same as above - shouldn't be cleared during ref re-init // VULKAN class Vulkan_Demo; diff --git a/src/engine/renderer/vk.cpp b/src/engine/renderer/vk.cpp index 3d0a923..cfbfb63 100644 --- a/src/engine/renderer/vk.cpp +++ b/src/engine/renderer/vk.cpp @@ -259,7 +259,7 @@ static VkSwapchainKHR create_swapchain(VkPhysicalDevice physical_device, VkDevic static VkRenderPass create_render_pass(VkPhysicalDevice physical_device, VkDevice device) { VkAttachmentDescription color_attachment; color_attachment.flags = 0; - color_attachment.format = vk_instance.surface_format.format; + color_attachment.format = vk.surface_format.format; color_attachment.samples = VK_SAMPLE_COUNT_1_BIT; color_attachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; color_attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE; @@ -319,7 +319,7 @@ static VkRenderPass create_render_pass(VkPhysicalDevice physical_device, VkDevic bool vk_initialize(HWND hwnd) { try { - auto& g = vk_instance; + auto& g = vk; g.instance = create_instance(); g.physical_device = select_physical_device(g.instance); @@ -332,16 +332,16 @@ bool vk_initialize(HWND hwnd) { g.swapchain = create_swapchain(g.physical_device, g.device, g.surface, g.surface_format); - VkResult result = vkGetSwapchainImagesKHR(g.device, g.swapchain, &vk_instance.swapchain_image_count, nullptr); + VkResult result = vkGetSwapchainImagesKHR(g.device, g.swapchain, &vk.swapchain_image_count, nullptr); check_vk_result(result, "vkGetSwapchainImagesKHR"); - if (vk_instance.swapchain_image_count > MAX_SWAPCHAIN_IMAGES) - ri.Error( ERR_FATAL, "initialize_vulkan: swapchain image count (%d) exceeded limit (%d)", vk_instance.swapchain_image_count, MAX_SWAPCHAIN_IMAGES ); + if (vk.swapchain_image_count > MAX_SWAPCHAIN_IMAGES) + ri.Error( ERR_FATAL, "initialize_vulkan: swapchain image count (%d) exceeded limit (%d)", vk.swapchain_image_count, MAX_SWAPCHAIN_IMAGES ); - result = vkGetSwapchainImagesKHR(g.device, g.swapchain, &vk_instance.swapchain_image_count, g.swapchain_images); + result = vkGetSwapchainImagesKHR(g.device, g.swapchain, &vk.swapchain_image_count, g.swapchain_images); check_vk_result(result, "vkGetSwapchainImagesKHR"); - for (std::size_t i = 0; i < vk_instance.swapchain_image_count; i++) { + for (std::size_t i = 0; i < vk.swapchain_image_count; i++) { VkImageViewCreateInfo desc; desc.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; desc.pNext = nullptr; @@ -367,9 +367,9 @@ bool vk_initialize(HWND hwnd) { desc.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; desc.pNext = nullptr; desc.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT | VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; - desc.queueFamilyIndex = vk_instance.queue_family_index; + desc.queueFamilyIndex = vk.queue_family_index; - result = vkCreateCommandPool(g.device, &desc, nullptr, &vk_instance.command_pool); + result = vkCreateCommandPool(g.device, &desc, nullptr, &vk.command_pool); check_vk_result(result, "vkCreateCommandPool"); } @@ -377,23 +377,23 @@ bool vk_initialize(HWND hwnd) { VkCommandBufferAllocateInfo alloc_info; alloc_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; alloc_info.pNext = nullptr; - alloc_info.commandPool = vk_instance.command_pool; + alloc_info.commandPool = vk.command_pool; alloc_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; alloc_info.commandBufferCount = 1; - result = vkAllocateCommandBuffers(vk_instance.device, &alloc_info, &g.command_buffer); + result = vkAllocateCommandBuffers(vk.device, &alloc_info, &g.command_buffer); check_vk_result(result, "vkAllocateCommandBuffers"); } - get_allocator()->initialize(vk_instance.physical_device, vk_instance.device); - get_resource_manager()->initialize(vk_instance.device); + get_allocator()->initialize(vk.physical_device, vk.device); + get_resource_manager()->initialize(vk.device); { - VkFormat depth_format = find_depth_format(vk_instance.physical_device); - vk_instance.depth_image = create_depth_attachment_image(glConfig.vidWidth, glConfig.vidHeight, depth_format); - vk_instance.depth_image_view = create_image_view(vk_instance.depth_image, depth_format, VK_IMAGE_ASPECT_DEPTH_BIT); + VkFormat depth_format = find_depth_format(vk.physical_device); + vk.depth_image = create_depth_attachment_image(glConfig.vidWidth, glConfig.vidHeight, depth_format); + vk.depth_image_view = create_image_view(vk.depth_image, depth_format, VK_IMAGE_ASPECT_DEPTH_BIT); - record_and_run_commands(vk_instance.command_pool, vk_instance.queue, [&depth_format](VkCommandBuffer command_buffer) { - record_image_layout_transition(command_buffer, vk_instance.depth_image, depth_format, 0, VK_IMAGE_LAYOUT_UNDEFINED, + record_and_run_commands(vk.command_pool, vk.queue, [&depth_format](VkCommandBuffer command_buffer) { + record_image_layout_transition(command_buffer, vk.depth_image, depth_format, 0, VK_IMAGE_LAYOUT_UNDEFINED, VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL); }); } @@ -401,22 +401,22 @@ bool vk_initialize(HWND hwnd) { g.render_pass = create_render_pass(g.physical_device, g.device); { - std::array attachments = {VK_NULL_HANDLE, vk_instance.depth_image_view}; + std::array attachments = {VK_NULL_HANDLE, vk.depth_image_view}; VkFramebufferCreateInfo desc; desc.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; desc.pNext = nullptr; desc.flags = 0; - desc.renderPass = vk_instance.render_pass; + desc.renderPass = vk.render_pass; desc.attachmentCount = static_cast(attachments.size()); desc.pAttachments = attachments.data(); desc.width = glConfig.vidWidth; desc.height = glConfig.vidHeight; desc.layers = 1; - for (uint32_t i = 0; i < vk_instance.swapchain_image_count; i++) { - attachments[0] = vk_instance.swapchain_image_views[i]; // set color attachment - VkResult result = vkCreateFramebuffer(vk_instance.device, &desc, nullptr, &vk_instance.framebuffers[i]); + for (uint32_t i = 0; i < vk.swapchain_image_count; i++) { + attachments[0] = vk.swapchain_image_views[i]; // set color attachment + VkResult result = vkCreateFramebuffer(vk.device, &desc, nullptr, &vk.framebuffers[i]); check_vk_result(result, "vkCreateFramebuffer"); } } @@ -428,20 +428,20 @@ bool vk_initialize(HWND hwnd) { } void vk_deinitialize() { - auto& g = vk_instance; + auto& g = vk; get_resource_manager()->release_resources(); get_allocator()->deallocate_all(); - vkDestroyFence(vk_instance.device, vulkan_demo->rendering_finished_fence, nullptr); - vkDestroyImage(vk_instance.device, vk_instance.depth_image, nullptr); - vkDestroyImageView(vk_instance.device, vk_instance.depth_image_view, nullptr); + vkDestroyFence(vk.device, vulkan_demo->rendering_finished_fence, nullptr); + vkDestroyImage(vk.device, vk.depth_image, nullptr); + vkDestroyImageView(vk.device, vk.depth_image_view, nullptr); - for (uint32_t i = 0; i < vk_instance.swapchain_image_count; i++) { - vkDestroyFramebuffer(vk_instance.device, vk_instance.framebuffers[i], nullptr); + for (uint32_t i = 0; i < vk.swapchain_image_count; i++) { + vkDestroyFramebuffer(vk.device, vk.framebuffers[i], nullptr); } - vkDestroyRenderPass(vk_instance.device, vk_instance.render_pass, nullptr); + vkDestroyRenderPass(vk.device, vk.render_pass, nullptr); vkDestroyCommandPool(g.device, g.command_pool, nullptr); @@ -469,11 +469,11 @@ VkImage vk_create_cinematic_image(int width, int height, Vk_Staging_Buffer& stag buffer_desc.pQueueFamilyIndices = nullptr; VkBuffer buffer; - VkResult result = vkCreateBuffer(vk_instance.device, &buffer_desc, nullptr, &buffer); + VkResult result = vkCreateBuffer(vk.device, &buffer_desc, nullptr, &buffer); check_vk_result(result, "vkCreateBuffer"); VkDeviceMemory buffer_memory = get_allocator()->allocate_staging_memory(buffer); - result = vkBindBufferMemory(vk_instance.device, buffer, buffer_memory, 0); + result = vkBindBufferMemory(vk.device, buffer, buffer_memory, 0); check_vk_result(result, "vkBindBufferMemory"); VkImageCreateInfo image_desc; @@ -496,11 +496,11 @@ VkImage vk_create_cinematic_image(int width, int height, Vk_Staging_Buffer& stag image_desc.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; VkImage image; - result = vkCreateImage(vk_instance.device, &image_desc, nullptr, &image); + result = vkCreateImage(vk.device, &image_desc, nullptr, &image); check_vk_result(result, "vkCreateImage"); VkDeviceMemory image_memory = get_allocator()->allocate_memory(image); - result = vkBindImageMemory(vk_instance.device, image, image_memory, 0); + result = vkBindImageMemory(vk.device, image, image_memory, 0); check_vk_result(result, "vkBindImageMemory"); staging_buffer.handle = buffer; @@ -512,12 +512,12 @@ VkImage vk_create_cinematic_image(int width, int height, Vk_Staging_Buffer& stag void vk_update_cinematic_image(VkImage image, const Vk_Staging_Buffer& staging_buffer, int width, int height, const uint8_t* rgba_pixels) { void* buffer_data; - VkResult result = vkMapMemory(vk_instance.device, staging_buffer.memory, staging_buffer.offset, staging_buffer.size, 0, &buffer_data); + VkResult result = vkMapMemory(vk.device, staging_buffer.memory, staging_buffer.offset, staging_buffer.size, 0, &buffer_data); check_vk_result(result, "vkMapMemory"); memcpy(buffer_data, rgba_pixels, staging_buffer.size); - vkUnmapMemory(vk_instance.device, staging_buffer.memory); + vkUnmapMemory(vk.device, staging_buffer.memory); - record_and_run_commands(vk_instance.command_pool, vk_instance.queue, + record_and_run_commands(vk.command_pool, vk.queue, [&image, &staging_buffer, &width, &height](VkCommandBuffer command_buffer) { record_image_layout_transition(command_buffer, image, VK_FORMAT_R8G8B8A8_UNORM, @@ -799,13 +799,13 @@ static VkPipeline create_pipeline(const Vk_Pipeline_Desc& desc) { create_info.pColorBlendState = &blend_state; create_info.pDynamicState = &dynamic_state; create_info.layout = vulkan_demo->pipeline_layout; - create_info.renderPass = vk_instance.render_pass; + create_info.renderPass = vk.render_pass; create_info.subpass = 0; create_info.basePipelineHandle = VK_NULL_HANDLE; create_info.basePipelineIndex = -1; VkPipeline pipeline; - VkResult result = vkCreateGraphicsPipelines(vk_instance.device, VK_NULL_HANDLE, 1, &create_info, nullptr, &pipeline); + VkResult result = vkCreateGraphicsPipelines(vk.device, VK_NULL_HANDLE, 1, &create_info, nullptr, &pipeline); check_vk_result(result, "vkCreateGraphicsPipelines"); return pipeline; } @@ -825,13 +825,13 @@ struct Timer { }; VkPipeline vk_find_pipeline(const Vk_Pipeline_Desc& desc) { - for (int i = 0; i < tr.vk.num_pipelines; i++) { - if (tr.vk.pipeline_desc[i] == desc) { - return tr.vk.pipelines[i]; + for (int i = 0; i < tr.vk_resources.num_pipelines; i++) { + if (tr.vk_resources.pipeline_desc[i] == desc) { + return tr.vk_resources.pipelines[i]; } } - if (tr.vk.num_pipelines == MAX_VK_PIPELINES) { + if (tr.vk_resources.num_pipelines == MAX_VK_PIPELINES) { ri.Error( ERR_DROP, "vk_find_pipeline: MAX_VK_PIPELINES hit\n"); } @@ -839,26 +839,26 @@ VkPipeline vk_find_pipeline(const Vk_Pipeline_Desc& desc) { VkPipeline pipeline = create_pipeline(desc); pipeline_create_time += t.Elapsed_Seconds(); - tr.vk.pipeline_desc[tr.vk.num_pipelines] = desc; - tr.vk.pipelines[tr.vk.num_pipelines] = pipeline; - tr.vk.num_pipelines++; + tr.vk_resources.pipeline_desc[tr.vk_resources.num_pipelines] = desc; + tr.vk_resources.pipelines[tr.vk_resources.num_pipelines] = pipeline; + tr.vk_resources.num_pipelines++; return pipeline; } static void vk_destroy_pipelines() { - for (int i = 0; i < tr.vk.num_pipelines; i++) { - vkDestroyPipeline(vk_instance.device, tr.vk.pipelines[i], nullptr); + for (int i = 0; i < tr.vk_resources.num_pipelines; i++) { + vkDestroyPipeline(vk.device, tr.vk_resources.pipelines[i], nullptr); } - tr.vk.num_pipelines = 0; - Com_Memset(tr.vk.pipelines, 0, sizeof(tr.vk.pipelines)); - Com_Memset(tr.vk.pipeline_desc, 0, sizeof(tr.vk.pipeline_desc)); + tr.vk_resources.num_pipelines = 0; + Com_Memset(tr.vk_resources.pipelines, 0, sizeof(tr.vk_resources.pipelines)); + Com_Memset(tr.vk_resources.pipeline_desc, 0, sizeof(tr.vk_resources.pipeline_desc)); pipeline_create_time = 0.0f; } void vk_destroy_resources() { - vkDeviceWaitIdle(vk_instance.device); + vkDeviceWaitIdle(vk.device); vk_destroy_pipelines(); } diff --git a/src/engine/renderer/vk_demo.cpp b/src/engine/renderer/vk_demo.cpp index d503bee..45a15ae 100644 --- a/src/engine/renderer/vk_demo.cpp +++ b/src/engine/renderer/vk_demo.cpp @@ -33,7 +33,7 @@ Vulkan_Demo::Vulkan_Demo(int window_width, int window_height) fence_desc.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; fence_desc.pNext = nullptr; fence_desc.flags = VK_FENCE_CREATE_SIGNALED_BIT; - VkResult result = vkCreateFence(vk_instance.device, &fence_desc, nullptr, &rendering_finished_fence); + VkResult result = vkCreateFence(vk.device, &fence_desc, nullptr, &rendering_finished_fence); check_vk_result(result, "vkCreateFence"); create_descriptor_pool(); @@ -72,7 +72,7 @@ void Vulkan_Demo::create_uniform_buffer() { uniform_buffer = create_buffer(size, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT); VkPhysicalDeviceProperties props; - vkGetPhysicalDeviceProperties(vk_instance.physical_device, &props); + vkGetPhysicalDeviceProperties(vk.physical_device, &props); VkDeviceSize offset_align = props.limits.minUniformBufferOffsetAlignment; tess_ubo_offset_step = (uint32_t)((sizeof(Uniform_Buffer_Object) + offset_align - 1) / offset_align * offset_align); } @@ -82,13 +82,13 @@ VkImage Vulkan_Demo::create_texture(const uint8_t* pixels, int bytes_per_pixel, bytes_per_pixel == 3 ? VK_FORMAT_R8G8B8_UNORM : VK_FORMAT_R8G8B8A8_UNORM, pixels, bytes_per_pixel); Defer_Action destroy_staging_image([this, &staging_image]() { - vkDestroyImage(vk_instance.device, staging_image, nullptr); + vkDestroyImage(vk.device, staging_image, nullptr); }); VkImage texture_image = ::create_texture(image_width, image_height, bytes_per_pixel == 3 ? VK_FORMAT_R8G8B8_UNORM : VK_FORMAT_R8G8B8A8_UNORM); - record_and_run_commands(vk_instance.command_pool, vk_instance.queue, + record_and_run_commands(vk.command_pool, vk.queue, [&texture_image, &staging_image, &image_width, &image_height, this](VkCommandBuffer command_buffer) { record_image_layout_transition(command_buffer, staging_image, VK_FORMAT_R8G8B8A8_UNORM, @@ -188,7 +188,7 @@ void Vulkan_Demo::create_image_descriptor_set(const image_t* image) { desc.pSetLayouts = &descriptor_set_layout; VkDescriptorSet set; - VkResult result = vkAllocateDescriptorSets(vk_instance.device, &desc, &set); + VkResult result = vkAllocateDescriptorSets(vk.device, &desc, &set); check_vk_result(result, "vkAllocateDescriptorSets"); VkDescriptorImageInfo image_info; @@ -208,7 +208,7 @@ void Vulkan_Demo::create_image_descriptor_set(const image_t* image) { descriptor_writes[0].pBufferInfo = nullptr; descriptor_writes[0].pTexelBufferView = nullptr; - vkUpdateDescriptorSets(vk_instance.device, (uint32_t)descriptor_writes.size(), descriptor_writes.data(), 0, nullptr); + vkUpdateDescriptorSets(vk.device, (uint32_t)descriptor_writes.size(), descriptor_writes.data(), 0, nullptr); update_ubo_descriptor(set); @@ -224,7 +224,7 @@ void Vulkan_Demo::create_multitexture_descriptor_set(const image_t* image, const desc.pSetLayouts = &descriptor_set_layout; VkDescriptorSet set; - VkResult result = vkAllocateDescriptorSets(vk_instance.device, &desc, &set); + VkResult result = vkAllocateDescriptorSets(vk.device, &desc, &set); check_vk_result(result, "vkAllocateDescriptorSets"); VkDescriptorImageInfo image_info[2]; @@ -259,7 +259,7 @@ void Vulkan_Demo::create_multitexture_descriptor_set(const image_t* image, const descriptor_writes[1].pBufferInfo = nullptr; descriptor_writes[1].pTexelBufferView = nullptr; - vkUpdateDescriptorSets(vk_instance.device, (uint32_t)descriptor_writes.size(), descriptor_writes.data(), 0, nullptr); + vkUpdateDescriptorSets(vk.device, (uint32_t)descriptor_writes.size(), descriptor_writes.data(), 0, nullptr); update_ubo_descriptor(set); @@ -295,7 +295,7 @@ void Vulkan_Demo::upload_geometry() { tess_vertex_buffer = get_resource_manager()->create_buffer(desc); tess_vertex_buffer_memory = get_allocator()->allocate_staging_memory(tess_vertex_buffer); - VkResult result = vkBindBufferMemory(vk_instance.device, tess_vertex_buffer, tess_vertex_buffer_memory, 0); + VkResult result = vkBindBufferMemory(vk.device, tess_vertex_buffer, tess_vertex_buffer_memory, 0); check_vk_result(result, "vkBindBufferMemory"); } @@ -312,7 +312,7 @@ void Vulkan_Demo::upload_geometry() { tess_index_buffer = get_resource_manager()->create_buffer(desc); tess_index_buffer_memory = get_allocator()->allocate_staging_memory(tess_index_buffer); - VkResult result = vkBindBufferMemory(vk_instance.device, tess_index_buffer, tess_index_buffer_memory, 0); + VkResult result = vkBindBufferMemory(vk.device, tess_index_buffer, tess_index_buffer_memory, 0); check_vk_result(result, "vkBindBufferMemory"); } } @@ -335,7 +335,7 @@ void Vulkan_Demo::update_ubo_descriptor(VkDescriptorSet set) { descriptor_writes[0].pBufferInfo = &buffer_info; descriptor_writes[0].pTexelBufferView = nullptr; - vkUpdateDescriptorSets(vk_instance.device, (uint32_t)descriptor_writes.size(), descriptor_writes.data(), 0, nullptr); + vkUpdateDescriptorSets(vk.device, (uint32_t)descriptor_writes.size(), descriptor_writes.data(), 0, nullptr); } void Vulkan_Demo::update_uniform_buffer() { @@ -372,10 +372,10 @@ void Vulkan_Demo::update_uniform_buffer() { } void* data; - VkResult result = vkMapMemory(vk_instance.device, uniform_staging_buffer_memory, tess_ubo_offset, sizeof(ubo), 0, &data); + VkResult result = vkMapMemory(vk.device, uniform_staging_buffer_memory, tess_ubo_offset, sizeof(ubo), 0, &data); check_vk_result(result, "vkMapMemory"); memcpy(data, &ubo, sizeof(ubo)); - vkUnmapMemory(vk_instance.device, uniform_staging_buffer_memory); + vkUnmapMemory(vk.device, uniform_staging_buffer_memory); } void Vulkan_Demo::begin_frame() { @@ -386,7 +386,7 @@ void Vulkan_Demo::begin_frame() { region.srcOffset = 0; region.dstOffset = 0; region.size = sizeof(Uniform_Buffer_Object) * 1024; - vkCmdCopyBuffer(vk_instance.command_buffer, uniform_staging_buffer, uniform_buffer, 1, ®ion); + vkCmdCopyBuffer(vk.command_buffer, uniform_staging_buffer, uniform_buffer, 1, ®ion); VkBufferMemoryBarrier barrier; barrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER; @@ -399,7 +399,7 @@ void Vulkan_Demo::begin_frame() { barrier.offset = 0; barrier.size = sizeof(Uniform_Buffer_Object) * 1024; - vkCmdPipelineBarrier(vk_instance.command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, 0, + vkCmdPipelineBarrier(vk.command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, 0, 0, nullptr, 1, &barrier, 0, nullptr); std::array clear_values; @@ -409,14 +409,14 @@ void Vulkan_Demo::begin_frame() { VkRenderPassBeginInfo render_pass_begin_info; render_pass_begin_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; render_pass_begin_info.pNext = nullptr; - render_pass_begin_info.renderPass = vk_instance.render_pass; - render_pass_begin_info.framebuffer = vk_instance.framebuffers[swapchain_image_index]; + render_pass_begin_info.renderPass = vk.render_pass; + render_pass_begin_info.framebuffer = vk.framebuffers[swapchain_image_index]; render_pass_begin_info.renderArea.offset = {0, 0}; render_pass_begin_info.renderArea.extent = {(uint32_t)window_width, (uint32_t)window_height}; render_pass_begin_info.clearValueCount = static_cast(clear_values.size()); render_pass_begin_info.pClearValues = clear_values.data(); - vkCmdBeginRenderPass(vk_instance.command_buffer, &render_pass_begin_info, VK_SUBPASS_CONTENTS_INLINE); + vkCmdBeginRenderPass(vk.command_buffer, &render_pass_begin_info, VK_SUBPASS_CONTENTS_INLINE); tess_vertex_buffer_offset = 0; tess_index_buffer_offset = 0; @@ -428,7 +428,7 @@ void Vulkan_Demo::begin_frame() { void Vulkan_Demo::end_frame() { fprintf(logfile, "end_frame (vb_size %d, ib_size %d, ubo_size %d)\n", (int)tess_vertex_buffer_offset, (int)tess_index_buffer_offset, (int)tess_ubo_offset); fflush(logfile); - vkCmdEndRenderPass(vk_instance.command_buffer); + vkCmdEndRenderPass(vk.command_buffer); } void Vulkan_Demo::render_tess(const shaderStage_t* stage) { @@ -436,7 +436,7 @@ void Vulkan_Demo::render_tess(const shaderStage_t* stage) { fflush(logfile); void* data; - VkResult result = vkMapMemory(vk_instance.device, tess_vertex_buffer_memory, tess_vertex_buffer_offset, tess.numVertexes * sizeof(Vk_Vertex), 0, &data); + VkResult result = vkMapMemory(vk.device, tess_vertex_buffer_memory, tess_vertex_buffer_offset, tess.numVertexes * sizeof(Vk_Vertex), 0, &data); check_vk_result(result, "vkMapMemory"); Vk_Vertex* v = (Vk_Vertex*)data; for (int i = 0; i < tess.numVertexes; i++, v++) { @@ -450,31 +450,31 @@ void Vulkan_Demo::render_tess(const shaderStage_t* stage) { v->st[0] = tess.svars.texcoords[0][i][0]; v->st[1] = tess.svars.texcoords[0][i][1]; } - vkUnmapMemory(vk_instance.device, tess_vertex_buffer_memory); + vkUnmapMemory(vk.device, tess_vertex_buffer_memory); - result = vkMapMemory(vk_instance.device, tess_index_buffer_memory, tess_index_buffer_offset, tess.numIndexes * sizeof(uint32_t), 0, &data); + result = vkMapMemory(vk.device, tess_index_buffer_memory, tess_index_buffer_offset, tess.numIndexes * sizeof(uint32_t), 0, &data); check_vk_result(result, "vkMapMemory"); uint32_t* ind = (uint32_t*)data; for (int i = 0; i < tess.numIndexes; i++, ind++) { *ind = tess.indexes[i]; } - vkUnmapMemory(vk_instance.device, tess_index_buffer_memory); + vkUnmapMemory(vk.device, tess_index_buffer_memory); const VkDeviceSize offset = 0; - vkCmdBindVertexBuffers(vk_instance.command_buffer, 0, 1, &tess_vertex_buffer, &tess_vertex_buffer_offset); - vkCmdBindIndexBuffer(vk_instance.command_buffer, tess_index_buffer, tess_index_buffer_offset, VK_INDEX_TYPE_UINT32); + vkCmdBindVertexBuffers(vk.command_buffer, 0, 1, &tess_vertex_buffer, &tess_vertex_buffer_offset); + vkCmdBindIndexBuffer(vk.command_buffer, tess_index_buffer, tess_index_buffer_offset, VK_INDEX_TYPE_UINT32); image_t* image = glState.vk_current_images[0]; VkDescriptorSet set = image_descriptor_sets[image]; update_uniform_buffer(); - vkCmdBindDescriptorSets(vk_instance.command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout, 0, 1, &set, 1, &tess_ubo_offset); + vkCmdBindDescriptorSets(vk.command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout, 0, 1, &set, 1, &tess_ubo_offset); tess_ubo_offset += tess_ubo_offset_step; - vkCmdBindPipeline(vk_instance.command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, stage->vk_pipeline); + vkCmdBindPipeline(vk.command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, stage->vk_pipeline); VkRect2D r = vk_get_viewport_rect(); - vkCmdSetScissor(vk_instance.command_buffer, 0, 1, &r); + vkCmdSetScissor(vk.command_buffer, 0, 1, &r); VkViewport viewport; viewport.x = (float)r.offset.x; @@ -483,13 +483,13 @@ void Vulkan_Demo::render_tess(const shaderStage_t* stage) { viewport.height = (float)r.extent.height; viewport.minDepth = 0.0f; viewport.maxDepth = 1.0f; - vkCmdSetViewport(vk_instance.command_buffer, 0, 1, &viewport); + vkCmdSetViewport(vk.command_buffer, 0, 1, &viewport); if (tess.shader->polygonOffset) { - vkCmdSetDepthBias(vk_instance.command_buffer, r_offsetUnits->value, 0.0f, r_offsetFactor->value); + vkCmdSetDepthBias(vk.command_buffer, r_offsetUnits->value, 0.0f, r_offsetFactor->value); } - vkCmdDrawIndexed(vk_instance.command_buffer, tess.numIndexes, 1, 0, 0, 0); + vkCmdDrawIndexed(vk.command_buffer, tess.numIndexes, 1, 0, 0, 0); tess_vertex_buffer_offset += tess.numVertexes * sizeof(Vk_Vertex); tess_index_buffer_offset += tess.numIndexes * sizeof(uint32_t); @@ -501,7 +501,7 @@ void Vulkan_Demo::render_tess_multi(const shaderStage_t* stage) { fflush(logfile); void* data; - VkResult result = vkMapMemory(vk_instance.device, tess_vertex_buffer_memory, tess_vertex_buffer_offset, tess.numVertexes * sizeof(Vk_Vertex2), 0, &data); + VkResult result = vkMapMemory(vk.device, tess_vertex_buffer_memory, tess_vertex_buffer_offset, tess.numVertexes * sizeof(Vk_Vertex2), 0, &data); check_vk_result(result, "vkMapMemory"); Vk_Vertex2* v = (Vk_Vertex2*)data; for (int i = 0; i < tess.numVertexes; i++, v++) { @@ -517,19 +517,19 @@ void Vulkan_Demo::render_tess_multi(const shaderStage_t* stage) { v->st2[0] = tess.svars.texcoords[1][i][0]; v->st2[1] = tess.svars.texcoords[1][i][1]; } - vkUnmapMemory(vk_instance.device, tess_vertex_buffer_memory); + vkUnmapMemory(vk.device, tess_vertex_buffer_memory); - result = vkMapMemory(vk_instance.device, tess_index_buffer_memory, tess_index_buffer_offset, tess.numIndexes * sizeof(uint32_t), 0, &data); + result = vkMapMemory(vk.device, tess_index_buffer_memory, tess_index_buffer_offset, tess.numIndexes * sizeof(uint32_t), 0, &data); check_vk_result(result, "vkMapMemory"); uint32_t* ind = (uint32_t*)data; for (int i = 0; i < tess.numIndexes; i++, ind++) { *ind = tess.indexes[i]; } - vkUnmapMemory(vk_instance.device, tess_index_buffer_memory); + vkUnmapMemory(vk.device, tess_index_buffer_memory); const VkDeviceSize offset = 0; - vkCmdBindVertexBuffers(vk_instance.command_buffer, 0, 1, &tess_vertex_buffer, &tess_vertex_buffer_offset); - vkCmdBindIndexBuffer(vk_instance.command_buffer, tess_index_buffer, tess_index_buffer_offset, VK_INDEX_TYPE_UINT32); + vkCmdBindVertexBuffers(vk.command_buffer, 0, 1, &tess_vertex_buffer, &tess_vertex_buffer_offset); + vkCmdBindIndexBuffer(vk.command_buffer, tess_index_buffer, tess_index_buffer_offset, VK_INDEX_TYPE_UINT32); image_t* image = glState.vk_current_images[0]; image_t* image2 = glState.vk_current_images[1]; @@ -542,13 +542,13 @@ void Vulkan_Demo::render_tess_multi(const shaderStage_t* stage) { auto set = it->second; update_uniform_buffer(); - vkCmdBindDescriptorSets(vk_instance.command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout, 0, 1, &set, 1, &tess_ubo_offset); + vkCmdBindDescriptorSets(vk.command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout, 0, 1, &set, 1, &tess_ubo_offset); tess_ubo_offset += tess_ubo_offset_step; - vkCmdBindPipeline(vk_instance.command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, stage->vk_pipeline); + vkCmdBindPipeline(vk.command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, stage->vk_pipeline); VkRect2D r = vk_get_viewport_rect(); - vkCmdSetScissor(vk_instance.command_buffer, 0, 1, &r); + vkCmdSetScissor(vk.command_buffer, 0, 1, &r); VkViewport viewport; viewport.x = (float)r.offset.x; @@ -557,13 +557,13 @@ void Vulkan_Demo::render_tess_multi(const shaderStage_t* stage) { viewport.height = (float)r.extent.height; viewport.minDepth = 0.0f; viewport.maxDepth = 1.0f; - vkCmdSetViewport(vk_instance.command_buffer, 0, 1, &viewport); + vkCmdSetViewport(vk.command_buffer, 0, 1, &viewport); if (tess.shader->polygonOffset) { - vkCmdSetDepthBias(vk_instance.command_buffer, r_offsetUnits->value, 0.0f, r_offsetFactor->value); + vkCmdSetDepthBias(vk.command_buffer, r_offsetUnits->value, 0.0f, r_offsetFactor->value); } - vkCmdDrawIndexed(vk_instance.command_buffer, tess.numIndexes, 1, 0, 0, 0); + vkCmdDrawIndexed(vk.command_buffer, tess.numIndexes, 1, 0, 0, 0); tess_vertex_buffer_offset += tess.numVertexes * sizeof(Vk_Vertex2); tess_index_buffer_offset += tess.numIndexes * sizeof(uint32_t); diff --git a/src/engine/renderer/vk_utils.cpp b/src/engine/renderer/vk_utils.cpp index 382a3dc..e9f11d9 100644 --- a/src/engine/renderer/vk_utils.cpp +++ b/src/engine/renderer/vk_utils.cpp @@ -30,12 +30,12 @@ Shader_Module::Shader_Module(uint8_t bytes[], int size) { desc.codeSize = data.size(); desc.pCode = reinterpret_cast(data.data()); - VkResult result = vkCreateShaderModule(vk_instance.device, &desc, nullptr, &handle); + VkResult result = vkCreateShaderModule(vk.device, &desc, nullptr, &handle); check_vk_result(result, "vkCreateShaderModule"); } Shader_Module::~Shader_Module() { - vkDestroyShaderModule(vk_instance.device, handle, nullptr); + vkDestroyShaderModule(vk.device, handle, nullptr); } void record_and_run_commands(VkCommandPool command_pool, VkQueue queue, std::function recorder) { @@ -48,7 +48,7 @@ void record_and_run_commands(VkCommandPool command_pool, VkQueue queue, std::fun alloc_info.commandBufferCount = 1; VkCommandBuffer command_buffer; - VkResult result = vkAllocateCommandBuffers(vk_instance.device, &alloc_info, &command_buffer); + VkResult result = vkAllocateCommandBuffers(vk.device, &alloc_info, &command_buffer); check_vk_result(result, "vkAllocateCommandBuffers"); VkCommandBufferBeginInfo begin_info; @@ -78,7 +78,7 @@ void record_and_run_commands(VkCommandPool command_pool, VkQueue queue, std::fun check_vk_result(result, "vkQueueSubmit"); result = vkQueueWaitIdle(queue); check_vk_result(result, "vkQueueWaitIdle"); - vkFreeCommandBuffers(vk_instance.device, command_pool, 1, &command_buffer); + vkFreeCommandBuffers(vk.device, command_pool, 1, &command_buffer); } static bool has_depth_component(VkFormat format) { @@ -162,11 +162,11 @@ VkImage create_texture(int image_width, int image_height, VkFormat format) { desc.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; VkImage image; - VkResult result = vkCreateImage(vk_instance.device, &desc, nullptr, &image); + VkResult result = vkCreateImage(vk.device, &desc, nullptr, &image); check_vk_result(result, "vkCreateImage"); VkDeviceMemory memory = get_allocator()->allocate_memory(image); - result = vkBindImageMemory(vk_instance.device, image, memory, 0); + result = vkBindImageMemory(vk.device, image, memory, 0); check_vk_result(result, "vkBindImageMemory"); return image; } @@ -192,12 +192,12 @@ VkImage create_staging_texture(int image_width, int image_height, VkFormat forma desc.initialLayout = VK_IMAGE_LAYOUT_PREINITIALIZED; VkImage image; - VkResult result = vkCreateImage(vk_instance.device, &desc, nullptr, &image); + VkResult result = vkCreateImage(vk.device, &desc, nullptr, &image); check_vk_result(result, "vkCreateImage"); get_allocator()->get_shared_staging_memory().ensure_allocation_for_object(image); VkDeviceMemory memory = get_allocator()->get_shared_staging_memory().get_handle(); - result = vkBindImageMemory(vk_instance.device, image, memory, 0); + result = vkBindImageMemory(vk.device, image, memory, 0); check_vk_result(result, "vkBindImageMemory"); VkImageSubresource staging_image_subresource; @@ -205,10 +205,10 @@ VkImage create_staging_texture(int image_width, int image_height, VkFormat forma staging_image_subresource.mipLevel = 0; staging_image_subresource.arrayLayer = 0; VkSubresourceLayout staging_image_layout; - vkGetImageSubresourceLayout(vk_instance.device, image, &staging_image_subresource, &staging_image_layout); + vkGetImageSubresourceLayout(vk.device, image, &staging_image_subresource, &staging_image_layout); void* data; - result = vkMapMemory(vk_instance.device, memory, 0, staging_image_layout.size, 0, &data); + result = vkMapMemory(vk.device, memory, 0, staging_image_layout.size, 0, &data); check_vk_result(result, "vkMapMemory"); const int bytes_per_row = image_width * bytes_per_pixel; @@ -220,7 +220,7 @@ VkImage create_staging_texture(int image_width, int image_height, VkFormat forma memcpy(&bytes[i * staging_image_layout.rowPitch], &pixels[i * bytes_per_row], bytes_per_row); } } - vkUnmapMemory(vk_instance.device, memory); + vkUnmapMemory(vk.device, memory); return image; } @@ -245,11 +245,11 @@ VkImage create_depth_attachment_image(int image_width, int image_height, VkForma desc.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; VkImage image; - VkResult result = vkCreateImage(vk_instance.device, &desc, nullptr, &image); + VkResult result = vkCreateImage(vk.device, &desc, nullptr, &image); check_vk_result(result, "vkCreateImage"); VkDeviceMemory memory = get_allocator()->allocate_memory(image); - result = vkBindImageMemory(vk_instance.device, image, memory, 0); + result = vkBindImageMemory(vk.device, image, memory, 0); check_vk_result(result, "vkBindImageMemory"); return image; } @@ -273,7 +273,7 @@ VkImageView create_image_view(VkImage image, VkFormat format, VkImageAspectFlags desc.subresourceRange.layerCount = 1; VkImageView image_view; - VkResult result = vkCreateImageView(vk_instance.device, &desc, nullptr, &image_view); + VkResult result = vkCreateImageView(vk.device, &desc, nullptr, &image_view); check_vk_result(result, "vkCreateImageView"); return image_view; } @@ -292,7 +292,7 @@ VkBuffer create_buffer(VkDeviceSize size, VkBufferUsageFlags usage) { VkBuffer buffer = get_resource_manager()->create_buffer(desc); VkDeviceMemory memory = get_allocator()->allocate_memory(buffer); - VkResult result = vkBindBufferMemory(vk_instance.device, buffer, memory, 0); + VkResult result = vkBindBufferMemory(vk.device, buffer, memory, 0); check_vk_result(result, "vkBindBufferMemory"); return buffer; } @@ -311,7 +311,7 @@ VkBuffer create_permanent_staging_buffer(VkDeviceSize size, VkDeviceMemory& memo VkBuffer buffer = get_resource_manager()->create_buffer(desc); memory = get_allocator()->allocate_staging_memory(buffer); - VkResult result = vkBindBufferMemory(vk_instance.device, buffer, memory, 0); + VkResult result = vkBindBufferMemory(vk.device, buffer, memory, 0); check_vk_result(result, "vkBindBufferMemory"); return buffer; }