Vulkan RT: gate extensions on GPU features and enable device feature chain

- Load vkGetPhysicalDeviceFeatures2; require bufferDeviceAddress,
  accelerationStructure, and rayTracingPipeline before enabling RT extensions.
- Chain VkPhysicalDeviceFeatures2 + KHR BDA/AS/ray-tracing feature structs into
  VkDeviceCreateInfo when RT is on (valid device creation with these extensions).
- Avoid duplicate buffer-device-address feature struct in _DEBUG when RT active.
- Log RT status from vk.rtxExtensionsEnabled; update RENDERERS_FUTURE, TODO_TRIAGE,
  CLAUDE.md; remove stale README ray-tracing disclaimer.

Co-authored-by: Tim Fox <timfox@outlook.com>

Author: cursoragent

CLAUDE.md

@@ -28,11 +28,11 @@ This document serves as the **constitutional contract** for the idTech3 engine f
 - ✅ **Performance**: Minimal overhead when disabled
 
 #### Ray Tracing (RTX)
-- 🔶 **Planned**: Vulkan `VK_KHR_ray_tracing_pipeline` scaffolding; extensions probed
+- 🔶 **In progress**: With `USE_VULKAN_RTX=ON`, the Vulkan device enables **KHR buffer device address**, **acceleration structure**, and **ray tracing pipeline** when the GPU reports the required features (not extension names alone).
 - ⏳ **Hardware Support**: NVIDIA RTX / AMD RDNA2+ via Vulkan RT or DXR
 - ⏳ **Quality Levels**: Multiple presets (performance/balanced/quality)
 - ⏳ **Fallback**: Graceful degradation on non-RT hardware
-- ⏳ **Integration**: Hybrid raster + RT (shadows/reflections) or full RT path
+- ⏳ **Integration**: BLAS/TLAS, shader binding table, and hybrid raster + RT frame path
 - See [docs/RENDERERS_FUTURE.md](docs/RENDERERS_FUTURE.md)
 
 #### Modern C/C++ Standards

README.md

@@ -12,8 +12,6 @@ Modern id Tech 3: **Vulkan-first renderer with PBR**, optional OpenGL fallback,
 2. **Tooling** - GPU detection, validation layers, performance HUD, safe mode, CI matrix builds, smoke tests and shader validation in the build.
 3. **Platform** - Linux, Windows, macOS, Android; IPv4/IPv6 networking, modern codecs and asset loaders.
 
-Ray tracing (Vulkan RT) is **scaffolded / in progress** - see `docs/RENDERERS_FUTURE.md` and `CLAUDE.md` for status, not a headline guarantee.
-
 ### Features (by area)
 
 **Rendering**:

docs/RENDERERS_FUTURE.md

@@ -8,7 +8,7 @@ This document outlines the architecture and implementation plan for three render
 |---------|--------|-------|
 | **Vulkan** | ✅ Complete | Primary renderer, ~18k LOC |
 | **OpenGL** | ✅ Complete | Fallback renderer |
-| **Vulkan RTX** | 🔶 Stub only | Ray tracing extensions probed; no pipeline |
+| **Vulkan RTX** | 🔶 Device path | With `USE_VULKAN_RTX=ON`, extensions plus **buffer device address**, **acceleration structure**, and **ray tracing pipeline** features are enabled when the GPU supports them (`vkGetPhysicalDeviceFeatures2` gate). BLAS/TLAS, SBT, and hybrid frame integration remain to be wired. |
 | **Metal** | ❌ Not started | Native Apple Silicon / macOS |
 | **DXR** | ❌ Not started | DirectX 12 + DirectX Raytracing (Windows) |
 
@@ -26,10 +26,10 @@ This document outlines the architecture and implementation plan for three render
 
 ### Implementation Phases
 
-1. **Extension enablement** (`vk_instance.c` / `vk_device.c` device creation)
-   - Add ray tracing extensions to `device_extension_list` when available
-   - Query `VkPhysicalDeviceRayTracingPipelinePropertiesKHR`
-   - Load `vkCreateRayTracingPipelinesKHR`, `vkCmdTraceRaysKHR`, etc.
+1. **Extension + feature enablement** (`vk_instance.c` device creation)
+   - Add ray tracing extensions to `device_extension_list` when available **and** `vkGetPhysicalDeviceFeatures2` reports `bufferDeviceAddress`, `accelerationStructure`, and `rayTracingPipeline`
+   - Chain `VkPhysicalDeviceFeatures2` + `VkPhysicalDeviceBufferDeviceAddressFeaturesKHR` + `VkPhysicalDeviceAccelerationStructureFeaturesKHR` + `VkPhysicalDeviceRayTracingPipelineFeaturesKHR` into `VkDeviceCreateInfo` (required for valid device creation with these extensions)
+   - Next: query `VkPhysicalDeviceRayTracingPipelinePropertiesKHR`, load `vkCreateRayTracingPipelinesKHR`, `vkCmdTraceRaysKHR`, etc.
 
 2. **Acceleration structures**
    - **BLAS**: Build from BSP world geometry + entity models (vertex/index buffers)

docs/TODO_TRIAGE.md

@@ -62,7 +62,7 @@ TODOs/FIXMEs in `src/external/` are from third-party code (duktape, zstd, cjson,
 | r_renderMode 1/2 | tr_init.c | Deferred / alternate-pipeline placeholders (`r_renderMode`); not wired to Vulkan **optional** Forward+ (`r_forwardPlus`). Real deferred still needs G-buffers, etc. Documented in cvar description. |
 | r_hdr 3 64-bit output | `vk_post_process_pipeline.c`, HDR format helpers | Infrastructure in place (vk_hdr64_active, _hdr64 modules, pipeline selection). glslangValidator rejects dvec4/f64vec4 fragment shader outputs. Falls back to RGBA32F. When glslang adds support, compile HDR64 variants and return RGBA64F from get_hdr_format. |
 | Vegetation wind draw | `vk_vegetation_wind.c` + draw path | Compute **dispatch** now runs **after** each `SURF_VEGETATION` tess batch (staging was previously uploaded *after* the misplaced `vk_begin_frame` dispatch, so GPU saw 0 verts). **Vertex shader still does not read** `vegwind_vertex_buffer` - deformed positions are not yet applied on draw. |
-| Vulkan RTX | CMake `USE_VULKAN_RTX`, renderer init | Extensions can be requested when `USE_VULKAN_RTX=ON` and GPU supports them. Pipeline (BLAS/TLAS, shaders) not yet implemented. See `docs/RENDERERS_FUTURE.md`. |
+| Vulkan RTX | CMake `USE_VULKAN_RTX`, `vk_instance.c` | Device creation enables KHR RT extensions when present **and** `vkGetPhysicalDeviceFeatures2` reports buffer-device-address + acceleration-structure + ray-tracing-pipeline features; `VkDeviceCreateInfo` chains the required feature structs. BLAS/TLAS, SBT, and frame integration still TODO. See `docs/RENDERERS_FUTURE.md`. |
 
 ## Subsystem audit log (rolling)
 

src/renderers/vulkan/vk.h

@@ -1144,6 +1144,7 @@ typedef struct {
 	qboolean debugMarkers;
 	qboolean colorWriteMaskDynamic;
 	qboolean meshShaderNV; /* VK_NV_mesh_shader enabled at device create (r_vk_meshShaderNV); no mesh pipelines yet */
+	qboolean rtxExtensionsEnabled; /* USE_VULKAN_RTX: KHR AS + RT pipeline + deferred host ops + buffer device address enabled at device create */
 
 	float maxAnisotropy;
 	float maxLod;

src/renderers/vulkan/vk_init_device.c

@@ -426,10 +426,14 @@ void vk_initialize( void )
 					features.multiViewport ? "yes" : "no" );
 				ri.Printf( PRINT_ALL, "[VK]   Sampler Anisotropy  : %s\n",
 					features.samplerAnisotropy ? "yes" : "no" );
-#ifdef VK_KHR_RAY_TRACING_PIPELINE
-				ri.Printf( PRINT_ALL, "[VK]   Ray Tracing         : available\n" );
+#ifdef USE_VULKAN_RTX
+				if ( vk.rtxExtensionsEnabled ) {
+					ri.Printf( PRINT_ALL, "[VK]   Ray Tracing         : enabled (KHR AS + RT pipeline + buffer device address)\n" );
+				} else {
+					ri.Printf( PRINT_ALL, "[VK]   Ray Tracing         : build on, GPU/extensions unavailable\n" );
+				}
 #else
-				ri.Printf( PRINT_ALL, "[VK]   Ray Tracing         : not available\n" );
+				ri.Printf( PRINT_ALL, "[VK]   Ray Tracing         : not built (enable USE_VULKAN_RTX)\n" );
 #endif
 				ri.Printf( PRINT_ALL, "[VK]   Compute Pipelines   : enabled\n" );
 				ri.Printf( PRINT_ALL, "[VK]   First Person Rendering : enabled (r_firstPersonFov, r_firstPersonScale, r_firstPersonZNear)\n" );

src/renderers/vulkan/vk_instance.c

@@ -188,6 +188,12 @@ static qboolean vk_create_device( VkPhysicalDevice physical_device, int device_i
 	VkPhysicalDevice8BitStorageFeatures storage_8bit_features;
 #endif
 	VkPhysicalDeviceMeshShaderFeaturesNV mesh_shader_features_nv;
+#ifdef USE_VULKAN_RTX
+	VkPhysicalDeviceFeatures2 rtx_device_features2;
+	VkPhysicalDeviceBufferDeviceAddressFeaturesKHR rtx_bda_features;
+	VkPhysicalDeviceAccelerationStructureFeaturesKHR rtx_as_features;
+	VkPhysicalDeviceRayTracingPipelineFeaturesKHR rtx_rtp_features;
+#endif
 
 	ri.Printf( PRINT_ALL, "...selected physical device: %i\n", device_index );
 
@@ -502,13 +508,52 @@ static qboolean vk_create_device( VkPhysicalDevice physical_device, int device_i
 			vk.colorWriteMaskDynamic = qfalse;
 		}
 #ifdef USE_VULKAN_RTX
-		if ( rtxAccelStruct && rtxPipeline && rtxDeferredHostOps && rtxBufferDeviceAddress && memoryRequirements2 ) {
-			device_extension_list[ device_extension_count++ ] = VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME;
-			device_extension_list[ device_extension_count++ ] = "VK_KHR_deferred_host_operations";
-			device_extension_list[ device_extension_count++ ] = VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME;
-			device_extension_list[ device_extension_count++ ] = VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME;
-			ri.Printf( PRINT_ALL, "[VK] Ray tracing extensions enabled (r_rtx available)\n" );
+		{
+			const qboolean rtxExtPresent = rtxAccelStruct && rtxPipeline && rtxDeferredHostOps && rtxBufferDeviceAddress && memoryRequirements2;
+			qboolean rtxGpuCapable = qfalse;
+
+			if ( rtxExtPresent && qvkGetPhysicalDeviceFeatures2 != NULL ) {
+				VkPhysicalDeviceFeatures2 qf2;
+				VkPhysicalDeviceBufferDeviceAddressFeaturesKHR qbda;
+				VkPhysicalDeviceAccelerationStructureFeaturesKHR qas;
+				VkPhysicalDeviceRayTracingPipelineFeaturesKHR qrtp;
+
+				Com_Memset( &qf2, 0, sizeof( qf2 ) );
+				Com_Memset( &qbda, 0, sizeof( qbda ) );
+				Com_Memset( &qas, 0, sizeof( qas ) );
+				Com_Memset( &qrtp, 0, sizeof( qrtp ) );
+				qf2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
+				qf2.pNext = &qbda;
+				qbda.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR;
+				qbda.pNext = &qas;
+				qas.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
+				qas.pNext = &qrtp;
+				qrtp.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
+				qrtp.pNext = NULL;
+				qvkGetPhysicalDeviceFeatures2( physical_device, &qf2 );
+				rtxGpuCapable = ( qbda.bufferDeviceAddress && qas.accelerationStructure && qrtp.rayTracingPipeline ) ? qtrue : qfalse;
+				if ( !rtxGpuCapable ) {
+					ri.Printf( PRINT_DEVELOPER, "[VK] Ray tracing extensions present but required GPU features are off "
+						"(bufferDeviceAddress=%u accelerationStructure=%u rayTracingPipeline=%u); RT disabled\n",
+						(unsigned)qbda.bufferDeviceAddress, (unsigned)qas.accelerationStructure, (unsigned)qrtp.rayTracingPipeline );
+				}
+			} else if ( rtxExtPresent && qvkGetPhysicalDeviceFeatures2 == NULL ) {
+				ri.Printf( PRINT_WARNING, "[VK] Ray tracing extensions present but vkGetPhysicalDeviceFeatures2 is unavailable; RT disabled\n" );
+			}
+
+			if ( rtxExtPresent && rtxGpuCapable ) {
+				device_extension_list[ device_extension_count++ ] = VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME;
+				device_extension_list[ device_extension_count++ ] = VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME;
+				device_extension_list[ device_extension_count++ ] = VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME;
+				device_extension_list[ device_extension_count++ ] = VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME;
+				vk.rtxExtensionsEnabled = qtrue;
+				ri.Printf( PRINT_ALL, "[VK] Ray tracing path: KHR extensions + GPU features enabled (buffer device address, acceleration structure, ray tracing pipeline)\n" );
+			} else {
+				vk.rtxExtensionsEnabled = qfalse;
+			}
 		}
+#else
+		vk.rtxExtensionsEnabled = qfalse;
 #endif
 		if ( nvMeshShader && r_vk_meshShaderNV && r_vk_meshShaderNV->integer &&
 			device_extension_count < ARRAY_LEN( device_extension_list ) ) {
@@ -606,7 +651,11 @@ static qboolean vk_create_device( VkPhysicalDevice physical_device, int device_i
 			pNextPtr = (const void **)&memory_model.pNext;
 		}
 
-		if ( devAddrFeat ) {
+		if ( devAddrFeat
+#ifdef USE_VULKAN_RTX
+			&& !vk.rtxExtensionsEnabled
+#endif
+			) {
 			*pNextPtr = &devaddr_features;
 			devaddr_features.pNext = NULL;
 			devaddr_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
@@ -646,6 +695,39 @@ static qboolean vk_create_device( VkPhysicalDevice physical_device, int device_i
 			device_desc.pNext = &mesh_shader_features_nv;
 		}
 
+#ifdef USE_VULKAN_RTX
+		if ( vk.rtxExtensionsEnabled ) {
+			Com_Memset( &rtx_device_features2, 0, sizeof( rtx_device_features2 ) );
+			Com_Memset( &rtx_bda_features, 0, sizeof( rtx_bda_features ) );
+			Com_Memset( &rtx_as_features, 0, sizeof( rtx_as_features ) );
+			Com_Memset( &rtx_rtp_features, 0, sizeof( rtx_rtp_features ) );
+			Com_Memcpy( &rtx_device_features2.features, &features, sizeof( features ) );
+			rtx_device_features2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
+			rtx_device_features2.pNext = &rtx_bda_features;
+			rtx_bda_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR;
+			rtx_bda_features.pNext = &rtx_as_features;
+			rtx_bda_features.bufferDeviceAddress = VK_TRUE;
+			rtx_bda_features.bufferDeviceAddressCaptureReplay = VK_FALSE;
+			rtx_bda_features.bufferDeviceAddressMultiDevice = VK_FALSE;
+			rtx_as_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
+			rtx_as_features.pNext = &rtx_rtp_features;
+			rtx_as_features.accelerationStructure = VK_TRUE;
+			rtx_as_features.accelerationStructureCaptureReplay = VK_FALSE;
+			rtx_as_features.accelerationStructureIndirectBuild = VK_FALSE;
+			rtx_as_features.accelerationStructureHostCommands = VK_FALSE;
+			rtx_as_features.descriptorBindingAccelerationStructureUpdateAfterBind = VK_FALSE;
+			rtx_rtp_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
+			rtx_rtp_features.pNext = (void *)(uintptr_t)device_desc.pNext;
+			rtx_rtp_features.rayTracingPipeline = VK_TRUE;
+			rtx_rtp_features.rayTracingPipelineShaderGroupHandleCaptureReplay = VK_FALSE;
+			rtx_rtp_features.rayTracingPipelineShaderGroupHandleCaptureReplayMixed = VK_FALSE;
+			rtx_rtp_features.rayTracingPipelineTraceRaysIndirect = VK_FALSE;
+			rtx_rtp_features.rayTraversalPrimitiveCulling = VK_FALSE;
+			device_desc.pNext = &rtx_device_features2;
+			device_desc.pEnabledFeatures = NULL;
+		}
+#endif
+
 		res = qvkCreateDevice( physical_device, &device_desc, NULL, &vk.device );
 		if ( res < 0 ) {
 			ri.Printf( PRINT_ERROR, "vkCreateDevice returned %s\n", vk_result_string( res ) );
@@ -709,6 +791,7 @@ void vk_init_vulkan_library( void )
 		INIT_INSTANCE_FUNCTION( vkEnumeratePhysicalDevices )
 		INIT_INSTANCE_FUNCTION( vkGetDeviceProcAddr )
 		INIT_INSTANCE_FUNCTION( vkGetPhysicalDeviceFeatures )
+		INIT_INSTANCE_FUNCTION_EXT( vkGetPhysicalDeviceFeatures2 )
 		INIT_INSTANCE_FUNCTION( vkGetPhysicalDeviceFormatProperties )
 		INIT_INSTANCE_FUNCTION( vkGetPhysicalDeviceMemoryProperties )
 		INIT_INSTANCE_FUNCTION( vkGetPhysicalDeviceProperties )

src/renderers/vulkan/vk_procs.c

@@ -20,6 +20,7 @@ PFN_vkEnumerateDeviceExtensionProperties			qvkEnumerateDeviceExtensionProperties
 PFN_vkEnumeratePhysicalDevices					qvkEnumeratePhysicalDevices;
 PFN_vkGetDeviceProcAddr							qvkGetDeviceProcAddr;
 PFN_vkGetPhysicalDeviceFeatures					qvkGetPhysicalDeviceFeatures;
+PFN_vkGetPhysicalDeviceFeatures2					qvkGetPhysicalDeviceFeatures2;
 PFN_vkGetPhysicalDeviceFormatProperties			qvkGetPhysicalDeviceFormatProperties;
 PFN_vkGetPhysicalDeviceMemoryProperties			qvkGetPhysicalDeviceMemoryProperties;
 PFN_vkGetPhysicalDeviceProperties				qvkGetPhysicalDeviceProperties;

src/renderers/vulkan/vk_procs.h

@@ -14,6 +14,7 @@ extern PFN_vkEnumerateDeviceExtensionProperties			qvkEnumerateDeviceExtensionPro
 extern PFN_vkEnumeratePhysicalDevices					qvkEnumeratePhysicalDevices;
 extern PFN_vkGetDeviceProcAddr							qvkGetDeviceProcAddr;
 extern PFN_vkGetPhysicalDeviceFeatures					qvkGetPhysicalDeviceFeatures;
+extern PFN_vkGetPhysicalDeviceFeatures2					qvkGetPhysicalDeviceFeatures2;
 extern PFN_vkGetPhysicalDeviceFormatProperties			qvkGetPhysicalDeviceFormatProperties;
 extern PFN_vkGetPhysicalDeviceMemoryProperties			qvkGetPhysicalDeviceMemoryProperties;
 extern PFN_vkGetPhysicalDeviceProperties				qvkGetPhysicalDeviceProperties;