Accessing data in argument buffers when the first field is [[id(n)]]

It shouldn't matter that they're in separate files. Each buffer parameter to a function has a separate "id space". That is to say if you have two buffer parameters in a function both can have a buffer arguments with an id(0). Likewise if you have a vertex and a fragment shader and both can have a buffer argument with an id(0) and these are independent.

I'm not sure what's going on. Can post you the vertex and fragment shader function headers?

Full shaders here, please see the comment in the second file. Thanks for looking at this! I can post the full single-file repro but it is in rust.)

triangle.vert.metal

Code Block 
#include <metal_stdlib>
#include <simd/simd.h>
using namespace metal;
struct ArgsTransform
{
    float4x4 transform;
};
struct spvDescriptorSetBuffer0
{
    constant ArgsTransform* uniform_buffer [[id(0)]];
};
struct main0_out
{
    float4 position [[position]];
};
struct main0_in
{
    float2 in_pos [[attribute(0)]];
    float3 in_color [[attribute(1)]];
};
vertex main0_out main0(main0_in in [[stage_in]], constant spvDescriptorSetBuffer0& spvDescriptorSet0 [[buffer(0)]])
{
    main0_out out = {};
    out.position = (*spvDescriptorSet0.uniform_buffer).transform * float4(in.in_pos, 0.0, 1.0);
    return out;
}

triangle.frag.metal

Code Block 
#include <metal_stdlib>
#include <simd/simd.h>
using namespace metal;
struct ArgsTransform
{
    float4x4 transform;
};
struct Args
{
    float4 color;
};
struct spvDescriptorSetBuffer0
{
    /*
    If the [[id(0)]] field is commented out, uniform_buffer returns the value
    that was bound to [[id(0)]] instead of [[id(1)]] and the triangle does not
    draw because the color is incorrect (0 alpha)
    */
    /* constant ArgsTransform* transform [[id(0)]]; */
    constant Args* uniform_buffer [[id(1)]];
};
struct main0_out
{
    float4 out_color [[color(0)]];
};
struct main0_in
{
};
fragment main0_out main0(main0_in in [[stage_in]], constant spvDescriptorSetBuffer0& spvDescriptorSet0 [[buffer(0)]])
{
    main0_out out = {};
    out.out_color = spvDescriptorSet0.uniform_buffer->color;
    return out;
}

Excerpts from code

This is in rust, sorry :D.

Code Block 
//
// Setup argument buffer
//
let desc0 = ArgumentDescriptor::new();
desc0.set_data_type(MTLDataType::Pointer);
desc0.set_index(0);
let desc1 = ArgumentDescriptor::new();
desc1.set_data_type(MTLDataType::Pointer);
desc1.set_index(1);
println!("args: {:#?}", [&desc0, &desc1]);
let args = Array::from_slice(&[desc0, desc1]);
let encoder = device.new_argument_encoder(&args);
let argument_buffer = device.new_buffer(encoder.encoded_length(), MTLResourceOptions::empty());
encoder.set_argument_buffer(&argument_buffer, 0);
encoder.set_buffer(0, &transform_buffer, 0);
encoder.set_buffer(1, &color_buffer, 0);

Code Block 
// Bind argument buffer to vertex and fragment shaders
encoder.set_vertex_buffer(0, Some(&argument_buffer), 0);
encoder.set_fragment_buffer(0, Some(&argument_buffer), 0);
encoder.use_resource(&transform_buffer, MTLResourceUsage::Read);
encoder.use_resource(&color_buffer, MTLResourceUsage::Read);
encoder.draw_primitives(MTLPrimitiveType::Triangle, 0, 3);

There are a few things going on here.

Using a MTLArgumentDescriptor to specify types and indices in an argument buffer is a complementary method to using [[id(n)]] to do the same thing. In general, you shouldn't use both.

1. You can specify types and indices using the [[id(n)]] attribute qualifier and create a MTLArgumentEncoder with -[MTLFunction newArgumentEncoderWithBufferIndex:]. This method is more flexible in that it allow you to specify types and indices for complex nested structures. We have a couple of samples showing how to use this method (such as this one)

2. You can use an MTLArgumentDescriptor to create a MTLArgumentEncoder with -[MTLDevice newArgumentEncoderWithArguments:]. This method is more flexible in that it allows you to specify types and indices in your host code (i.e. your Rust code in this case). However, you can only specify types or indices for flat (non-nested) structures this way. Also, this method is more error prone because you can mistakenly specify a type with a the argument descriptor that doesn't match the type as it's used in your shader.

So use one of these methods, not both. (There are rules so that you could to use both, but unless you really need to for some quirk of your apps's architecture, it will only make your code more confusing)

Another problem is that you're trying you use a single argument encoder for multiple arguments. This will only work if both arguments are the same type, but your spvDescriptorSetBuffer0 structures are different types (that happened to be named the same).

So create separate argument encoders for your vertex and fragment shader buffers.

Thanks for the information! I was able to use an option in spirv_cross "--msl-force-active-argument-buffer-resources" to ensure the same type is emitted for the vertex and fragment files. This fixes the case mentioned above.

I think in my case, I'm better off using the second approach. I don't have nested structures in argument buffers because I need to stay compatible with vulkan and other graphics APIs. Additionally the first approach would still require me to pass the "correct" indices when setting the values in functions like MTLArgumentEncoder's setBuffer/setTexture so it still requires me to use reflection data (which I already generate offline).

I'm actually not sure if there is a way to force spirv_cross to omit the [[id(n)]] attributes. So it would be helpful to know if there are rules I need to follow. It seems like the most important thing is to include the same fields in the same order in all shader stages and in the host code. I noticed that even if I use different IDs in the vertex MSL, fragment MSL, and my host application code, as long as the fields are the same order and nothing is omitted, the triangle renders fine. (Not that I would intentionally "ship" like that :D)

Thanks again for answering, it's been very helpful!