GLSL: Implement EXT_descriptor_heap

main.cpp

@@ -694,6 +694,8 @@ struct CLIArguments
 	uint32_t glsl_ovr_multiview_view_count = 0;
 	SmallVector<pair<uint32_t, uint32_t>> glsl_ext_framebuffer_fetch;
 	bool glsl_ext_framebuffer_fetch_noncoherent = false;
+	uint32_t glsl_descriptor_heap_set = UINT32_MAX;
+	uint32_t glsl_descriptor_heap_binding = UINT32_MAX;
 	bool vulkan_glsl_disable_ext_samplerless_texture_functions = false;
 	bool emit_line_directives = false;
 	bool enable_storage_image_qualifier_deduction = true;
@@ -821,6 +823,7 @@ static void print_help_glsl()
 	                "\t\tPrimary use case is supporting external samplers in ESSL for video rendering on Android where you could remap a texture to a YUV one.\n"
 	                "\t[--glsl-force-flattened-io-blocks]:\n\t\tAlways flatten I/O blocks and structs.\n"
 	                "\t[--glsl-ovr-multiview-view-count count]:\n\t\tIn GL_OVR_multiview2, specify layout(num_views).\n"
+	                "\t[--glsl-descriptor-heap-set-binding desc_set binding]:\n\t\tInstead of layout(descriptor_heap), emit layout(set = desc_set, binding = binding) instead for compatibility with mapping API.\n"
 	);
 	// clang-format on
 }
@@ -1458,6 +1461,10 @@ static string compile_iteration(const CLIArguments &args, std::vector<uint32_t>
 	opts.force_recompile_max_debug_iterations = args.force_recompile_max_debug_iterations;
 	compiler->set_common_options(opts);
 
+	// This is enough for Vulkan mapping API.
+	if (args.glsl_descriptor_heap_set != UINT32_MAX)
+		compiler->remap_descriptor_heap(ResourceTypeUnknown, args.glsl_descriptor_heap_set, args.glsl_descriptor_heap_binding);
+
 	for (auto &fetch : args.glsl_ext_framebuffer_fetch)
 		compiler->remap_ext_framebuffer_fetch(fetch.first, fetch.second, !args.glsl_ext_framebuffer_fetch_noncoherent);
 
@@ -1704,6 +1711,11 @@ static int main_inner(int argc, char *argv[])
 	cbs.add("--glsl-ext-framebuffer-fetch-noncoherent", [&args](CLIParser &) {
 		args.glsl_ext_framebuffer_fetch_noncoherent = true;
 	});
+	cbs.add("--glsl-descriptor-heap-set-binding", [&args](CLIParser &parser)
+	{
+		args.glsl_descriptor_heap_set = parser.next_uint();
+		args.glsl_descriptor_heap_binding = parser.next_uint();
+	});
 	cbs.add("--vulkan-glsl-disable-ext-samplerless-texture-functions",
 	        [&args](CLIParser &) { args.vulkan_glsl_disable_ext_samplerless_texture_functions = true; });
 	cbs.add("--disable-storage-image-qualifier-deduction",

reference/shaders-no-opt/asm/comp/nonuniform-bracket-handling.vk.nocompat.asm.comp.vk

@@ -2,6 +2,7 @@
 #extension GL_EXT_buffer_reference2 : require
 #extension GL_EXT_nonuniform_qualifier : require
 #extension GL_KHR_shader_subgroup_ballot : require
+#extension GL_EXT_samplerless_texture_functions : require
 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
 
 layout(set = 0, binding = 0, std430) restrict readonly buffer SSBO_Offsets

reference/shaders-no-opt/asm/comp/temorary-access-terminator.vk.nocompat.asm.comp.vk

@@ -1,5 +1,6 @@
 #version 450
 #extension GL_KHR_shader_subgroup_ballot : require
+#extension GL_EXT_samplerless_texture_functions : require
 layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in;
 
 layout(set = 0, binding = 0) uniform usamplerBuffer _8;

reference/shaders-no-opt/asm/frag/descriptor-heap-hazard-tracking.vk.nocompat.asm.spv16.frag.vk

@@ -0,0 +1,26 @@
+#version 460
+#extension GL_EXT_descriptor_heap : require
+#extension GL_EXT_nonuniform_qualifier : require
+#extension GL_EXT_shader_image_load_formatted : require
+
+layout(location = 0) out float FragColor;
+layout(descriptor_heap, std430) readonly buffer SSBONoWrite
+{
+    vec4 data[];
+} spvSSBONoWrite_9ResourceHeap[];
+
+layout(descriptor_heap, std430) coherent buffer SSBOCoherent
+{
+    vec4 data[];
+} spvSSBOCoherent_10ResourceHeap[];
+
+
+void main()
+{
+    spvSSBOCoherent_10ResourceHeap[2].data[0].z = 0.0;
+    FragColor = spvSSBONoWrite_9ResourceHeap[2].data[2].z;
+    float _34 = spvSSBOCoherent_10ResourceHeap[2].data[0].z;
+    spvSSBOCoherent_10ResourceHeap[2].data[0].z = 0.0;
+    FragColor = _34;
+}
+

reference/shaders-no-opt/asm/frag/descriptor-heap-hlsl-strides.spv16.asm.vk.nocompat.frag.vk

@@ -0,0 +1,31 @@
+#version 460
+#extension GL_EXT_ray_query : require
+#extension GL_EXT_descriptor_heap : require
+#extension GL_EXT_nonuniform_qualifier : require
+#extension GL_EXT_shader_image_load_formatted : require
+#extension GL_EXT_samplerless_texture_functions : require
+
+const bool _56 = (uint(0) > uint(0));
+const int _13 = _56 ? 0 : 0;
+
+layout(location = 0) out vec4 FragColor;
+rayQueryEXT rq;
+layout(descriptor_heap) uniform texture1D spv_23ResourceHeap[];
+layout(descriptor_heap, std140) uniform UBO140
+{
+    float data[2];
+} spvUBO140_42ResourceHeap[];
+
+layout(descriptor_heap) uniform accelerationStructureEXT spv_51ResourceHeap[];
+// WARNING: HLSL style descriptor heap stride is assumed for one or more descriptors. Allowing for compatibility with HLSL shaders.
+// This may be not strictly be compatible with GLSL if sizeof(buffer) != sizeof(image).
+// Application side can convert bindless indices accordingly to compensate or use explicit mapping API to configure strides outside SPIRV-Cross.
+
+void main()
+{
+    FragColor = vec4(0.0);
+    FragColor += texelFetch(spv_23ResourceHeap[int(gl_FragCoord.x)], 0, 0);
+    FragColor += vec4(spvUBO140_42ResourceHeap[50].data[1]);
+    rayQueryInitializeEXT(rq, spv_51ResourceHeap[50], 0u, 0u, vec3(0.0), 0.0, vec3(1.0, 0.0, 0.0), 1.0);
+}
+

reference/shaders-no-opt/asm/frag/descriptor-heap-multi-stage-chain-typed.vk.spv16.asm.nocompat.frag.vk

@@ -0,0 +1,23 @@
+#version 460
+#extension GL_EXT_descriptor_heap : require
+#extension GL_EXT_nonuniform_qualifier : require
+#extension GL_EXT_shader_image_load_formatted : require
+
+layout(location = 0) out float FragColor;
+layout(descriptor_heap, std430) readonly buffer SSBONoWrite
+{
+    vec4 data[];
+} spvSSBONoWrite_9ResourceHeap[];
+
+layout(descriptor_heap, std430) writeonly buffer SSBONoRead
+{
+    vec4 data[];
+} spvSSBONoRead_10ResourceHeap[];
+
+
+void main()
+{
+    spvSSBONoRead_10ResourceHeap[2].data[0].z = spvSSBONoWrite_9ResourceHeap[2].data[2].z;
+    FragColor = spvSSBONoWrite_9ResourceHeap[2].data[2].z;
+}
+

reference/shaders-no-opt/asm/frag/descriptor-heap-multi-stage-chain-untyped.vk.spv16.asm.nocompat.frag.vk

@@ -0,0 +1,23 @@
+#version 460
+#extension GL_EXT_descriptor_heap : require
+#extension GL_EXT_nonuniform_qualifier : require
+#extension GL_EXT_shader_image_load_formatted : require
+
+layout(location = 0) out float FragColor;
+layout(descriptor_heap, std430) readonly buffer SSBONoWrite
+{
+    vec4 data[];
+} spvSSBONoWrite_9ResourceHeap[];
+
+layout(descriptor_heap, std430) writeonly buffer SSBONoRead
+{
+    vec4 data[];
+} spvSSBONoRead_10ResourceHeap[];
+
+
+void main()
+{
+    spvSSBONoRead_10ResourceHeap[2].data[0].z = spvSSBONoWrite_9ResourceHeap[2].data[2].z;
+    FragColor = spvSSBONoWrite_9ResourceHeap[2].data[2].z;
+}
+

reference/shaders-no-opt/asm/frag/descriptor-heap-nonwritable-nonreadable-alias.vk.nocompat.asm.spv16.frag.vk

@@ -0,0 +1,24 @@
+#version 460
+#extension GL_EXT_descriptor_heap : require
+#extension GL_EXT_nonuniform_qualifier : require
+#extension GL_EXT_shader_image_load_formatted : require
+
+layout(location = 0) out vec4 FragColor;
+layout(descriptor_heap, std430) readonly buffer SSBONoWrite
+{
+    vec4 data[];
+} spvSSBONoWrite_9ResourceHeap[];
+
+layout(descriptor_heap, std430) writeonly buffer SSBONoRead
+{
+    vec4 data[];
+} spvSSBONoRead_10ResourceHeap[];
+
+
+void main()
+{
+    FragColor = vec4(0.0);
+    spvSSBONoRead_10ResourceHeap[2].data[0] = spvSSBONoWrite_9ResourceHeap[2].data[2];
+    FragColor = spvSSBONoWrite_9ResourceHeap[2].data[2];
+}
+

reference/shaders-no-opt/asm/frag/descriptor-heap-ssbo-atomic.asm.vk.nocompat.spv16.frag.vk

@@ -0,0 +1,24 @@
+#version 460
+#extension GL_EXT_descriptor_heap : require
+#extension GL_EXT_nonuniform_qualifier : require
+#extension GL_EXT_shader_image_load_formatted : require
+
+layout(descriptor_heap, std430) buffer SSBOAtomic
+{
+    uint data;
+    uint data2;
+} spvSSBOAtomic_32ResourceHeap[];
+
+layout(descriptor_heap, std430) buffer SSBOAtomic_1
+{
+    uint data;
+    uint data2;
+} spvSSBOAtomic_35ResourceHeap[];
+
+void main()
+{
+    int desc_index = int(gl_FragCoord.x);
+    uint _34 = atomicAdd(spvSSBOAtomic_32ResourceHeap[desc_index].data2, 1u);
+    uint _37 = atomicAdd(spvSSBOAtomic_35ResourceHeap[desc_index].data2, 1u);
+}
+

reference/shaders-no-opt/asm/frag/descriptor-heap-ssbo-atomic.heap-legacy-mapping.asm.vk.nocompat.spv16.frag.vk

@@ -0,0 +1,24 @@
+#version 460
+#extension GL_EXT_descriptor_heap : require
+#extension GL_EXT_nonuniform_qualifier : require
+#extension GL_EXT_shader_image_load_formatted : require
+
+layout(set = 1, binding = 2, std430) buffer SSBOAtomic
+{
+    uint data;
+    uint data2;
+} spvSSBOAtomic_32ResourceHeap[];
+
+layout(set = 1, binding = 2, std430) buffer SSBOAtomic_1
+{
+    uint data;
+    uint data2;
+} spvSSBOAtomic_35ResourceHeap[];
+
+void main()
+{
+    int desc_index = int(gl_FragCoord.x);
+    uint _34 = atomicAdd(spvSSBOAtomic_32ResourceHeap[nonuniformEXT(desc_index)].data2, 1u);
+    uint _37 = atomicAdd(spvSSBOAtomic_35ResourceHeap[nonuniformEXT(desc_index)].data2, 1u);
+}
+

reference/shaders-no-opt/asm/frag/descriptor-heap-typed-buffer-pointer.asm.vk.nocompat.spv16.frag.vk

@@ -0,0 +1,18 @@
+#version 460
+#extension GL_EXT_descriptor_heap : require
+#extension GL_EXT_nonuniform_qualifier : require
+#extension GL_EXT_shader_image_load_formatted : require
+
+layout(location = 0) out vec4 FragColor;
+layout(descriptor_heap, std430) buffer SSBO
+{
+    vec4 data[];
+} spvSSBO_23ResourceHeap[];
+
+
+void main()
+{
+    FragColor = vec4(0.0);
+    FragColor = spvSSBO_23ResourceHeap[2].data[2] + vec4(float(int(uint(spvSSBO_23ResourceHeap[2].data.length()))));
+}
+

reference/shaders-no-opt/asm/frag/descriptor-heap-untyped-array-length.asm.vk.nocompat.spv16.frag.vk

@@ -0,0 +1,18 @@
+#version 460
+#extension GL_EXT_descriptor_heap : require
+#extension GL_EXT_nonuniform_qualifier : require
+#extension GL_EXT_shader_image_load_formatted : require
+
+layout(location = 0) out vec4 FragColor;
+layout(descriptor_heap, std430) buffer SSBO
+{
+    vec4 data[];
+} spvSSBO_23ResourceHeap[];
+
+
+void main()
+{
+    FragColor = vec4(0.0);
+    FragColor += vec4(float(int(uint(spvSSBO_23ResourceHeap[2].data.length()))));
+}
+

reference/shaders-no-opt/vulkan/frag/descriptor-heap.heap-legacy-mapping.vk.nocompat.spv16.frag.vk

@@ -0,0 +1,83 @@
+#version 460
+#extension GL_EXT_ray_query : require
+#extension GL_EXT_descriptor_heap : require
+#extension GL_EXT_nonuniform_qualifier : require
+#extension GL_EXT_shader_image_load_formatted : require
+#extension GL_EXT_scalar_block_layout : require
+#extension GL_EXT_samplerless_texture_functions : require
+
+layout(location = 0) out vec4 FragColor;
+rayQueryEXT rq;
+layout(set = 1, binding = 2) uniform texture1D spv_28ResourceHeap[];
+layout(set = 1, binding = 2) uniform texture2D spv_40ResourceHeap[];
+layout(set = 1, binding = 2) uniform texture3D spv_53ResourceHeap[];
+layout(set = 1, binding = 2) uniform sampler spv_75SamplerHeap[];
+layout(set = 1, binding = 2, r32f) uniform image1D spv_114ResourceHeap[];
+layout(set = 1, binding = 2, r32f) uniform image2D spv_123ResourceHeap[];
+layout(set = 1, binding = 2, r32f) uniform image3D spv_132ResourceHeap[];
+layout(set = 1, binding = 2) uniform image2D spv_171ResourceHeap[];
+layout(set = 1, binding = 2, std140) uniform UBO140
+{
+    float data[2];
+} spvUBO140_189ResourceHeap[];
+
+layout(set = 1, binding = 2, std140) uniform UBO430
+{
+    vec3 data[2];
+} spvUBO430_203ResourceHeap[];
+
+layout(set = 1, binding = 2, scalar) uniform UBOScalar
+{
+    vec3 data[2];
+} spvUBOScalar_217ResourceHeap[];
+
+layout(set = 1, binding = 2, std430) readonly buffer SSBOReadOnly
+{
+    vec4 data;
+} spvSSBOReadOnly_232ResourceHeap[];
+
+layout(set = 1, binding = 2, std430) coherent writeonly buffer SSBOWriteOnly
+{
+    vec4 data;
+} spvSSBOWriteOnly_246ResourceHeap[];
+
+layout(set = 1, binding = 2, std430) buffer SSBO
+{
+    vec4 data;
+} spvSSBO_255ResourceHeap[];
+
+layout(set = 1, binding = 2, r32ui) uniform uimage2D spv_263ResourceHeap[];
+layout(set = 1, binding = 2) uniform accelerationStructureEXT spv_278ResourceHeap[];
+
+void main()
+{
+    FragColor = vec4(0.0);
+    int desc_index = int(gl_FragCoord.x);
+    FragColor += texelFetch(spv_28ResourceHeap[nonuniformEXT(desc_index + 0)], 0, 0);
+    FragColor += texelFetch(spv_40ResourceHeap[nonuniformEXT(desc_index + 1)], ivec2(0), 0);
+    FragColor += texelFetch(spv_53ResourceHeap[nonuniformEXT(desc_index + 2)], ivec3(0), 0);
+    FragColor += texture(nonuniformEXT(sampler2D(spv_40ResourceHeap[int(gl_FragCoord.x)], spv_75SamplerHeap[int(gl_FragCoord.y)])), vec2(0.0), 0.0);
+    FragColor += vec4(texture(nonuniformEXT(sampler2DShadow(spv_40ResourceHeap[int(gl_FragCoord.x)], spv_75SamplerHeap[int(gl_FragCoord.y)])), vec3(vec3(0.0).xy, 0.0), 0.0));
+    imageStore(spv_114ResourceHeap[nonuniformEXT(desc_index + 3)], 0, FragColor);
+    imageStore(spv_123ResourceHeap[nonuniformEXT(desc_index + 4)], ivec2(0), FragColor);
+    imageStore(spv_132ResourceHeap[nonuniformEXT(desc_index + 5)], ivec3(0), FragColor);
+    FragColor += imageLoad(spv_114ResourceHeap[nonuniformEXT(desc_index + 6)], 0);
+    FragColor += imageLoad(spv_123ResourceHeap[nonuniformEXT(desc_index + 7)], ivec2(0));
+    FragColor += imageLoad(spv_132ResourceHeap[nonuniformEXT(desc_index + 8)], ivec3(0));
+    FragColor += imageLoad(spv_171ResourceHeap[nonuniformEXT(desc_index + 9)], ivec2(0));
+    int _181 = desc_index + 10;
+    FragColor += vec4(spvUBO140_189ResourceHeap[nonuniformEXT(_181)].data[1]);
+    int _197 = desc_index + 11;
+    FragColor += vec4(spvUBO430_203ResourceHeap[nonuniformEXT(_197)].data[1].x);
+    int _211 = desc_index + 12;
+    FragColor += vec4(spvUBOScalar_217ResourceHeap[nonuniformEXT(_211)].data[1].x);
+    int _225 = desc_index + 13;
+    FragColor += spvSSBOReadOnly_232ResourceHeap[nonuniformEXT(_225)].data;
+    int _239 = desc_index + 14;
+    spvSSBOWriteOnly_246ResourceHeap[nonuniformEXT(_239)].data = vec4(20.0);
+    int _250 = desc_index + 15;
+    FragColor += spvSSBO_255ResourceHeap[nonuniformEXT(_250)].data;
+    uint _271 = imageAtomicAdd(spv_263ResourceHeap[nonuniformEXT(desc_index + 16)], ivec2(0), 50u);
+    rayQueryInitializeEXT(rq, spv_278ResourceHeap[nonuniformEXT(desc_index + 17)], 0u, 0u, vec3(0.0), 0.0, vec3(1.0, 0.0, 0.0), 1.0);
+}
+