iPad GLSL. From within a fragment shader how do I get the surface - not vertex - normal

Question

Is it possible to access the surface normal - the normal associated with the plane of a fragment - from within a fragment shader? Or perhaps this can be done in the vertex shader?

Is all knowledge of the associated geometry lost when we go down the shader pipeline or is there some clever way of recovering that information in either the vertex of fragment shader?

Thanks in advance.

Cheers,
Doug
twitter: @dugla

Answer 1

The surface normal vector can be calculated approximately by the partial derivative of the view space position in the frgament shader. The partial derivative can be get by the functions dFdx and dFdy. For this is required OpenGL es 3.0 or the OES_standard_derivatives extension:

in vec3 view_position;

void main()
{
    vec3 normalvector = cross(dFdx(view_position), dFdy(view_position));
    nv = normalize(normalvector * sign(normalvector.z));

    .....
}

---

In general it is possible to calculate the normal vector of a surface in a geometry shader (since OpenGL ES 3.2). For example if you draw triangles you get all three points in the geometry shader. Three points define a plane from which the normal vector can be calculated. You just have to be careful if the points are arranged clockwise or counterclockwise.

The normal vector of a triangle is the normalized cross product of 2 vectors defined by the corner points of the triangle. See the folowing example which for counterclockwise triangles:

Vertex shader

#version 400

layout (location = 0) in vec3 inPos;

out vec3 vertPos;

uniform mat4 u_projectionMat44;
uniform mat4 u_modelViewMat44;

void main()
{
    vec4 viewPos = u_modelViewMat44 * vec4( inPos, 1.0 );
    vertPos = viewPos.xyz;
    gl_Position = u_projectionMat44 * viewPos;
}

Geometry shader

#version 400

layout( triangles ) in;
layout( triangle_strip, max_vertices = 3 ) out;

in vec3 vertPos[];

out vec3 geoPos;
out vec3 geoNV;

void main()
{
    vec3 leg1 = vertPos[1] - vertPos[0];
    vec3 leg2 = vertPos[2] - vertPos[0];
    geoNV = normalize( cross( leg1, leg2 ) ); 

    geoPos = vertPos[0];
    EmitVertex();
    geoPos = vertPos[1];
    EmitVertex();
    geoPos = vertPos[2];
    EmitVertex();
    EndPrimitive();
}

Fragment shader

#version 400

in vec3 geoPos;
in vec3 geoNV;

void main()
{
    // ...
}

Of course you can calculate the normalvector also in the tesselation shaders (since OpenGL ES 3.2). But this makes sense only if you already required tessellation shader for other reasons and additionally calculate the normal vector of the face:

Vertex shader

The vertex shader is the same as above.

Tessellation control shader

#version 400

layout( vertices=3 ) out;

in  vec3 vertPos[];
out vec3 tctrlPos[];

void main()
{
    tctrlPos[gl_InvocationID] = vertPos[gl_InvocationID];

    if ( gl_InvocationID == 0 )
    {
        gl_TessLevelOuter[0] =  ;
        gl_TessLevelOuter[1] =  ;
        gl_TessLevelOuter[2] =  ;
        gl_TessLevelInner[0] =  ;
    }
}

Tessellation evaluation shader

#version 400

layout(triangles, ccw) in;

in vec3 tctrlPos[];

out vec3 tevalPos;
out vec3 tevalNV;

void main()
{
  vec3 leg1 = tctrlPos[1] - tctrlPos[0];
  vec3 leg2 = tctrlPos[2] - tctrlPos[0];
  tevalNV = normalize( cross( leg1, leg2 ) ); 

  tevalPos = tctrlPos[0] * gl_TessCoord.x + tctrlPos[1] * gl_TessCoord.y + tctrlPos[2] * gl_TessCoord.z;
}

Fragmant shader

#version 400

in vec3 tevalPos;
in vec3 tevalNV;

void main()
{
    // ...
}

Answer 2

You can get per-pixel normals interpolated from vertex normales by just using a "varying" (in newer OpenGL it is just in/out) variable. But do not forget to normalize this normal! Interpolated normals must not have a length of 1 any longer. These normals also give bad results on sharp edges.

If you want to use custom normals with a higher resolution a commonly used technique are normal maps. You create a texture with baked normals for your object. Then you can access the normal in the fragment texture using a textur look-up.

Answer 3

If you pass the vertex normal through to the fragment shader in a "varying" then you will get an interpolated fragment normal.

EDIT: You will have to calculate the normals in your application, and pass them into your shader as an attribute for each vertex of your triangle.

The usual way to calculate the normal for a triangle is with a cross product.

1. Call the three points making up the triangle P1, P2, and P3.
2. Calculate V1, the vector from P1 to P2.
3. Calculate V2, the vector from P1 to P3.
4. Calculate the cross product of V1 and V2.

This will give you the normal to the plane of the triangle. V2 should be "to the left of" V1, or your normal will point "in" instead of "out". See the Wikipedia article on cross products for details.

FURTHER EDIT: Right, I understand your problem now. Yes, it's true that with shared vertices you can't really have more than one normal per vertex.

The only other thing that I can think of is that maybe a geometry shader could help, because it gets passed all three vertices for a triangle. I don't have any experience with them though.