Alignment of mat3x3 as a uniform?

[ahwatts]

I was trying to pass a model transformation matrix along with a normal transformation matrix (the upper-left 3x3 of the model transformation matrix) as a uniform. The WGSL looks like this:

struct TransformUniform {
    model: mat4x4<f32>,
    normal: mat3x3<f32>,
}

However, mapping that to a Rust structure with #[repr(C)] proved difficult. After some trial & error, it seems like the proper alignment of a mat3x3<f32> is as three vec3<f32>s, with 4 bytes of padding after each one, since a vec3<f32> needs to be aligned on 16-byte boundaries. So my Rust struct winds up looking like this:

#[repr(C)]
#[derive(Clone, Copy, Debug, NoUninit)]
pub struct TransformUniformData {
    model: [[f32; 4]; 4],
    normal_col1: [f32; 3],
    padding1: [u8; 4],
    normal_col2: [f32; 3],
    padding2: [u8; 4],
    normal_col3: [f32; 3],
    padding3: [u8; 4],
 }

This is obviously tedious to update, as I need to split the normal matrix up into three columns and set each one individually:

self.normal_col1 = normal_matrix[0].into();
self.normal_col2 = normal_matrix[1].into();
self.normal_col3 = normal_matrix[2].into();

Is the proper way to do this just to generate the 3x3 in the shader, e.g.:

let normal_matrix = mat3x3<f32>(model[0].xyz, model[1].xyz, model[2].xyz);

I saw that done in a couple of examples. That's also kind of annoying, though perhaps less annoying than manually padding out the 3x3 struct in Rust.

[kpreid]

After some trial & error, it seems like the proper alignment of a mat3x3<f32> is as three vec3<f32>s, with 4 bytes of padding after each one, since a vec3<f32> needs to be aligned on 16-byte boundaries.

That's correct, but also note that you can look up this information authoritatively here: https://www.w3.org/TR/WGSL/#alignment-and-size

So my Rust struct winds up looking like this: ... This is obviously tedious to update,

What I would recommend is that you should define a Rust struct that matches mat3x3<f32>. This way, your TransformUniformData only needs to have two fields, and if you use any more mat3x3s, the work doesn’t have to be repeated.

Also, either with this or without this, you can avoid explicit padding fields by using [[f32; 4]; 3] as your definition, and setting the fourth elements to 0 or whatever. This also makes the update simpler because you can use array map() to add that.

#[derive(Clone, Copy, Debug, bytemuck::NoUninit)]
#[repr(C)]
struct WgslMat3x3F32 {
    data: [[f32; 4]; 3], 
}

impl WgslMat3x3F32 {
    pub fn new(mat: [[f32; 3]; 3]) -> Self {
        Self {
            data: mat.map(|[x, y, z]| [x, y, z, 0.0])
        }
    }
}