RuntimeArray inside struct

[ViniciusGiroto]

I am trying to write a compute shader that receives a struct with an array of objects of size determined at runtime. Something like this:

struct Object {
    // ...
}

struct Result {
    // ...
}

struct Query {
    // ...
    objects: RuntimeArray<Object>
}

#[spirv(compute(threads(64)))]
pub fn main_cs(
    #[spirv(global_invocation_id)] id: UVec3,
    #[spirv(storage_buffer, descriptor_set = 0, binding = 0)] query: &Query,
    #[spirv(storage_buffer, descriptor_set = 0, binding = 1)] result: &mut Result,
) {
    // ...
}

but I am getting the following error:

error: [VUID-StandaloneSpirv-OpTypeRuntimeArray-04680] Vulkan, OpTypeStruct containing an OpTypeRuntimeArray must be decorated with Block or BufferBlock.

are RuntimeArrays the correct type for this case? If so, how can i work with it?

[Firestar99]

The validation is correct, in spirv it is illegal for RuntimeArrays to be part of structs. In fact, it is also illegal to pass them (and images, buffers etc.) into functions, it's just that rust-gpu has "validation passes" to aggressively inline those functions so they never end up in the final spirv.

Note that RuntimeArray is a "primitive" of spirv and you can't just put arbitrary types into it.

/// If you want to read an arbitrary amount of T from a buffer, just use a slice 
#[spirv(storage_buffer, descriptor_set = 0, binding = 0)] many_objects: &[Objects],
/// You use RuntimeArray to get an arbitrary about of [Buffers, Images, Samplers]
/// search for Vulkan descriptor indexing or bindless for more info
#[spirv(storage_buffer, descriptor_set = 0, binding = 0)] many_buffers_with_many_objects RuntimeArray<TypedBuffer<[Objects]>>,

I feel like what you're trying to do doesn't map well to "slot-based" graphics programming. Generally, a shader would declare a certain number of slots (descriptor_set = 0, binding = 0) that you then fill on the CPU with buffers, images or samplers. This means that you can't easily reference a buffer from another struct, you always need to globally declare the kind of buffers you want (in rust-gpu on the entry point instead of a global). If you truely want one buffer to reference another, you can use vulkan descriptor indexing or bindless to emulate that behavior. I have build a library around that, feel free to look at this example and use it, but it's poorly documented: https://github.com/Firestar99/rust-gpu-bindless/blob/main/tests/integration-test-shader/src/simple_compute.rs

[ViniciusGiroto]

Sorry for the late reply. The current implementation of the compute shader is written in WGSL which allows for structs to have a single runtime-sized arrays, as long as it is the last field of the struct.

The shader is structured so that every entry function only uses two slots. One slot for the query parameters, which would be a struct with different fields based on the entry function + a runtime-sized array, and one slot for the result, which also varies by function.

Restructuring the entry functions "parameters" would result in a more complex interface between CPU and GPU, given that, currently, every entry function shares the same interface.

Since I suppose for the long-term it would be better to restructure the code, I will do deeper research on how to do this the "right way".

Thanks for the reply and clarification.

[Firestar99]

Sounds to me you basically want an "unsized struct" in rust terms, or a "buffer reference" in glsl terms, so something like this?

struct MyUnsized {
  my_atomic_field: u32,
  my_slice: [Data],
}

I'm actually not sure if we support that kind of struct, feel free to try if we just accept that as an input in our entry points. Otherwise, I'd point you at our ByteAddressableBuffer which essentially allows you to read and write arbitrary structs at some &[u32] buffer at some arbitrary offset.