Are vertex normals not interpolated linearly across faces/edges?

[evan-goode]

I'm not sure whether this question is best targeted at Bevy, WGSL, or even my GPU's driver. Please let me know if should be moved somewhere else.

Using Bevy/bevy_pbr, I would expect vertex normals to be interpolated linearly across faces and edges. Specifically, for vertices A and B with normals $$\hat{\mathbf{n}}_{A}$$ and $$\hat{\mathbf{n}}_B$$, I would expect the interpolated normal halfway between A and B to equal $$\text{normalize}(\hat{\mathbf{n}}_A + \hat{\mathbf{n}}_B)$$. But that does not appear to be true:

In this reproducer [1], the bottom shape is created by subdividing the top shape in half. The normal vector for the middle-top vertex on the bottom shape is created by linearly interpolating between the normal of the top left vertex and the top right vertex. (The same for the middle-bottom vertex).
I use a fragment shader to map the x, y, z components of each fragment's interpolated normal vector to a color. It's subtle, but you can see the normal vectors near the middle-top are different between the top and bottom shapes. The bottom shape overall is slightly "greener" than the top shape.

Is there something wrong with my minimal reproducer, or is Bevy/WGSL/my GPU drivers/my GPU not interpolating the normal vectors linearly? If they are not interpolated linearly, how are they computed?

For context, I am writing a geomorphing [2] shader and I want to create subdivided meshes that render exactly the same as the original meshes.

[1] https://gist.github.com/evan-goode/0d6dba45abf0ee16bbbc97b1a3d21b56
[2] something like https://www.ims.tuwien.ac.at/publications/tuw-138077.pdf

[atlv24]

You need to normalize in the fragment shader, gpu interpolators do not automatically normalize normals, so you're getting non-unit-length normals at the inbetween values

[evan-goode]

Thanks, good idea, but the output still has the same general pattern if I normalize the normal in the fragment shader:

    out.color = vec4((normalize(in.world_normal.xyz) + 1.0) / 2.0, 1.0);

I updated the gist.

[evan-goode]

Oh but I see your point, the values near the interpolated vertices look correct, it's just the others that are now being interpolated between different vertices. Maybe what I want to do is not possible, with this geometry at least.

[atlv24]

what you might want to consider is reparametrizing your normals such that linear interpolation of the parameter yields correctly interpolated unit normal output. the most common way this is done is with normal maps, the parameter being uvs, and the texture being essentially a lookup table. Another way may be to store polar coordinate in vertices, then convert to cartesian with sin/cos in the fragment, which will give you uniform interpolation of angles.

[evan-goode]

Thanks for the suggestions. What I ended up doing is:

1. Using a subdivision scheme such that each new triangle is entirely contained within one of the triangles on the original mesh. (i.e. subdividing a 2-triangle quad into 4 2-triangle quads). I was already doing this, but not in the minimal reproducer I posted.
2. Using non-normalized linearly-interpolated normals for the subdivided vertices in the mesh, then further making sure the vertex shader does not normalize them:

// We have to "un-normalize" the coarse_world_normal since mesh_normal_local_to_world normalizes the result.
let coarse_world_normal = mesh_functions::mesh_normal_local_to_world(
    vertex.coarse_normal,
    vertex_no_morph.instance_index
) * length(vertex.coarse_normal);

I tried spherical coordinates as you mentioned, and that also worked, but in my use case, the trig functions in the fragment shader are not worth it over just using linearly-interpolated normals.