Calculating surface normals of dynamic mesh (without geometry shader)

Question

I have a mesh whose vertex positions are generated dynamically by the vertex shader. I've been using https://www.khronos.org/opengl/wiki/Calculating_a_Surface_Normal to calculate the surface normal for each primitive in the geometry shader, which seems to work fine.

Unfortunately, I'm planning on switching to an environment where using a geometry shader is not possible. I'm looking for alternative ways to calculate surface normals. I've considered:

• Using compute shaders in two passes. One to generate the vertex positions, another (using the generated vertex positions) to calculate the surface normals, and then passing that data into the shader pipeline.
• Using ARB_shader_image_load_store (or related) to write the vertex positions to a texture (in the vertex shader), which can then be read from the fragment shader. The fragment shader should be able to safely access the vertex positions (since it will only ever access the vertices used to invoke the fragment), and can then calculate the surface normal per fragment.

I believe both of these methods should work, but I'm wondering if there is a less complicated way of doing this, especially considering that this seems like a fairly common task. I'm also wondering if there are any problems with either of the ideas I've proposed, as I've had little experience with both compute shaders and image_load_store.

Answer 1

See Diffuse light with OpenGL GLSL . If you just want the face normals, you can use the partial derivative dFdx , dFdy . Basic fragment shader that calculates the normal vector ( N ) in the same space as the position :

in vec3 position; 

void main()
{
    vec3 dx = dFdx(position);
    vec3 dy = dFdy(position);
    vec3 N = normalize(cross(dx, dy));
    
    // [...]
}