How to read from an dynamically sized storage buffer

[gliderkite]

Hi, I'm currently playing around with wgpu, as my first introduction to 3D computer graphics and GPU programming in general, learning the theory as I go.

My current goal is to be able to write a buffer of transformation matrices so that I can access them in the vertex shader using an index of the array. So far I've followed the learn-gpu tutorial, and I was able to create an uniform buffer for a single matrix used for the camera.

I'm using WGSL for the shader, where if I wanted to keep using a uniform buffer with a fixed number of elements I could write something like:

struct Transform {
    matrix: mat4x4<f32>;
};

[[block]]
struct Transforms {
    transforms: [[stride(64)]] array<Transform, 1>;
};

[[group(1), binding(0)]]
var<uniform> transforms: Transforms;

[[stage(vertex)]]
fn main(...) {
    // access the transform from the buffer at index i
    let t = transforms.transforms[i].matrix;
}

And I create the buffer, layout and bind group with:

let my_buffer = device.create_buffer_init(&util::BufferInitDescriptor {
    label: None,
    contents: bytemuck::cast_slice(buffer),
    usage: BufferUsage::UNIFORM | BufferUsage::COPY_DST,
});

let my_group_layout = device.create_bind_group_layout(&BindGroupLayoutDescriptor {
    entries: &[BindGroupLayoutEntry {
        binding: 0,
        visibility: ShaderStage::VERTEX,
        ty: BindingType::Buffer {
            ty: BufferBindingType::Uniform,
            has_dynamic_offset: false,
            min_binding_size: None,
        },
        count: None,
    }],
    label: None,
});

device.create_bind_group(&BindGroupDescriptor {
    layout: &my_group_layout,
    entries: &[BindGroupEntry {
        binding: 0,
        resource: my_buffer.as_entire_binding(),
    }],
    label: None,
});

I then update the buffer by pushing the new data into the queue:

queue.write_buffer(
    &self.my_buffer,
    0,
    bytemuck::cast_slice(&[my_raw_data]),
);

While this works, I would like to not having to specify a fixed size for the transformation array in the shader, and I seem to understand this is not possible with uniform buffer, but I need to use storage buffers. So I changed the following part of the code:

[[block]]
struct Transforms {
    // dynamically sized now
    transforms: [[stride(64)]] array<Transform>;
};

// uniform -> storage
[[group(1), binding(0)]]
var<storage> transforms: Transforms;

// change buffer usage from UNIFORM to STORAGE
usage: BufferUsage::STORAGE | BufferUsage::COPY_DST,

// change the buffer binding
ty: BufferBindingType::Storage { read_only: true },

The problem is that when I run the code I get Global variable [2] is used incorrectly as READ, full error:

ERROR: ValidationError { source: ContextError { string: "Device::create_shader_module", cause: Validation(EntryPoint { stage: Vertex, name: "main", error: InvalidGlobalUsage([2], READ) }), label_key: "label", label: "Shader" }, description: "Validation Error\n\nCaused by:\n    In Device::create_shader_module\n      note: label = `Shader`\n    Entry point main at Vertex is invalid\n    Global variable [2] is used incorrectly as READ\n" }

So my questions is: how should I structure my code to be able to read from a dynamically sized buffer (note: the same error is raised even if I keep the buffer with a fixed size in the shader)?

[kvark]

Hi! Could you post the whole shader? We recommend looking at the examples, and there is a handy table of features to point you to the right one. Storage buffers are used in shadow and boids examples.
The error message you are getting sounds quite interesting.

[gliderkite]

This is the whole shader, I'm positive it could be further simplified to reproduce the issue:

[[block]]
struct Camera {
    view_proj: mat4x4<f32>;
};

[[group(0), binding(0)]]
var<uniform> camera: Camera;

struct Transform {
    matrix: mat4x4<f32>;
};

[[block]]
struct Transforms {
    transforms: [[stride(64)]] array<Transform>;
};

[[group(1), binding(0)]]
var<storage> transforms: Transforms;

struct VertexInput {
    [[location(0)]] position: vec3<f32>;
    [[location(1)]] color: vec3<f32>;
};

struct InstanceInput {
    [[location(7)]] model_matrix_0: vec4<f32>;
    [[location(8)]] model_matrix_1: vec4<f32>;
    [[location(9)]] model_matrix_2: vec4<f32>;
    [[location(10)]] model_matrix_3: vec4<f32>;
};

struct VertexOutput {
    [[builtin(position)]] clip_position: vec4<f32>;
    [[location(0)]] color: vec3<f32>;
};

[[stage(vertex)]]
fn main(
    model: VertexInput,
    instance: InstanceInput,
) -> VertexOutput {
    let instance_matrix = mat4x4<f32>(
        instance.model_matrix_0,
        instance.model_matrix_1,
        instance.model_matrix_2,
        instance.model_matrix_3,
    );
   
    // reading this variable raises the error!
    let t = transforms.transforms[0].matrix;

    var out: VertexOutput;
    out.clip_position = camera.view_proj * t * instance_matrix * vec4<f32>(model.position, 1.0);
    out.color = model.color;
    return out;
}

[[stage(fragment)]]
fn main(in: VertexOutput) -> [[location(0)]] vec4<f32> {
    return vec4<f32>(in.color, 1.0);
}

However, following #1777 (comment) I updated wgpu to master (instead of using 0.9 in Cargo.toml), and I cannot reproduce the issue anymore as it seems to be working as expected now (that is, I'm able to write into and read from the storage buffer).

[[package]]
name = "wgpu"
version = "0.9.0"
source = "git+https://github.com/gfx-rs/wgpu.git#7798534d428100145f10de1fac4bd35c38737806"

[kvark]

ok, so this is something broken in 0.9 but fixed in master. That's good to know. Are you able to continue with master?

[gliderkite]

Yes, no problem with master for me, thanks.