Vulkan: support runtime-sized descriptor arrays

The path tracer reaches its materials through a bindless texture array declared
as `layout(set = 1, binding = 0) uniform texture2D bindless_textures[]`, a
runtime-sized descriptor array. The reflection already carried an `unbounded`
flag for such bindings all the way through the shader container, but the Vulkan
driver ignored it, so the descriptor set layout reserved a single descriptor and
every sample returned zero.

Adds the missing driver support:

- Query and enable the descriptor indexing features
  (shaderSampledImageArrayNonUniformIndexing, descriptorBindingPartiallyBound,
  descriptorBindingVariableDescriptorCount, runtimeDescriptorArray), following
  the per-feature struct style already used for buffer device address and the
  memory model rather than switching this driver to a unified
  VkPhysicalDeviceVulkan12Features.
- Reserve a large maximum descriptor count for an unbounded binding in the set
  layout, and mark it partially bound and variable count.
- Pin the real descriptor count with
  VkDescriptorSetVariableDescriptorCountAllocateInfo when the set is allocated.

With this the path tracer renders. Measured on an RTX 4070 Laptop with a scene
of a floor and eight boxes at 640x360, mean image intensity: the albedo debug
view goes from 0.0000 to 0.3312, and the final path traced image from 0.0000 to
0.4860 against 0.5446 for the raster path. Ray traversal, BLAS/TLAS and the
geometry attributes were already correct; only material evaluation was affected,
because textures were the only thing reached through the bindless set.

Verified at one and eight samples per pixel, and with the denoiser off. With a
sky background the path traced and rasterized images cover the frame equally
(99.9% versus 100% of pixels lit). A flat background colour still renders black
under path tracing: the miss shader only handles sky, which is a gap in the
ported renderer rather than in this change.

DLSS is unaffected: frame to frame difference stays at 0.001788 on Vulkan and
0.001795 on D3D12, and reconstruction error against a native reference at 0.042,
matching the values measured before the path tracer was ported.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WgxxgYZUnriDqgepZHiKpY

Author: Critsium-xy

drivers/vulkan/rendering_device_driver_vulkan.cpp

@@ -1041,6 +1041,11 @@ Error RenderingDeviceDriverVulkan::_check_device_capabilities() {
 				vulkan_memory_model_support = device_features_vk_1_2.vulkanMemoryModel;
 				vulkan_memory_model_device_scope_support = device_features_vk_1_2.vulkanMemoryModelDeviceScope;
 			}
+			// Descriptor indexing, required for the raytracing bindless texture array.
+			descriptor_indexing_capabilities.shader_sampled_image_array_non_uniform_indexing = device_features_vk_1_2.shaderSampledImageArrayNonUniformIndexing;
+			descriptor_indexing_capabilities.descriptor_binding_partially_bound = device_features_vk_1_2.descriptorBindingPartiallyBound;
+			descriptor_indexing_capabilities.descriptor_binding_variable_descriptor_count = device_features_vk_1_2.descriptorBindingVariableDescriptorCount;
+			descriptor_indexing_capabilities.runtime_descriptor_array = device_features_vk_1_2.runtimeDescriptorArray;
 		} else {
 			if (enabled_device_extension_names.has(VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME)) {
 				shader_capabilities.shader_float16_is_supported = shader_features.shaderFloat16;
@@ -1371,6 +1376,18 @@ Error RenderingDeviceDriverVulkan::_initialize_device(const LocalVector<VkDevice
 	shader_features.shaderInt8 = shader_capabilities.shader_int8_is_supported;
 	create_info_next = &shader_features;
 
+	// Runtime-sized descriptor arrays, used by the raytracing bindless texture set.
+	VkPhysicalDeviceDescriptorIndexingFeatures descriptor_indexing_features = {};
+	if (descriptor_indexing_capabilities.runtime_descriptor_array) {
+		descriptor_indexing_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
+		descriptor_indexing_features.pNext = create_info_next;
+		descriptor_indexing_features.shaderSampledImageArrayNonUniformIndexing = descriptor_indexing_capabilities.shader_sampled_image_array_non_uniform_indexing;
+		descriptor_indexing_features.descriptorBindingPartiallyBound = descriptor_indexing_capabilities.descriptor_binding_partially_bound;
+		descriptor_indexing_features.descriptorBindingVariableDescriptorCount = descriptor_indexing_capabilities.descriptor_binding_variable_descriptor_count;
+		descriptor_indexing_features.runtimeDescriptorArray = descriptor_indexing_capabilities.runtime_descriptor_array;
+		create_info_next = &descriptor_indexing_features;
+	}
+
 	VkPhysicalDeviceBufferDeviceAddressFeaturesKHR buffer_device_address_features = {};
 	if (buffer_device_address_support) {
 		buffer_device_address_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR;
@@ -4328,6 +4345,10 @@ static VkShaderStageFlagBits RD_STAGE_TO_VK_SHADER_STAGE_BITS[RDD::SHADER_STAGE_
 	VK_SHADER_STAGE_INTERSECTION_BIT_KHR,
 };
 
+// A runtime-sized descriptor array declares no size in the shader, so the set layout
+// reserves this many slots and the real count is pinned when the set is allocated.
+static constexpr uint32_t VK_UNBOUNDED_DESCRIPTOR_COUNT = 128000;
+
 RDD::ShaderID RenderingDeviceDriverVulkan::shader_create_from_container(const Ref<RenderingShaderContainer> &p_shader_container, const Vector<ImmutableSampler> &p_immutable_samplers) {
 	ShaderReflection shader_refl = p_shader_container->get_shader_reflection();
 	ShaderInfo shader_info;
@@ -4374,11 +4395,11 @@ RDD::ShaderID RenderingDeviceDriverVulkan::shader_create_from_container(const Re
 				} break;
 				case UNIFORM_TYPE_SAMPLER_WITH_TEXTURE: {
 					layout_binding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-					layout_binding.descriptorCount = uniform.length;
+					layout_binding.descriptorCount = uniform.unbounded ? VK_UNBOUNDED_DESCRIPTOR_COUNT : uniform.length;
 				} break;
 				case UNIFORM_TYPE_TEXTURE: {
 					layout_binding.descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
-					layout_binding.descriptorCount = uniform.length;
+					layout_binding.descriptorCount = uniform.unbounded ? VK_UNBOUNDED_DESCRIPTOR_COUNT : uniform.length;
 				} break;
 				case UNIFORM_TYPE_IMAGE: {
 					layout_binding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
@@ -4531,11 +4552,37 @@ RDD::ShaderID RenderingDeviceDriverVulkan::shader_create_from_container(const Re
 		placeholder_binding.stageFlags = VK_SHADER_STAGE_ALL;
 
 		for (uint32_t i = 0; i < shader_refl.uniform_sets.size(); i++) {
+			bool has_unbounded = false;
+			for (uint32_t j = 0; j < shader_refl.uniform_sets[i].size(); j++) {
+				if (shader_refl.uniform_sets[i][j].unbounded) {
+					has_unbounded = true;
+					break;
+				}
+			}
+
+			const bool use_binding_flags = has_unbounded && descriptor_indexing_capabilities.descriptor_binding_partially_bound;
+			LocalVector<VkDescriptorBindingFlags> binding_flags;
+			VkDescriptorSetLayoutBindingFlagsCreateInfo binding_flags_info = {};
+			if (use_binding_flags) {
+				binding_flags.resize(vk_set_bindings[i].size());
+				for (uint32_t j = 0; j < binding_flags.size(); j++) {
+					binding_flags[j] = (j < shader_refl.uniform_sets[i].size() && shader_refl.uniform_sets[i][j].unbounded)
+							? (VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT | VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT)
+							: 0;
+				}
+				binding_flags_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO;
+				binding_flags_info.bindingCount = binding_flags.size();
+				binding_flags_info.pBindingFlags = binding_flags.ptr();
+			}
+
 			// Empty ones are fine if they were not used according to spec (binding count will be 0).
 			VkDescriptorSetLayoutCreateInfo layout_create_info = {};
 			layout_create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
 			layout_create_info.bindingCount = vk_set_bindings[i].size();
 			layout_create_info.pBindings = vk_set_bindings[i].ptr();
+			if (use_binding_flags) {
+				layout_create_info.pNext = &binding_flags_info;
+			}
 
 			// ...not so fine on Adreno 5XX.
 			if (adreno_5xx_empty_descriptor_set_layout_workaround && layout_create_info.bindingCount == 0) {
@@ -4767,6 +4814,7 @@ RDD::UniformSetID RenderingDeviceDriverVulkan::uniform_set_create(VectorView<Bou
 	// Immutable samplers will be skipped so we need to track the number of vk_writes used.
 	VkWriteDescriptorSet *vk_writes = ALLOCA_ARRAY(VkWriteDescriptorSet, p_uniforms.size());
 	uint32_t writes_amount = 0;
+	uint32_t variable_descriptor_count = 0;
 	for (uint32_t i = 0; i < p_uniforms.size(); i++) {
 		const BoundUniform &uniform = p_uniforms[i];
 
@@ -4985,6 +5033,10 @@ RDD::UniformSetID RenderingDeviceDriverVulkan::uniform_set_create(VectorView<Bou
 		if (add_write) {
 			vk_writes[writes_amount].dstBinding = uniform.binding;
 			vk_writes[writes_amount].descriptorCount = num_descriptors;
+			if (uniform.variable_count) {
+				ERR_FAIL_COND_V_MSG(variable_descriptor_count > 0, UniformSetID(), "Trying to create a uniform set with multiple variable bindings. Only the last binding can be variable.");
+				variable_descriptor_count = num_descriptors;
+			}
 			writes_amount++;
 		}
 
@@ -5008,6 +5060,16 @@ RDD::UniformSetID RenderingDeviceDriverVulkan::uniform_set_create(VectorView<Bou
 	const ShaderInfo *shader_info = (const ShaderInfo *)p_shader.id;
 	descriptor_set_allocate_info.pSetLayouts = &shader_info->vk_descriptor_set_layouts[p_set_index];
 
+	// A runtime-sized binding reserves a large maximum in the layout; tell Vulkan how
+	// many descriptors this particular set actually holds.
+	VkDescriptorSetVariableDescriptorCountAllocateInfo variable_count_info = {};
+	if (variable_descriptor_count > 0) {
+		variable_count_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO;
+		variable_count_info.descriptorSetCount = 1;
+		variable_count_info.pDescriptorCounts = &variable_descriptor_count;
+		descriptor_set_allocate_info.pNext = &variable_count_info;
+	}
+
 	VkDescriptorSet vk_descriptor_set = VK_NULL_HANDLE;
 	for (KeyValue<VkDescriptorPool, uint32_t> &E : pool_sets_it->value) {
 		if (E.value < max_descriptor_sets_per_pool) {

drivers/vulkan/rendering_device_driver_vulkan.h

@@ -109,6 +109,14 @@ class RenderingDeviceDriverVulkan : public RenderingDeviceDriver {
 		bool validation = false;
 	};
 
+	// Runtime-sized descriptor arrays, needed by the raytracing bindless texture set.
+	struct DescriptorIndexingCapabilities {
+		bool shader_sampled_image_array_non_uniform_indexing = false;
+		bool descriptor_binding_partially_bound = false;
+		bool descriptor_binding_variable_descriptor_count = false;
+		bool runtime_descriptor_array = false;
+	};
+
 	struct DeviceFunctions {
 		PFN_vkCreateSwapchainKHR CreateSwapchainKHR = nullptr;
 		PFN_vkDestroySwapchainKHR DestroySwapchainKHR = nullptr;
@@ -165,6 +173,7 @@ class RenderingDeviceDriverVulkan : public RenderingDeviceDriver {
 	AccelerationStructureCapabilities acceleration_structure_capabilities;
 	bool ray_query_support = false;
 	RaytracingCapabilities raytracing_capabilities;
+	DescriptorIndexingCapabilities descriptor_indexing_capabilities;
 	bool pipeline_cache_control_support = false;
 	bool device_fault_support = false;
 	bool framebuffer_depth_resolve = false;