Bindless textures in HLSL for Vulkan and Metal

cbuffer Frame : register(b0) { float4x4 ViewProjection; };
Texture2D<float4> Textures[] : register(t0, space1);   // every texture the scene uses
SamplerState Linear : register(s1);
 
struct VSIn { float3 Position : POSITION; float2 Uv : TEXCOORD0; uint Material : MATERIAL; };
struct VSOut { float4 Position : SV_Position; float2 Uv : TEXCOORD0; nointerpolation uint Material : MATERIAL; };
 
[shader("vertex")]
VSOut VSMain(VSIn i)
{
    VSOut o;
    o.Position = mul(ViewProjection, float4(i.Position, 1));
    o.Uv = i.Uv;
    o.Material = i.Material;
    return o;
}
 
[shader("pixel")]
float4 PSMain(VSOut i) : SV_Target
{
    // The index differs between pixels of one draw, so mark it non-uniform.
    return Textures[NonUniformResourceIndex(i.Material)].Sample(Linear, i.Uv);
}

using OneShader.Layouts;
using OneShader.Layouts.Metal;
using OneShader.Layouts.Vulkan;
using Bindless.Shaders;
 
// The generated binding says the array has no fixed size.
Console.WriteLine($"Textures: set {Scene.Bindings.Textures.Set}, binding {Scene.Bindings.Textures.Binding}, " +
                  $"count {Scene.Bindings.Textures.Count}, unbounded {Scene.Bindings.Textures.IsUnbounded}");
 
PipelineLayout pipeline = Scene.Pipeline;
Console.WriteLine($"Device features: {pipeline.RequiredFeatures}");
 
// Vulkan: a partially bound, variable-count binding, capped at 1024 descriptors.
var vulkan = pipeline.ToVulkan(new VulkanLayoutOptions { UnboundedMaxCount = 1024 });
foreach (var set in vulkan.SetLayouts)
    foreach (var b in set.Bindings)
        Console.WriteLine($"set {set.Set} binding {b.Binding}: {b.Name}, {b.DescriptorType} x{b.DescriptorCount}, flags {b.BindingFlags}");
foreach (var set in vulkan.SetLayouts)
    if (set.HasVariableCount)
        Console.WriteLine($"set {set.Set} needs VkDescriptorSetVariableDescriptorCountAllocateInfo");
 
// Metal: one argument buffer of 8-byte descriptors.
if (pipeline.TryToMetal(out MetalPipelineLayout? metal, out var metalError))
    foreach (MetalStageLayout stage in metal!.Stages)
        foreach (MetalArgument arg in stage.Arguments)
            Console.WriteLine($"Metal {stage.Stage}: {arg.Name} -> {arg.Kind}({arg.Index})" +
                              (arg.IsArgumentBuffer ? $", argument buffer, {arg.DescriptorStride} bytes per descriptor" : ""));
else
    Console.WriteLine(metalError);
 
// WebGPU has no binding arrays.
if (!pipeline.TryToWebGpu(out _, out var webgpuError))
    Console.WriteLine($"WebGPU: {webgpuError}");

Textures: set 1, binding 0, count 0, unbounded True
Device features: RuntimeDescriptorArray, NonUniformIndexing
set 0 binding 0: Frame, UniformBuffer x1, flags None
set 0 binding 1: Linear, Sampler x1, flags None
set 1 binding 0: Textures, SampledImage x1024, flags PartiallyBound, VariableDescriptorCount
set 1 needs VkDescriptorSetVariableDescriptorCountAllocateInfo
Metal Vertex: Frame -> Buffer(0)
Metal Pixel: Textures -> Buffer(1), argument buffer, 8 bytes per descriptor
Metal Pixel: Linear -> Sampler(0)
WebGPU: 'Textures' is an unbounded resource array; WebGPU has no binding arrays or descriptor indexing, so it cannot be bound. Build the shader for Vulkan or Metal only, or declare the resources separately.

// One 8-byte descriptor of the argument buffer 'Textures'.
struct Textures_entry
{
    texture2d<float, access::sample> v;
};
 
fragment PSMain_out PSMain(
    PSMain_in stage_in [[stage_in]],
    float4 frag_coord [[position]],
    constant Textures_entry* Textures [[buffer(1)]],
    sampler Linear [[sampler(0)]])
...
    float4 v5 = Textures[v4].v.sample(Linear, v1);

/tmp/oneshader-docs/cookbook/Bindless/Shaders/Scene.hlsl(2,19): error OSH5202: The unbounded resource array 'Textures' is not available in WGSL: WebGPU has no binding arrays or descriptor indexing. Declare the elements of 'Textures' as separate resources, use a texture array (Texture2DArray) when the elements are textures of one size, or build this shader for SPIR-V or MSL only.

struct DrawIndices { uint Texture; uint Sampler; };
[[vk::push_constant]] DrawIndices Draw;
 
[shader("pixel")]
float4 PSMain(float4 position : SV_Position, float2 uv : TEXCOORD0) : SV_Target
{
    Texture2D<float4> tex = ResourceDescriptorHeap[Draw.Texture];
    SamplerState s = SamplerDescriptorHeap[Draw.Sampler];
    return tex.Sample(s, uv);
}

oneshader -T ps_6_6 -E PSMain --reflect heap.json Heap.hlsl -Fo heap.spv

"name": "ResourceDescriptorHeap",
"kind": "SampledTexture",
"count": 0,
"unbounded": true,
"heap": "Resource",
"heapKinds": [ "SampledTexture" ],

Misuse.hlsl(4,12): error OSH0336: 'Sample' cannot be called on ResourceDescriptorHeap[...] directly: it has no type until it is assigned. Assign it to a variable of the resource type you want, for example 'Texture2D<float4> t = ResourceDescriptorHeap[i];'.