Diffuse Component Vertex Shader

Before we can look at the fragment shader code for the diffuse component, we will examine the vertex shader necessary to set up the vertex position and normal. Listing 9-9 contains the code for TransformAmbientDiffuseShader’s vertex shader.

Listing 9-9.  TransformAmbientDiffuseShader's Vertex Shader Source. TransformAmbientDiffuseShader.cpp

m_vertexShaderCode =
       "uniform mat4 u_mModelViewProj;                           
"
       "uniform mat3 u_mModelIT;                                 
"
       "attribute vec4 a_vPosition;                              
"
       "attribute vec3 a_vNormal;                                
"
       "varying   vec3 v_vNormal;                                
"
       "void main(){                                             
"
       "    gl_Position = u_mModelViewProj * a_vPosition;        
"
       "    v_vNormal = normalize(u_mModelIT * a_vNormal);       
"
       "}                                                        
";
 

Our vertex shader is straightforward to read. We have a matrix, u_mModelViewProj, which we use to transform our vertex’s position attribute into normalized device coordinates as usual.

We now also have an attribute for our vertex normal and a varying variable to store the output. Varyings in GLSL are used to interpolate values between the three vertices which make up a triangle. As we are now specifying a normal vector per vertex, we must store each into a varying to be interpolated for each fragment to be shaded.

When we store our normal into v_vNormal, we are also multiplying it by the matrix u_mModelIT. This matrix is responsible for transforming the matrix from the model’s local space into world space. As a normal vector does not require any translation, the matrix itself is only a 3x3 rotation and scaling matrix. Unfortunately, we cannot simply transform normals with the model’s transform matrix directly. Any scaling which could be applied to the model will cause the normal to change direction relative to its surface. Instead, we must transform normals using the inverse transpose of the model’s matrix.

If you recall, a rotation matrix is an orthogonal matrix. This type of matrix is special in that its inverse is also its transpose; therefore, the inverse transpose of the rotation part of the model’s transform will remain unchanged. A scaling matrix is a diagonal matrix, and as such the transpose of a scaling matrix is no different from the standard matrix. The inverse scale elements contain one divided by the original scales, giving us the inverse. Multiplying normals by this inverse transpose of the model matrix allows us to rotate our normals into world space in the same manner as our model but also to preserve the direction of the original normal relative to the surface it represents.

Diffuse Component Fragment Shader

With the vertex shader out of the way, we can look at the fragment shader. We do this in Listing 9-10.

Listing 9-10.  TransformAmbientDiffuseShader's Fragment Shader Source. TransformAmbientDiffuseShader.cpp

m_fragmentShaderCode =
       "precision mediump float;                                        
"
       "varying vec3 v_vNormal;                                         
"
       "                                                                
"
       "uniform vec4 u_vAmbientColor;                                   
"
       "uniform vec4 u_vDiffuseColor;                                   
"
       "uniform vec4 u_vAmbientLight;                                   
"
       "uniform vec4 u_vDiffuseLight;                                   
"
       "uniform vec3 u_vLightDirection;                                 
"
       "                                                                
"
       "const float c_zero = 0.0;                                       
"
       "const float c_one  = 1.0;                                       
"
       "                                                                
"
       "void main(){                                                    
"
       "    gl_FragColor = vec4(c_zero, c_zero, c_zero, c_zero);        
"
       "                                                                
"
       "    float ndotl = dot(u_vLightDirection, v_vNormal);            
"
       "    ndotl = max(ndotl, c_zero);                                 
"
       "    gl_FragColor += ndotl * u_vDiffuseLight * u_vDiffuseColor;  
"
       "                                                                
"
       "    gl_FragColor += u_vAmbientLight * u_vAmbientColor;          
"
       "                                                                
"
       "    gl_FragColor.a = c_one;                                     
"
       "}                                                               
";
 

The fragment shader for the diffuse lighting component begins by declaring the default precision of the floating-point operations for this shader program. Shader precision qualifiers can be a complicated topic when looking into the specific details. For the purposes of this book, it’s sufficient to know that the precision affects the range of values available to a given data type.

There are three precision qualifiers available, lowp, mediump, and highp. For the purposes of a lighting equation, lowp usually does not provide enough precision and highp usually provides more than we require. The increase in precision at each level results in a shader taking longer to execute; therefore, it is important to select a level of precision which is suitable for any given shader. I’ve used mediump here; however, I can’t actually see any difference when changing the setting to lowp.

It’s also worth remembering that some platforms may not support all of the precision qualifiers. The OpenGL ES 2.0 standard states that the minimum required precision qualifier is mediump for fragment shaders and highp for vertex shaders.

Next, we declare the varying which will contain our interpolated normal vector. Remember that the vertex shader will compute a transformed normal for each vertex, and the GPU will use linear interpolation to calculate the normal position at each fragment. Linear interpolation is calculated by using the values 0 and 1 at each extreme. A linear interpolation of halfway between the digits 5 and 10 would look like the following equation.

((10 – 5) * 0.5) + 5 = 7.5

Here we calculate the difference between our two extremes, which in this case is covered by the sum 10 – 5. We then multiply the range by the interpolation factor, which is 0.5 to represent halfway between the extremes. The last step involves adding the first extreme to calculate the point which rests between the first and second points.

We then have our uniform values. The uniforms are variables which are supplied to all instances of the fragment shader from the game code. In our diffuse shader, we are supplying uniforms which represent the ambient and diffuse color of the object’s material, the ambient and diffuse colors of the light, and the direction of the light. We have also specified constants to represent the values 0.0 and 1.0; these are c_zero and c_one, respectively.

Our main method is defined after all of our variables are declared. We begin by initializing gl_FragColor to a vec4 containing c_zero at each element.

The dot method is then used to calculate the dot product of the vectors v_vLightDirection and v_vNormal. We have achieved the technique known as per-pixel lighting by carrying out this calculation in our fragment shader. We would be implementing per-vertex lighting if we had calculated the dot product in our vertex shader. Calculating the lighting equation in the vertex shader is much faster but does not give as nice results. If you were implementing a full game, having key objects lit with a per-fragment shader and other less important objects lit with a per-vertex shader could be one technique used to optimize your game.

The next line in the shader uses max to limit the lowest possible value of the dot product to 0. We then multiply the three elements needed to calculate the diffuse color, ndotl, u_vDiffuseLight, and u_vDiffuseColor.

With our diffuse color component computed, we then add the result of the ambient component. This is calculated in the same way as in Listing 9-4 by multiplying the ambient light vector with the ambient color vector.

Initializing the Shader Using OpenGL ES 2.0

Listing 9-11 contains the Link method needed to acquire the handles to our uniforms and attributes.

Listing 9-11.  TransformAmbientDiffuseShader::Link. TransformAmbientDiffuseShader.cpp

void TransformAmbientDiffuseShader::Link()
{
       Shader::Link();
       m_modelViewProjUniformHandle       = glGetUniformLocation(m_programId, "u_mModelViewProj");
       m_modelITMatrixUniformHandle       = glGetUniformLocation(m_programId, "u_mModelIT");
       m_positionAttributeHandle          = glGetAttribLocation(m_programId,  "a_vPosition");
       m_normalAttributeHandle            = glGetAttribLocation(m_programId,  "a_vNormal");
       m_ambientColorUniformHandle        = glGetUniformLocation(m_programId, "u_vAmbientColor");
       m_diffuseColorUniformHandle        = glGetUniformLocation(m_programId, "u_vDiffuseColor");
       m_ambientLightUniformHandle        = glGetUniformLocation(m_programId, "u_vAmbientLight");
       m_diffuseLightUniformHandle        = glGetUniformLocation(m_programId, "u_vDiffuseLight");
       m_lightDirectionUniformHandle      = glGetUniformLocation(m_programId, "u_vLightDirection");
}
 

Recall from Listing 9-9 that we had to provide the model’s inverse transpose Transform matrix to the vertex shader to transform the vertex normal. Listing 9-12 shows the TransformAmbientDiffuseShader::Setup method, which contains the code to calculate this matrix.

Listing 9-12.  TransformAmbientDiffuseShader::Setup. TransformAmbientDiffuseShader.cpp

void TransformAmbientDiffuseShader::Setup(Renderable& renderable)
{
       Geometry* pGeometry = renderable.GetGeometry();
       if (pGeometry)
       {
              Shader::Setup(renderable);
              Renderer& renderer = Renderer::GetSingleton();
              const Matrix4& viewMatrix = renderer.GetViewMatrix();
              const Matrix4& projectionMatrix = renderer.GetProjectionMatrix();
              const Matrix4& modelMatrix = renderable.GetTransform().GetMatrix();
              Matrix4 modelViewMatrix;
              modelMatrix.Multiply(viewMatrix, modelViewMatrix);
              Matrix4 modelViewProjectionMatrix;
              modelViewMatrix.Multiply(projectionMatrix, modelViewProjectionMatrix);
              glUniformMatrix4fv(
                     m_modelViewProjUniformHandle,
                     1,
                     false,
                     modelViewProjectionMatrix.m_m);
 
              Matrix3 modelIT;
              renderable.GetTransform().GetInverseTransposeMatrix(modelIT);
              glUniformMatrix3fv(m_modelITMatrixUniformHandle, 1, false, modelIT.m_m);
              glVertexAttribPointer(
                     m_positionAttributeHandle,
                     pGeometry->GetNumVertexPositionElements(),
                     GL_FLOAT,
                     GL_FALSE,
                     pGeometry->GetVertexStride(),
                     pGeometry->GetVertexBuffer());
              glEnableVertexAttribArray(m_positionAttributeHandle);
              glVertexAttribPointer(
                     m_normalAttributeHandle,
                     pGeometry->GetNumNormalPositionElements(),
                     GL_FLOAT,
                     GL_FALSE,
                     pGeometry->GetVertexStride(),
                     static_cast<float*>(pGeometry->GetVertexBuffer()) +
                            pGeometry->GetNumVertexPositionElements());
              glEnableVertexAttribArray(m_normalAttributeHandle);
              const Vector4& ambientColor = renderable.GetMaterial()->GetAmbientColor();
              glUniform4f(
                     m_ambientColorUniformHandle,
                     ambientColor.m_x,
                     ambientColor.m_y,
                     ambientColor.m_z,
                     ambientColor.m_w);
 
              const Vector4& diffuseColor = renderable.GetMaterial()->GetDiffuseColor();
              glUniform4f(
                     m_diffuseColorUniformHandle,
                     diffuseColor.m_x,
                     diffuseColor.m_y,
                     diffuseColor.m_z,
                     diffuseColor.m_w);
 
              const Vector4& ambientLightColor = renderer.GetAmbientLightColor();
              glUniform4f(
                     m_ambientLightUniformHandle,
                     ambientLightColor.m_x,
                     ambientLightColor.m_y,
                     ambientLightColor.m_z,
                     ambientLightColor.m_w);
 
              const Vector4& diffuseLightColor = renderer.GetDiffuseLightColor();
              glUniform4f(
                     m_diffuseLightUniformHandle,
                     diffuseLightColor.m_x,
                     diffuseLightColor.m_y,
                     diffuseLightColor.m_z,
                     diffuseLightColor.m_w);
 
              const Vector3& lightDirection = renderer.GetLightDirection();
              glUniform3f(
                     m_lightDirectionUniformHandle,
                     lightDirection.m_x,
                     lightDirection.m_y,
                     lightDirection.m_z);
       }
}


 

We begin this method by obtaining references to the current view matrix , projection matrix , and model matrix . modelMatrix is then multiplied with viewMatrix to obtain modelViewMatrix. modelViewMatrix is then multiplied with projectionMatrix. This gives us modelViewProjection matrix, which is necessary to transform our model’s vertices into the canonical view volume. We use glUniformMatrix4fv to upload this matrix to the GPU to be used with the uniform u_mModelViewProj in our vertex shader.

The next step in the method is to get the inverse transpose of the model’s transform matrix. We do this using Transform::GetInverseTransposeMatrix. The class declaration for Transform was shown in Listing 6-21; we describe the code for GetInverseTransposeMatrix in Listing 9-13.

Listing 9-13.   Transform::GetInverseTransposeMatrix. Transform.cpp

void Transform::GetInverseTransposeMatrix(Matrix4& out) const
{
       float invScale = 1.0f / m_scale;
       out.m_m[0] = m_rotation.m_m[0] * invScale;
       out.m_m[1] = m_rotation.m_m[1];
       out.m_m[2] = m_rotation.m_m[2];
       out.m_m[3] = 0.0f;
       out.m_m[4] = m_rotation.m_m[3];
       out.m_m[5] = m_rotation.m_m[4] * invScale;
       out.m_m[6] = m_rotation.m_m[5];
       out.m_m[7] = 0.0f;
       out.m_m[8] = m_rotation.m_m[6];
       out.m_m[9] = m_rotation.m_m[7];
       out.m_m[10] = m_rotation.m_m[8] * invScale;
       out.m_m[11] = 0.0f;
       out.m_m[12] = -m_translation.m_x;
       out.m_m[13] = -m_translation.m_y;
       out.m_m[14] = -m_translation.m_z;
       out.m_m[15] = 1.0f;
}
 
void Transform::GetInverseTransposeMatrix(Matrix3& out) const
{
       float invScale = 1.0f / m_scale;
       out.m_m[0] = m_rotation.m_m[0] * invScale;
       out.m_m[1] = m_rotation.m_m[1];
       out.m_m[2] = m_rotation.m_m[2];
       out.m_m[3] = m_rotation.m_m[3];
       out.m_m[4] = m_rotation.m_m[4] * invScale;
       out.m_m[5] = m_rotation.m_m[5];
       out.m_m[6] = m_rotation.m_m[6];
       out.m_m[7] = m_rotation.m_m[7];
       out.m_m[8] = m_rotation.m_m[8] * invScale;
}
 

Listing 9-13 contains two versions of the method to obtain the inverse transpose matrix from a Transform. As we already know, the inverse transpose of a rotation matrix is the original matrix, so we copy the rotation matrix in the normal order. The transpose of the scale matrix doesn’t change anything and we can calculate the inverse of the scale components very easily by dividing the scale into 1. Our code in Listing 9-12 is using the version of this method, which obtains a 3x3 matrix, as our normals do not require the translation component to be present.

Our vertex attributes are then set up. The m_positionAttributeHandle is initialized with the proper parameters from the geometry class and is enabled with glEnableVertexAttribArray. We then do the same for the normals. The address of the first normal is calculated by casting the vertex buffer pointer to a float pointer and adding the number of vertex position elements.

The vectors containing the material and light color properties are then initialized using glUniform4f and glUniform3f .

Our code should now be complete, and we will see some diffuse lighting in our game. This is the first time where we can actually see some depth in our scene and be able to tell that we have successfully created a three-dimensional game. Figure 9-3 shows a screenshot of the scene with diffuse lighting enabled.

As is evident from the preceding screenshot, we have set up our diffuse light source to be situated above and to the right of our objects. The light shines most brightly in those areas and becomes darker on the bottom left of the objects. We can also see the spherical shape of the player and AI objects, as well as the depth of our cubes.

The remaining component of the Blinn-Phong lighting model is the specular component. We look at this next.

Specular Component Vertex Shader

The vertex shader for the specular component of the Blinn-Phong model is shown in Listing 9-14.

Listing 9-14.  TransformAmbientDiffuseSpecularShader's Vertex Shader. TransformAmbientDiffuseSpecularShader.cpp

m_vertexShaderCode =
       "uniform mat4 u_mModelViewProj;                                         
"
       "uniform mat3 u_mModelIT;                                               
"
       "attribute vec4 a_vPosition;                                            
"
       "attribute vec3 a_vNormal;                                              
"
       "varying   vec3 v_vNormal;                                              
"
       "void main(){                                                           
"
       "    gl_Position = u_mModelViewProj * a_vPosition;                      
"
       "    v_vNormal = normalize(u_mModelIT * a_vNormal);                     
"
       "}                                                                      
";
 

Hopefully, it comes as no surprise that our vertex shader does not differ from the vertex shader used in TransformAmbientDiffuseShader. We are using Phong shading to calculate our lighting values at a per-pixel level. We’ll move straight on to the fragment shader.

Specular Component Fragment Shader

Our fragment shader will add the next additive component of the Blinn-Phong model, the specular component. We have already looked at the equation for this component, so Listing 9-15 gets straight into the fragment shader source code.

Listing 9-15.  TransformAmbientDiffuseSpecularShader's Fragment Shader. TransformAmbientDiffuseSpecularShader.cpp

m_fragmentShaderCode =
       "precision mediump float;                                               
"
       "varying   vec3 v_vNormal;                                              
"
       "                                                                       
"
       "uniform vec4 u_vAmbientColor;                                          
"
       "uniform vec4 u_vDiffuseColor;                                          
"
       "uniform vec4 u_vSpecularColor;                                         
"
       "uniform float u_fSpecularExponent;                                     
"
       "uniform vec4 u_vAmbientLight;                                          
"
       "uniform vec4 u_vDiffuseLight;                                          
"
       "uniform vec4 u_vSpecularLight;                                         
"
       "uniform vec3 u_vLightDirection;                                        
"
       "uniform vec3 u_vLightHalfVector;                                       
"
       "                                                                       
"
       "const float c_zero = 0.0;                                              
"
       "const float c_one  = 1.0;                                              
"
       "                                                                       
"
       "void main(){                                                           
"
       "    gl_FragColor = vec4(c_zero, c_zero, c_zero, c_zero);               
"
       "                                                                       
"
       "    float ndoth =  dot(u_vLightHalfVector, v_vNormal);                 
"
       "    ndoth = max(ndoth, c_zero);                                        
"
       "    float dotPow = pow(ndoth, u_fSpecularExponent);                    
"
       "    gl_FragColor += dotPow * u_vSpecularColor * u_vSpecularLight;      
"
       "                                                                       
"
       "    float ndotl = dot(u_vLightDirection, v_vNormal);                   
"
       "    ndotl = max(ndotl, c_zero);                                        
"
       "    gl_FragColor += ndotl * u_vDiffuseLight * u_vDiffuseColor;         
"
       "                                                                       
"
       "    gl_FragColor += u_vAmbientLight * u_vAmbientColor;                 
"
       "                                                                       
"
       "    gl_FragColor.a = c_one;                                            
"
       "}                                                                      
";
 

As our new shader contains both the ambient and diffuse components, it retains all of the uniforms necessary for those calculations. Our newly introduced uniforms are u_vSpecularColor, u_fSpecularExponent, u_vSpecularLight, and u_vLightHalfVector.

There are four new lines in the shader which calculate the specular component. The first calculates the dot product between u_vLightHalfVector and v_vNormal. This gives us the angle between the half vector and the fragment’s normal vector. We then take the higher of either the dot product or zero. The result of the previous steps is then raised to the power of the specular component, and finally the dot product raised to the specular exponent is multiplied by the specular material and light colors.

As the equation is an additive process, we add the diffuse component and then the ambient component to get to the final fragment color.

With our shader code complete, the last step is to look at the OpenGL ES 2.0 code we require to put the shader into use.

Initializing TransformAmbientDiffuseSpecularShader

Like all of our shaders, we must override the Link and Setup methods to be able to use this specific shader.

We look at TransformAmbientDiffuseSpecularShader::Link in Listing 9-16.

Listing 9-16.  TransformAmbientDiffuseSpecularShader::Link. TransformAmbientDiffuseSpecularShader.cpp

void TransformAmbientDiffuseSpecularShader::Link()
{
       Shader::Link();
       m_modelViewProjUniformHandle     = glGetUniformLocation(m_programId, "u_mModelViewProj");
       m_modelITMatrixUniformHandle     = glGetUniformLocation(m_programId, "u_mModelIT");
       m_positionAttributeHandle        = glGetAttribLocation(m_programId,  "a_vPosition");
       m_normalAttributeHandle          = glGetAttribLocation(m_programId,  "a_vNormal");
       m_ambientColorUniformHandle      = glGetUniformLocation(m_programId, "u_vAmbientColor");
       m_diffuseColorUniformHandle      = glGetUniformLocation(m_programId, "u_vDiffuseColor");
       m_specularColorUniformHandle     = glGetUniformLocation(m_programId, "u_vSpecularColor");
       m_specularExponentUniformHandle  = glGetUniformLocation(m_programId, "u_fSpecularExponent");
       m_ambientLightUniformHandle      = glGetUniformLocation(m_programId, "u_vAmbientLight");
       m_diffuseLightUniformHandle      = glGetUniformLocation(m_programId, "u_vDiffuseLight");
       m_specularLightUniformHandle     = glGetUniformLocation(m_programId, "u_vSpecularLight");
       m_lightDirectionUniformHandle    = glGetUniformLocation(m_programId, "u_vLightDirection");
       m_lightHalfVectorUniformHandle   = glGetUniformLocation(m_programId, "u_vLightHalfVector");
}
 

In Link, we obtain all of the handles required for setting the uniforms and attributes using the OpenGL ES 2.0 methods glGetUniformLocation and glGetAttribLocation. We put these handles to use in TransformAmbientDiffuseSpecularShader::Setup, shown in Listing 9-17.

Listing 9-17.  Listing 9-17. TransformAmbientDiffuseSpecularShader::Setup. TransformAmbientDiffuseSpecularShader.cpp

void TransformAmbientDiffuseSpecularShader::Setup(Renderable& renderable)
{
       Geometry* pGeometry = renderable.GetGeometry();
       if (pGeometry)
       {
              Shader::Setup(renderable);
              Renderer& renderer = Renderer::GetSingleton();
              const Matrix4& viewMatrix = renderer.GetViewMatrix();
              const Matrix4& projectionMatrix = renderer.GetProjectionMatrix();
              const Matrix4& modelMatrix = renderable.GetTransform().GetMatrix();
              Matrix4 modelViewMatrix;
              modelMatrix.Multiply(viewMatrix, modelViewMatrix);
              Matrix4 modelViewProjectionMatrix;
              modelViewMatrix.Multiply(projectionMatrix, modelViewProjectionMatrix);
              glUniformMatrix4fv(
                     m_modelViewProjUniformHandle,
                     1,
                     false,
                     modelViewProjectionMatrix.m_m);
 
              Matrix3 modelIT;
              renderable.GetTransform().GetInverseTransposeMatrix(modelIT);
              glUniformMatrix3fv(m_modelITMatrixUniformHandle, 1, false, modelIT.m_m);
              glVertexAttribPointer(
                     m_positionAttributeHandle,
                     pGeometry->GetNumVertexPositionElements(),
                     GL_FLOAT,
                     GL_FALSE,
                     pGeometry->GetVertexStride(),
                     pGeometry->GetVertexBuffer());
              glEnableVertexAttribArray(m_positionAttributeHandle);
              glVertexAttribPointer(
                     m_normalAttributeHandle,
                     pGeometry->GetNumNormalPositionElements(),
                     GL_FLOAT,
                     GL_FALSE,
                     pGeometry->GetVertexStride(),
                     static_cast<float*>(pGeometry->GetVertexBuffer()) +
                            pGeometry->GetNumVertexPositionElements());
              glEnableVertexAttribArray(m_normalAttributeHandle);
              const Vector4& ambientColor = renderable.GetMaterial()->GetAmbientColor();
              glUniform4f(
                     m_ambientColorUniformHandle,
                     ambientColor.m_x,
                     ambientColor.m_y,
                     ambientColor.m_z,
                     ambientColor.m_w);
 
              const Vector4& diffuseColor = renderable.GetMaterial()->GetDiffuseColor();
              glUniform4f(
                     m_diffuseColorUniformHandle,
                     diffuseColor.m_x,
                     diffuseColor.m_y,
                     diffuseColor.m_z,
                     diffuseColor.m_w);
 
 const Vector4&specularColor = renderable.GetMaterial()->GetSpecularColor();
 glUniform4f(
 m_specularColorUniformHandle,
 specularColor.m_x,
 specularColor.m_y,
 specularColor.m_z,
 specularColor.m_w);
 
 glUniform1f(
 m_specularExponentUniformHandle,
 renderable.GetMaterial()->GetSpecularExponent());
              const Vector4& ambientLightColor = renderer.GetAmbientLightColor();
              glUniform4f(
                     m_ambientLightUniformHandle,
                     ambientLightColor.m_x,
                     ambientLightColor.m_y,
                     ambientLightColor.m_z,
                     ambientLightColor.m_w);
 
              const Vector4& diffuseLightColor = renderer.GetDiffuseLightColor();
              glUniform4f(
                     m_diffuseLightUniformHandle,
                     diffuseLightColor.m_x,
                     diffuseLightColor.m_y,
                     diffuseLightColor.m_z,
                     diffuseLightColor.m_w);
 
 const Vector4&
specularLightColor = renderer.GetSpecularLightColor();
 glUniform4f(
 m_specularLightUniformHandle,
 specularLightColor.m_x,
 specularLightColor.m_y,
 specularLightColor.m_z,
 specularLightColor.m_w);
 
              const Vector3& lightDirection = renderer.GetLightDirection();
              glUniform3f(
                     m_lightDirectionUniformHandle,
                     lightDirection.m_x,
                     lightDirection.m_y,
                     lightDirection.m_z);
 
 Vector3 lightHalfVector = renderer.GetCameraTransform().GetTranslation();
 lightHalfVector.Subtract(
 Vector3(modelMatrix.m_m[12], modelMatrix.m_m[13], modelMatrix.m_m[14]));
 lightHalfVector.Normalize();
 lightHalfVector.Add(lightDirection);
 lightHalfVector.Normalize();
 glUniform3f(
 m_lightHalfVectorUniformHandle,
 lightHalfVector.m_x,
 lightHalfVector.m_y,
 lightHalfVector.m_z);
       }
}
 

The lines of code which are in bold in the preceding listing are the lines which differ between TransformAmbientDiffuseSpecularShader::Setup and TransformAmbientDiffuseShader::Setup.

The first block is responsible for uploading the specular color and exponent of the object’s material to the GPU. The second identified section uploads the light’s specular color to the GPU.

The last section is responsible for calculating the light’s half vector. We begin by getting the position of the camera object in world space. By subtracting the model’s position, we obtain a vector which points in the direction of the camera from the model. We then turn this into a unit normal by calling the Normalize method. Now we find the vector halfway between the eye vector and the light vector by adding them together. Once we have this vector, we would like to be a unit normal once again, so we call Normalize for a second time. Calculating this vector once for each model is the optimization which Blinn made to the original Phong lighting model.

With the specular component now added to the shader, we can see the results of the complete lighting equation. Figure 9-4 shows a screenshot containing the final result.

Figure 9-5 shows each of the figures from this chapter together.

Starting in the top left corner, we have the unlit scene. The colors are fully saturated and the objects in the scene all look completely flat.

Moving to the top right tile, we see the ambient lit scene. While the first tile shows the scene unlit, in reality it’s fully lit with ambient color. An unlit scene would actually appear completely black. Our ambient scene adds a base layer of light and we can slightly see the green shade of the player object.

The bottom left image shows the scene with some definition to the objects for the first time. This is thanks to the diffuse lighting, which is the first lighting component that takes into account whether a given fragment is pointing toward the light source or away.

The last image shows our scene with the specular component of the lighting equation added. This adds a hint of reflectivity to our objects’ surfaces. Where the diffuse lit objects look like solid objects, they are slightly uninteresting. The specular highlight on the final image manages to make our spheres take a more realistic appearance.

This simple model is more than enough to add lighting to our game. The following sections of this chapter will describe some different options for adding lighting and materials to a game via shaders.

Forward Shading

In forward shading, a single pass is used where all computations to create the final image are carried out. The directional lights which we have implemented in this chapter are examples of lights which fall into the forward shading category.

The major drawback from this approach is that it requires a large amount of computation to calculate the lighting components from multiple light sources for every rendered object. This cost of computation per light source constrains the number of active lights in any given scene, and many games resort to precalculating their lighting and including it in the textures to be applied to the game levels themselves, either by changing the textures used in the levels or by implementing light maps. The benefit, especially on modern mobile graphics hardware, is that a single target rendering surface is used, and therefore there is not a cost associated with switching render targets when running multiple rendering passes.

Other types of lights which are useful in forward shading are point lights and spotlights.

Point Lights

A point light is different from the directional light which we have described in our shaders, in that it has a position in the world. This means that the light can be placed inside the world and light objects from different directions.

A point light affects all objects by calculating the light direction at each vertex by subtracting the vertex’s position from the light position. Doing this creates a spherical shape for the light source.

Point lights are usually also implemented with an attenuation algorithm. The attenuation of a light causes it to have less of an effect on an object the further away from the light that object becomes. Directional lights are used to simulate lights which are infinitely far away, such as a simple sunlight model, so the attenuation factor makes little sense for them.

The addition of the calculation of the light vector and the attenuation factor increases the computational complexity of the vertex shader. If your game is very simple, this type of light may be feasible, but in most games multiple lights of this type are needed to create the desired effects. This usually puts this technique out of the reach of most low-end mobile GPUs for scenes which have some geometric complexity.

Spotlights

Spotlights are another type of light which are even more complex than point lights. Spotlights have a position and a direction. When spotlights are implemented, they resemble the effects of a torch. Spotlights contain an attenuation factor like point lights but they also have a spotlight cutoff parameter.

This cutoff parameter defines the half angle of the cone of the spotlight. This determines how wide the spotlight is. Anything outside of the cone created by the direction and angle will not be lit by the spotlight. Spotlights also have another attenuation factor which determines the brightness of the light from the center of the cone out to the sides. This allows the spotlight to be brighter in the middle and gradually fade toward the edges of the cone.

Point lights and spotlights were the types of lights which were supplied by OpenGL ES 1.0, and their implementation in the traditional manner is known as forward shading. A modern technique for compositing a scene in modern games is known as deferred rendering.

Deferred Rendering

An alternative technique which has been put to use in many games on the Xbox 360 and Playstation 3 is deferred rendering.

Deferred rendering is usually implemented in two passes. The first pass renders into several buffers. The diffuse color of objects is stored in the diffuse color G buffer. This is different from the diffuse color as we implemented it in the Blinn-Phong model. The stored color is simply the single diffuse material color of the object. No ambient light is used in deferred rendering, and any specular lighting is calculated later. Along with the diffuse G buffer, a normal G buffer stores the normal vectors for each fragment, and the z buffer stores the depth of each fragment at each location.

The second pass then renders a geometric shape for each light. The lighting equation is calculated at each location using the light’s information along with the color, normal, and depth read from the buffers written in the first pass.

The benefit of this model is that hundreds of lights can be rendered in a scene, as they are calculated only for pixels in the frame which will actually make it into the final image. The downside is that it can’t handle transparent objects, so you still need a traditional rendering pass for these.

Another advanced topic which can be implemented with shaders is different types of materials. This is done using different lighting equations in the shaders. These equations are known as bidirectional reflectance distribution functions (BRDFs).

Bidirectional Reflectance Distribution Functions

BRDFs are a group of equations which describe methods for calculating reflected vectors. The Blinn-Phong equation which we have implemented in this chapter is just one example of this set of equations.

The Blinn-Phong model is very good for approximating materials which have a look similar to plastic. Fixed-function graphics pipelines such as those found in OpenGL ES 1.0 have exposed only this model to game developers, but with OpenGL ES 2.0 programmers are free to implement more types of BRDFs thanks to shaders.

Entire books have been written on the subject of lighting in computer graphics, and if you are interested in learning more about BRDFs, the major models to begin with are the Torrance-Sparrow model, the Oren-Nayer diffuse reflection model, and Ward’s reflection model.

These different lighting equations are better suited to recreating the look of different materials such as metals, paper, velvet, sand, and wood.