feat(vulkan): add resource state tracking for Vulkan images

- Introduced a new resource state tracker to manage Vulkan image layouts, reducing redundant pipeline barriers during layout transitions.
- Implemented functions for initializing, shutting down, and managing image layout states, enhancing performance and efficiency in rendering.
- Updated existing Vulkan files to utilize the new resource state tracker, improving synchronization and reducing unnecessary operations.
- Enhanced comments and documentation to clarify the purpose and functionality of the resource state management system.

This commit significantly improves the Vulkan renderer's handling of image states, contributing to better performance and maintainability.

Author: timfox

CMakeLists.txt

@@ -1546,6 +1546,7 @@ SET(RENDERER_VK_SRCS
 	src/renderers/vulkan/vk_flares.c
 	src/renderers/vulkan/vk_utils.c
 	src/renderers/vulkan/vk_commands.c
+	src/renderers/vulkan/vk_resource_state.c
 	src/renderers/vulkan/vk_pipeline.c
 	src/renderers/vulkan/vk_shader_manager.cpp
 	src/renderers/vulkan/vk_shader_validation.c

src/renderers/vulkan/CMakeLists.txt

@@ -10,7 +10,7 @@ if(VK_METRICS_ENABLED)
     endif()
   endif()
 endif()
-target_sources(idtech3_vulkan_x86_64 PRIVATE vk_rtx_acceleration.cpp vk_bindings_direct_final.c vk_sync.c)
+target_sources(idtech3_vulkan_x86_64 PRIVATE vk_rtx_acceleration.cpp vk_bindings_direct_final.c vk_sync.c vk_resource_state.c)
 # Always include lightweight Vulkan command-buffer stubs to ease testing
 option(VK_METRICS_ENABLED "Enable Vulkan metrics instrumentation" OFF)
 

src/renderers/vulkan/tr_scene.c

@@ -32,13 +32,13 @@ static int			r_firstSceneLitSurf;
 int			r_numdlights;
 static int			r_firstSceneDlight;
 
-static int			r_numentities;
+int			r_numentities;
 static int			r_firstSceneEntity;
 
-static int			r_numpolys;
+int			r_numpolys;
 static int			r_firstScenePoly;
 
-static int			r_numpolyverts;
+int			r_numpolyverts;
 
 // CPU-side particle buffer for RE_AddParticle
 #define MAX_CPU_PARTICLES 1024

src/renderers/vulkan/vk.c

@@ -109,6 +109,7 @@ void *Sys_LoadFunction(void *handle, const char *name) {
 #include "vk_surface_sprites.h"
 #include "vk_world_effects.h"
 #include "vk_frame.h"
+#include "vk_resource_state.h"
 
 #include "vk_post_process.h"
 #ifdef USE_VULKAN_RAY_TRACING
@@ -629,6 +630,7 @@ PFN_vkResetFences								qvkResetFences;
 PFN_vkUnmapMemory								qvkUnmapMemory;
 PFN_vkUpdateDescriptorSets						qvkUpdateDescriptorSets;
 PFN_vkWaitForFences								qvkWaitForFences;
+PFN_vkGetFenceStatus							qvkGetFenceStatus;
 PFN_vkAcquireNextImageKHR						qvkAcquireNextImageKHR;
 PFN_vkCreateSwapchainKHR							qvkCreateSwapchainKHR;
 PFN_vkDestroySwapchainKHR						qvkDestroySwapchainKHR;
@@ -1055,6 +1057,7 @@ void VK_EndImmediateCommands( VkCommandBuffer command_buffer, const char *locati
 
 
 // Optimized layout transition helper using C23 designated initializers
+// Now uses resource state tracker to avoid redundant barriers
 static void record_image_layout_transition( 
 	VkCommandBuffer command_buffer, 
 	VkImage image, 
@@ -1064,101 +1067,26 @@ static void record_image_layout_transition(
 	uint32_t src_stage_override, 
 	uint32_t dst_stage_override )
 {
-	(void)dst_stage_override; // Suppress unused parameter warning
-	
-	// Determine source stage and access mask
-	uint32_t src_stage;
-	VkAccessFlags src_access;
-	
-	switch ( old_layout ) {
-		case VK_IMAGE_LAYOUT_UNDEFINED:
-			src_stage = (src_stage_override != 0) ? src_stage_override : VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
-			src_access = VK_ACCESS_NONE;
-			break;
-		case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
-			src_stage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
-			src_access = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
-			break;
-		case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
-			src_stage = VK_PIPELINE_STAGE_TRANSFER_BIT;
-			src_access = VK_ACCESS_TRANSFER_WRITE_BIT;
-			break;
-		case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
-			src_stage = VK_PIPELINE_STAGE_TRANSFER_BIT;
-			src_access = VK_ACCESS_TRANSFER_READ_BIT;
-			break;
-		case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
-			src_stage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
-			src_access = VK_ACCESS_SHADER_READ_BIT;
-			break;
-		case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR:
-			src_stage = VK_PIPELINE_STAGE_TRANSFER_BIT;
-			src_access = VK_ACCESS_NONE;
-			break;
-		default:
-			ri.Error( ERR_DROP, "unsupported old layout %i", old_layout );
-			src_stage = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
-			src_access = VK_ACCESS_NONE;
-			break;
+	// Use resource state tracker to avoid redundant barriers
+	// If old_layout is UNDEFINED, try to get actual layout from state tracker
+	VkImageLayout actual_old_layout = old_layout;
+	if (old_layout == VK_IMAGE_LAYOUT_UNDEFINED) {
+		VkImageLayout tracked_layout = vk_resource_state_get_image_layout(image);
+		if (tracked_layout != VK_IMAGE_LAYOUT_UNDEFINED) {
+			actual_old_layout = tracked_layout;
+		}
 	}
-
-	// Determine destination stage and access mask
-	uint32_t dst_stage;
-	VkAccessFlags dst_access;
 
-	switch ( new_layout ) {
-		case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
-			dst_stage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
-			dst_access = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
-			break;
-		case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
-			dst_stage = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
-			dst_access = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
-			break;
-		case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR:
-			dst_stage = VK_PIPELINE_STAGE_TRANSFER_BIT;
-			dst_access = VK_ACCESS_NONE;
-			break;
-		case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
-			dst_stage = VK_PIPELINE_STAGE_TRANSFER_BIT;
-			dst_access = VK_ACCESS_TRANSFER_READ_BIT;
-			break;
-		case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
-			dst_stage = VK_PIPELINE_STAGE_TRANSFER_BIT;
-			dst_access = VK_ACCESS_TRANSFER_WRITE_BIT;
-			break;
-		case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
-			dst_stage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
-			dst_access = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;
-			break;
-		default:
-			ri.Error( ERR_DROP, "unsupported new layout %i", new_layout);
-			dst_stage = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
-			dst_access = VK_ACCESS_NONE;
-			break;
+	// Use state tracker transition (will skip if layout hasn't changed)
+	if (actual_old_layout == VK_IMAGE_LAYOUT_UNDEFINED) {
+		// First use - use automatic transition
+		vk_resource_state_transition_image(command_buffer, image, image_aspect_flags,
+		                                   new_layout, src_stage_override, dst_stage_override);
+	} else {
+		// Known old layout - use explicit transition
+		vk_resource_state_transition_image_explicit(command_buffer, image, image_aspect_flags,
+		                                            actual_old_layout, new_layout, src_stage_override, dst_stage_override);
 	}
-
-	// Use C23 designated initializer for better performance and type safety
-	const VkImageMemoryBarrier barrier = {
-		.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
-		.pNext = NULL,
-		.srcAccessMask = src_access,
-		.dstAccessMask = dst_access,
-		.oldLayout = old_layout,
-		.newLayout = new_layout,
-		.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-		.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-		.image = image,
-		.subresourceRange = {
-			.aspectMask = image_aspect_flags,
-			.baseMipLevel = 0,
-			.levelCount = VK_REMAINING_MIP_LEVELS,
-			.baseArrayLayer = 0,
-			.layerCount = VK_REMAINING_ARRAY_LAYERS
-		}
-	};
-
-	qvkCmdPipelineBarrier( command_buffer, src_stage, dst_stage, 0, 0, NULL, 0, NULL, 1, &barrier );
 }
 
 
@@ -3891,6 +3819,7 @@ static void init_vulkan_library( void )
 	INIT_DEVICE_FUNCTION(vkResetCommandBuffer)
 	INIT_DEVICE_FUNCTION(vkResetDescriptorPool)
 	INIT_DEVICE_FUNCTION(vkResetFences)
+	INIT_DEVICE_FUNCTION(vkGetFenceStatus)
 	INIT_DEVICE_FUNCTION(vkUnmapMemory)
 	INIT_DEVICE_FUNCTION(vkUpdateDescriptorSets)
 	INIT_DEVICE_FUNCTION(vkWaitForFences)
@@ -4462,6 +4391,7 @@ qvkGetPipelineCacheData					= NULL;
 	qvkResetFences								= NULL;
 	qvkResetQueryPool							= NULL;
 	qvkCmdResetQueryPool						= NULL;
+	qvkGetFenceStatus							= NULL;
 	qvkUnmapMemory								= NULL;
 	qvkUpdateDescriptorSets						= NULL;
 	qvkWaitForFences							= NULL;
@@ -4809,6 +4739,9 @@ void vk_initialize( void )
     if (vk.device != (VkDevice)0x20000000) {
         vk_create_sync_primitives();
         ri.Printf(PRINT_ALL, "Vulkan: Sync primitives created\n");
+        
+        // Initialize resource state tracker
+        vk_resource_state_init();
     // Optional: initialize timeline semaphore if available
         #ifdef VK_KHR_TIMELINE_SEMAPHORE
         if (qvkCreateSemaphore) {
@@ -9858,6 +9791,9 @@ void vk_shutdown( refShutdownCode_t code ) {
 				// Shutdown world effects system
 				vk_world_effects_shutdown();
 
+				// Shutdown resource state tracker
+				vk_resource_state_shutdown();
+
 				// Ray tracing and raymarching moved to RTX renderer only
 
 				// Shutdown async compute

src/renderers/vulkan/vk_command_buffers.cpp

@@ -177,22 +177,48 @@ extern "C" VkCommandBuffer vk_begin_command_buffer(void) {
 
     current_command_buffer = command_buffers[0];
 
-    // Wait for previous frame to complete before reusing command buffer
-    // Check device loss during fence wait
-    if (!vk.device_lost) {
-        VkResult fence_result = qvkWaitForFences(vk.device, 1, &command_fence, VK_TRUE, UINT64_MAX);
-        if (fence_result == VK_ERROR_DEVICE_LOST) {
-            vk.device_lost = qtrue;
-            vk_reset_memory_tracking_on_device_lost();
-            ri.Printf(PRINT_ERROR, "Vulkan: Device lost during command buffer fence wait\n");
-            return VK_NULL_HANDLE;
-        } else if (fence_result != VK_SUCCESS) {
-            ri.Printf(PRINT_WARNING, "vk_begin_command_buffer: Fence wait failed: %d\n", fence_result);
+    // Wait for all frame command buffers to complete before reusing immediate command buffer
+    // This prevents conflicts between immediate commands and frame rendering
+    // Use frame-based synchronization to align with the main rendering pipeline
+    if (!vk.device_lost && vk.device != VK_NULL_HANDLE) {
+        // Collect all active frame fences to ensure no frame is still in flight
+        VkFence frame_fences[NUM_COMMAND_BUFFERS];
+        uint32_t fence_count = 0;
+        
+        // Add all valid frame fences
+        for (uint32_t i = 0; i < NUM_COMMAND_BUFFERS; i++) {
+            if (vk.tess[i].rendering_finished_fence != VK_NULL_HANDLE) {
+                frame_fences[fence_count++] = vk.tess[i].rendering_finished_fence;
+            }
         }
 
-        // Reset fence after waiting (must be done before reuse)
-        if (!vk.device_lost) {
-            qvkResetFences(vk.device, 1, &command_fence);
+        // Wait for all frame fences if any exist
+        if (fence_count > 0) {
+            VkResult fence_result = qvkWaitForFences(vk.device, fence_count, frame_fences, VK_TRUE, UINT64_MAX);
+            if (fence_result == VK_ERROR_DEVICE_LOST) {
+                vk.device_lost = qtrue;
+                vk_reset_memory_tracking_on_device_lost();
+                ri.Printf(PRINT_ERROR, "Vulkan: Device lost during command buffer fence wait\n");
+                return VK_NULL_HANDLE;
+            } else if (fence_result != VK_SUCCESS) {
+                ri.Printf(PRINT_WARNING, "vk_begin_command_buffer: Fence wait failed: %d\n", fence_result);
+            }
+        } else {
+            // Fallback to static fence if no frame fences are available (e.g., during initialization)
+            if (command_fence != VK_NULL_HANDLE) {
+                VkResult fence_result = qvkWaitForFences(vk.device, 1, &command_fence, VK_TRUE, UINT64_MAX);
+                if (fence_result == VK_ERROR_DEVICE_LOST) {
+                    vk.device_lost = qtrue;
+                    vk_reset_memory_tracking_on_device_lost();
+                    ri.Printf(PRINT_ERROR, "Vulkan: Device lost during command buffer fence wait\n");
+                    return VK_NULL_HANDLE;
+                } else if (fence_result != VK_SUCCESS) {
+                    ri.Printf(PRINT_WARNING, "vk_begin_command_buffer: Fence wait failed: %d\n", fence_result);
+                } else {
+                    // Reset static fence after waiting (frame fences are managed by frame system)
+                    qvkResetFences(vk.device, 1, &command_fence);
+                }
+            }
         }
     }
 
@@ -208,12 +234,12 @@ extern "C" VkCommandBuffer vk_begin_command_buffer(void) {
     }
 
     // Begin recording
-    // For reusable command buffers, we can omit ONE_TIME_SUBMIT_BIT since we reset before reuse
-    // However, keeping it is safe and indicates the buffer is used once per submission
+    // This is a reusable command buffer - it's reset before reuse
+    // Omit ONE_TIME_SUBMIT_BIT for better performance with reusable buffers
     VkCommandBufferBeginInfo beginInfo = {
         .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
         .pNext = nullptr,
-        .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
+        .flags = 0, // Reusable buffer - no ONE_TIME_SUBMIT_BIT
         .pInheritanceInfo = nullptr
     };
 

src/renderers/vulkan/vk_frame.cpp

@@ -406,10 +406,12 @@ extern "C" void vk_begin_frame(void) {
     vk_update_performance_stats();
 
     // Begin command buffer
+    // Frame command buffers are reusable - they're reset and reused each frame
+    // Omit ONE_TIME_SUBMIT_BIT for better performance with reusable buffers
     VkCommandBufferBeginInfo begin_info = {
         .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
         .pNext = nullptr,
-        .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
+        .flags = 0, // Reusable frame buffer - no ONE_TIME_SUBMIT_BIT
         .pInheritanceInfo = nullptr
     };