GPUVertexStepMode, why isn't there a "triangle" mode.

[shi-yan]

this is a potentially stupid question.

I'm trying to draw a cube with flat shader, for which I need to duplicate vertex positions in the vertex buffer, because of different normals. For example, a vertex at a corner has 3 different normal directions. I hence have to duplicate the vertex to pair with the 3 different normals.

This is a redundancy. What if I can define 2 vertex buffers, one for vertices, one for normals. And the normal buffer's step mode is per triangle? i.e. the normal value will only change when we switching to a new triangle.

right now the step mode supports only "vertex" and "instance", why not a "triangle" mode too? The pipeline has to do rasterization anyway, it must know vertex connectivity?

[greggman]

AFAIK there is no such step mode on the GPU. What would it do if you were using indexed vertices?

If you want to do your own indexing then pass in your vertices as storage buffers and use vertex_index and/or instance_index to help you pull the vertices. There's an example on this page under "using storage buffers for vertex data"

For flat shading you can also possibly use @interpolation(flat), or you can compute normals in the fragment shader based on derivatives.

Here's an example of deriving the normals from derivatives

https://jsgist.org/?src=d052697c0e426c31804714826f25801b

[conorpo]

Alternatively if its just for this cube, you can store normals in there own buffer, than do something normals[vertex_index/6] to pass into the fragment shader. You could also store a u32 on the vertex struct that indexes into the normals buffer.

[shi-yan]

Thank you all! I'm not searching for a solution. I understand webgpu is built on top of vulkan, metal, directx backends. IF they don't support this, it's difficult for webgpu to support it.

I'm mainly curious why gpu doesn't support this mode, given there seem to be enough use-cases. I want to know what the difficulty is?

[greggman]

You should probably go ask the vulkan, metal, directx people why. Maybe ask here

Though Metal doesn't support attributes at all IIRC. You always "pull" the data yourself.

[kainino0x]

Metal does support attributes (though expressed somewhat differently than most APIs IIRC), but they do not implement robustness, so an index buffer index that's out of bounds is unsafe. As a result, we don't use them in Dawn (at least for indexed draw calls, not sure about non-indexed). There's an alternate solution to this problem which is to validate or clamp the index buffer values in an internal compute shader before using them. It could theoretically be faster because vertex pulling is said to be less efficient than fixed-function vertex "pushing".