CISC/CMPE 454 - Shading in Shaders

We'll consider two kinds of light source to illuminate our surfaces:

A source at infinity emits light from sufficiently far away that the source is in (essentially) the same direction as seen from any point in the scene.
A point source emits light from a particular point, usually in the scene. The direction to a point source is different for each point in the scene. For a point light source at location $\ell$ and a position $p$ on a surface in the scene, the light direction is $\ell - p$.

For sources at infinity, the direction to the source is constant, so the direction can be provided to the shaders as a uniform (i.e. global) variable.

For point sources, the position of the source is constant, to the position can be provided to the shaders as a uniform variable. For point sources, the shaders have to compute the direction to the source.

Coordinate System for Lighting Calculations

Lighting calculations on a fragment involve computing $N \cdot L$ and $R \cdot V$.

All of the vectors have to be in the same coordinate system for these calculations to be meaningful.

The calculations are usually performed in the viewpoint coordinate system (VCS):

Surface normal $N$ has to be moved from the object coordinate system (OCS) into the VCS:
$N_{vcs} = V \; M \; N_{ocs}$
where $M$ is the object-to-world "model transform" and $V$ is the world-to-viewpoint "viewing transform".
For a source at infinity, light direction $L$ has to be provided in the VCS. This can be done in one of two ways:
1. Provide a constant light direction in the world coordinate system (WCS), in which case
  $L_{vcs} = V \; L_{wcs}$
2. Provide a constant light direction in the VCS, in which case nothing needs to be done to it. Since this light direction is fixed in the VCS, it always has the same relation to the viewpoint, even when the viewpoint moves in the world. So this kind of light appears as though attached to the viewer, like headlights on a car.
For a point source in the scene, the viewing direction, $V$, is the direction from the position, $P_{vcs}$ of the fragment in the VCS, to the position of the eye in the VCS. But the position of the eye is $(0,0,0)$ in the VCS, so the shader needs only to be given $P_{vcs}$ of the fragment. Then $V = (0,0,0) - P_{vcs} = - P_{vcs}$.
Lighting calculations are usually done in the fragment shader, so the vertex shader must provide the VCS coordinates of each vertex in its output. The GPU will perform smooth interpolation on those VCS vertex positions to get VCS fragment positions.
Reflection direction $R$ can be computed as $R = 2 \; (N \cdot L) \; N - L$.

Shading on the GPU

Shading requires coordination betweent the code on the CPU side (C++ in our case), the code in the vertex shader, and the code in the fragment shader.

CPU-side code

Since the GPU must use the modelview transform (called $MV$, but actually $V \times M$) the CPU-side code must provide $MV$ as a uniform.

The CPU-side code must also provide the $MVP$ transform, as usual, so that the vertex shader can compute gl_Position, which is the vertex position, but in the clipping coordinate system.

If the lighting direction is fixed in the world, the CPU-side code must also provide the world-to-viewpoint transform, $V$, so that the lighting direction can be moved into the VCS.

Finally, the CPU-side code must provide these constants as uniform variables:

$I_\textrm{in} =$ incoming light intensity
$I_\textrm{A} =$ ambient light intensity
$I_\textrm{E} =$ emissive light intensity
$k_D =$ diffuse reflection coefficient
$k_S =$ specular reflection coefficient
$k_A =$ ambient reflection coefficient
$n =$ specular exponent

Recall that $k_D$, $k_S$, $k_A$, $I_\textrm{E}$, and $n$ are surface properties, so they might be different when rendering different surfaces.

See 03-shaders/shader.cpp in openGL.zip. (But that code is simpler: It does not pass the constant uniforms listed above and it uses a light direction in the VCS.)

Vertex shader code

The vertex shader needs to output to the fragment shader:

gl_Position in the CCS
the vertex normal in the VCS
the vertex position in the VCS (only if doing specular lighting, to compute $V$, or having a point light source, to compute $L$)
any other vertex attributes, like colour

For purely diffuse shading, a vertex shader is

#version 300 es

uniform mat4 MVP;		// OCS-to-CCS
uniform mat4 MV;		// OCS-to-VCS

layout (location = 0) in vec3 vertPosition;
layout (location = 1) in vec3 vertNormal;

flat out mediump vec3 colour;
smooth out mediump vec3 normal;

void main()

{
  // calc vertex position in CCS

  gl_Position = MVP * vec4( vertPosition, 1.0f );

  // assign (r,g,b) colour

  colour = 2.0 * vec3( 0.33, 0.42, 0.18 );

  // calc normal in VCS
  //
  // To do this, apply the non-translational parts of MV to the model
  // normal.  The 0.0 as the fourth component of the normal ensures
  // that no translational component is added.

  normal = vec3( MV * vec4( vertNormal, 0.0 ) );
}

See 03-shaders/*.vert in openGL.zip for more examples.

Fragment shader code

The fragment shader does the actual calculation. In the case of purely diffuse shading, a vertex shader is

#version 300 es

uniform mediump vec3 lightDir; // direction *toward* light in VCS

flat in mediump vec3 colour;
smooth in mediump vec3 normal;

out mediump vec4 outputColour;

void main()

{
  mediump float NdotL = dot( normalize(normal), lightDir );

  if (NdotL < 0.0)  // For light behind the surface, there is no illumination
    NdotL = 0.0;

  mediump vec3 diffuseColour = NdotL * colour;

  outputColour = vec4( diffuseColour, 1.0 );
}

See 03-shaders/*.frag in openGL.zip for more examples.

Shading in Shaders

Light Sources

Coordinate System for Lighting Calculations

Shading on the GPU

CPU-side code

Vertex shader code

Fragment shader code