第九章：环境光照

原文链接：

http://www.rastertek.com/gl40tut09.html

Tutorial 9: Ambient Lighting

第九章：环境光照

This tutorial will be an introduction to using ambient lighting in OpenGL 4.0 using GLSL.

本章将介绍使用OpenGL 4.0 GLSL实现环境光照。

I will explain ambient lighting using an example. Imagine you are in a room and the only light source is sunlight which is coming in from a window. The sunlight doesn't directly point at all the surfaces in the room but everything in the room is illuminated to a certain extent due to bouncing light particles. This lighting effect on the surfaces that the sun isn't directly pointing at is called ambient lighting.

我将用一个例子解释环境光照。想象在一个房间里，只有太阳光从窗户照进来。阳光并不直接照射所有的墙面，但房间里所有的物体都被不同程度的照亮了。这种没有被直接照明的光照效果叫做环境光。

Now to simulate ambient lighting we use a very simple equation. We just set each pixel to be the value of the ambient light at the start of the pixel shader. From that point forward all other operations just add their value to the ambient color. This way we ensure everything is at a minimum using the ambient color value.

我们使用一个非常简单的公式来模拟环境光照。我们在像素着色器开始位置设置每个像素的值为环境光颜色。剩下的操作都在环境光的基础上再加其他的值。这种方式可以保证物体至少有环境光的颜色。

Ambient lighting also adds far more realism to a 3D scene. Take for example the following picture that has only diffuse lighting pointing down the positive X axis at a cube:

环境光增加了3D场景的现实感。例如下面这个只有X轴上漫反射光照的盒子：

The image produced doesn't look realistic because ambient light is almost always everywhere giving everything their proper shape even if it is only slightly illuminated. Now if we just add 15% ambient white light to the same scene we get the following image instead:

图像看上去不够真实，因为环境光到处都存在，哪怕是很暗的地方。下面我们添加15%环境白光到相同的物体上得到下面的图像：

This now gives us a more realistic lighting effect that we as humans are used to.

这个图像得到了更加真实的光照效果。

We will now look at the changes to the code to implement ambient lighting. This tutorial is built on the previous tutorials that used diffuse lighting. We will now add the ambient component with just a few changes.

下面我们来修改代码实现环境光照。本章在漫反射光照的教程基础上进行修改。下面来添加漫反射部分。

Light.vs

The vertex shader has stayed the same for this tutorial.

顶点着色器不做任何改动。

////////////////////////////////////////////////////////////////////////////////
// Filename: light.vs
////////////////////////////////////////////////////////////////////////////////
#version 400

/////////////////////
// INPUT VARIABLES //
/////////////////////
in vec3 inputPosition;
in vec2 inputTexCoord;
in vec3 inputNormal;

//////////////////////
// OUTPUT VARIABLES //
//////////////////////
out vec2 texCoord;
out vec3 normal;

///////////////////////
// UNIFORM VARIABLES //
///////////////////////
uniform mat4 worldMatrix;
uniform mat4 viewMatrix;
uniform mat4 projectionMatrix;

////////////////////////////////////////////////////////////////////////////////
// Vertex Shader
////////////////////////////////////////////////////////////////////////////////
void main(void)
{
 // Calculate the position of the vertex against the world, view, and projection matrices.
 gl_Position = worldMatrix * vec4(inputPosition, 1.0f);
 gl_Position = viewMatrix * gl_Position;
 gl_Position = projectionMatrix * gl_Position;

 // Store the texture coordinates for the pixel shader.
 texCoord = inputTexCoord;

 // Calculate the normal vector against the world matrix only.
 normal = mat3(worldMatrix) * inputNormal;

 // Normalize the normal vector.
 normal = normalize(normal);
}

Light.ps

////////////////////////////////////////////////////////////////////////////////
// Filename: light.ps
////////////////////////////////////////////////////////////////////////////////
#version 400

/////////////////////
// INPUT VARIABLES //
/////////////////////
in vec2 texCoord;
in vec3 normal;

//////////////////////
// OUTPUT VARIABLES //
//////////////////////
out vec4 outputColor;

First we add a 4 float ambient light uniform variable so that the ambient light color can be set in this shader by outside classes.

首先添加4个浮点数格式的环境光照一致变了，这样环境光的颜色可以被外部设置。

///////////////////////
// UNIFORM VARIABLES //
///////////////////////
uniform sampler2D shaderTexture;
uniform vec3 lightDirection;
uniform vec4 diffuseLightColor;
uniform vec4 ambientLight;

////////////////////////////////////////////////////////////////////////////////
// Pixel Shader
////////////////////////////////////////////////////////////////////////////////
void main(void)
{
 vec4 textureColor;
 vec4 color;
 vec3 lightDir;
 float lightIntensity;

 // Sample the pixel color from the texture using the sampler at this texture coordinate location.
 textureColor = texture(shaderTexture, texCoord);

We set the output color value to the base ambient color. All pixels will now be illuminated by a minimum of the ambient color value.

先设置输出颜色的值为环境光。所有像素至少都显示为环境光值。

 // Set the default output color to the ambient light value for all pixels.
 color = ambientLight;

 // Invert the light direction for calculations.
 lightDir = -lightDirection;

 // Calculate the amount of light on this pixel.
 lightIntensity = clamp(dot(normal, lightDir), 0.0f, 1.0f);

Check if the N dot L is greater than zero. If it is then add the diffuse color to the ambient color. If not then you need to be careful to not add the diffuse color. The reason being is that the diffuse color could be negative and it will subtract away some of the ambient color in the addition which is not correct.

检查N点乘L的值是否大于0。如果大于0，将漫反射光和环境光叠加。否则就不加漫反射光。如果漫反射光为负值，那么加上环境光后计算出来的结果就会不正确。

 if(lightIntensity > 0.0f)
 {
  // Determine the final diffuse color based on the diffuse color and the amount of light intensity.
  color += (diffuseLightColor * lightIntensity);
 }

Make sure to clamp the final output light color since the combination of ambient and diffuse could have been greater than 1.

确保最后输出的光照颜色在0.0f和1.0f范围内。

 // Clamp the final light color.
 color = clamp(color, 0.0f, 1.0f);

Finally combine the ambient/diffuse light to the texture pixel to produce the final result.

最后融合将环境/漫反射光照和纹理像素融合。

 // Multiply the texture pixel and the final diffuse color to get the final pixel color result.
 outputColor = color * textureColor;
}

Lightshaderclass.h

////////////////////////////////////////////////////////////////////////////////
// Filename: lightshaderclass.h
////////////////////////////////////////////////////////////////////////////////
#ifndef _LIGHTSHADERCLASS_H_
#define _LIGHTSHADERCLASS_H_

//////////////
// INCLUDES //
//////////////
#include <fstream>
using namespace std;

///////////////////////
// MY CLASS INCLUDES //
///////////////////////
#include "openglclass.h"

////////////////////////////////////////////////////////////////////////////////
// Class name: LightShaderClass
////////////////////////////////////////////////////////////////////////////////
class LightShaderClass
{
public:
 LightShaderClass();
 LightShaderClass(const LightShaderClass&);
 ~LightShaderClass();

 bool Initialize(OpenGLClass*, HWND);
 void Shutdown(OpenGLClass*);
 void SetShader(OpenGLClass*);

The SetShaderParameters now takes an extra float array as input for the ambient light value.

SetShaderParameters增加了环境光作为输入参数。

bool SetShaderParameters(OpenGLClass*, float*, float*, float*, int, float*, float*, float*);

private:
 bool InitializeShader(char*, char*, OpenGLClass*, HWND);
 char* LoadShaderSourceFile(char*);
 void OutputShaderErrorMessage(OpenGLClass*, HWND, unsigned int, char*);
 void OutputLinkerErrorMessage(OpenGLClass*, HWND, unsigned int);
 void ShutdownShader(OpenGLClass*);

private:
 unsigned int m_vertexShader;
 unsigned int m_fragmentShader;
 unsigned int m_shaderProgram;
};

#endif

Lightshaderclass.cpp

////////////////////////////////////////////////////////////////////////////////
// Filename: lightshaderclass.cpp
////////////////////////////////////////////////////////////////////////////////
#include "lightshaderclass.h"

LightShaderClass::LightShaderClass()
{
}

LightShaderClass::LightShaderClass(const LightShaderClass& other)
{
}

LightShaderClass::~LightShaderClass()
{
}

bool LightShaderClass::Initialize(OpenGLClass* OpenGL, HWND hwnd)
{
 bool result;

 // Initialize the vertex and pixel shaders.
 result = InitializeShader("../Engine/light.vs", "../Engine/light.ps", OpenGL, hwnd);
 if(!result)
 {
  return false;
 }

 return true;
}

void LightShaderClass::Shutdown(OpenGLClass* OpenGL)
{
 // Shutdown the vertex and pixel shaders as well as the related objects.
 ShutdownShader(OpenGL);

 return;
}

void LightShaderClass::SetShader(OpenGLClass* OpenGL)
{
 // Install the shader program as part of the current rendering state.
 OpenGL->glUseProgram(m_shaderProgram);
 
 return;
}

bool LightShaderClass::InitializeShader(char* vsFilename, char* fsFilename, OpenGLClass* OpenGL, HWND hwnd)
{
 const char* vertexShaderBuffer;
 const char* fragmentShaderBuffer;
 int status;

 // Load the vertex shader source file into a text buffer.
 vertexShaderBuffer = LoadShaderSourceFile(vsFilename);
 if(!vertexShaderBuffer)
 {
  return false;
 }

 // Load the fragment shader source file into a text buffer.
 fragmentShaderBuffer = LoadShaderSourceFile(fsFilename);
 if(!fragmentShaderBuffer)
 {
  return false;
 }

 // Create a vertex and fragment shader object.
 m_vertexShader = OpenGL->glCreateShader(GL_VERTEX_SHADER);
 m_fragmentShader = OpenGL->glCreateShader(GL_FRAGMENT_SHADER);

 // Copy the shader source code strings into the vertex and fragment shader objects.
 OpenGL->glShaderSource(m_vertexShader, 1, &vertexShaderBuffer, NULL);
 OpenGL->glShaderSource(m_fragmentShader, 1, &fragmentShaderBuffer, NULL);

 // Release the vertex and fragment shader buffers.
 delete [] vertexShaderBuffer;
 vertexShaderBuffer = 0;
 
 delete [] fragmentShaderBuffer;
 fragmentShaderBuffer = 0;

 // Compile the shaders.
 OpenGL->glCompileShader(m_vertexShader);
 OpenGL->glCompileShader(m_fragmentShader);

 // Check to see if the vertex shader compiled successfully.
 OpenGL->glGetShaderiv(m_vertexShader, GL_COMPILE_STATUS, &status);
 if(status != 1)
 {
  // If it did not compile then write the syntax error message out to a text file for review.
  OutputShaderErrorMessage(OpenGL, hwnd, m_vertexShader, vsFilename);
  return false;
 }

 // Check to see if the fragment shader compiled successfully.
 OpenGL->glGetShaderiv(m_fragmentShader, GL_COMPILE_STATUS, &status);
 if(status != 1)
 {
  // If it did not compile then write the syntax error message out to a text file for review.
  OutputShaderErrorMessage(OpenGL, hwnd, m_fragmentShader, fsFilename);
  return false;
 }

 // Create a shader program object.
 m_shaderProgram = OpenGL->glCreateProgram();

 // Attach the vertex and fragment shader to the program object.
 OpenGL->glAttachShader(m_shaderProgram, m_vertexShader);
 OpenGL->glAttachShader(m_shaderProgram, m_fragmentShader);

 // Bind the shader input variables.
 OpenGL->glBindAttribLocation(m_shaderProgram, 0, "inputPosition");
 OpenGL->glBindAttribLocation(m_shaderProgram, 1, "inputTexCoord");
 OpenGL->glBindAttribLocation(m_shaderProgram, 2, "inputNormal");

 // Link the shader program.
 OpenGL->glLinkProgram(m_shaderProgram);

 // Check the status of the link.
 OpenGL->glGetProgramiv(m_shaderProgram, GL_LINK_STATUS, &status);
 if(status != 1)
 {
  // If it did not link then write the syntax error message out to a text file for review.
  OutputLinkerErrorMessage(OpenGL, hwnd, m_shaderProgram);
  return false;
 }

 return true;
}

char* LightShaderClass::LoadShaderSourceFile(char* filename)
{
 ifstream fin;
 int fileSize;
 char input;
 char* buffer;

 // Open the shader source file.
 fin.open(filename);

 // If it could not open the file then exit.
 if(fin.fail())
 {
  return 0;
 }

 // Initialize the size of the file.
 fileSize = 0;

 // Read the first element of the file.
 fin.get(input);

 // Count the number of elements in the text file.
 while(!fin.eof())
 {
  fileSize++;
  fin.get(input);
 }

 // Close the file for now.
 fin.close();

 // Initialize the buffer to read the shader source file into.
 buffer = new char[fileSize+1];
 if(!buffer)
 {
  return 0;
 }

 // Open the shader source file again.
 fin.open(filename);

 // Read the shader text file into the buffer as a block.
 fin.read(buffer, fileSize);

 // Close the file.
 fin.close();

 // Null terminate the buffer.
 buffer[fileSize] = '\0';

 return buffer;
}

void LightShaderClass::OutputShaderErrorMessage(OpenGLClass* OpenGL, HWND hwnd, unsigned int shaderId, char* shaderFilename)
{
 int logSize, i;
 char* infoLog;
 ofstream fout;
 wchar_t newString[128];
 unsigned int error, convertedChars;

 // Get the size of the string containing the information log for the failed shader compilation message.
 OpenGL->glGetShaderiv(shaderId, GL_INFO_LOG_LENGTH, &logSize);

 // Increment the size by one to handle also the null terminator.
 logSize++;

 // Create a char buffer to hold the info log.
 infoLog = new char[logSize];
 if(!infoLog)
 {
  return;
 }

 // Now retrieve the info log.
 OpenGL->glGetShaderInfoLog(shaderId, logSize, NULL, infoLog);

 // Open a file to write the error message to.
 fout.open("shader-error.txt");

 // Write out the error message.
 for(i=0; i<logSize; i++)
 {
  fout << infoLog[i];
 }

 // Close the file.
 fout.close();

 // Convert the shader filename to a wide character string.
 error = mbstowcs_s(&convertedChars, newString, 128, shaderFilename, 128);
 if(error != 0)
 {
  return;
 }

 // Pop a message up on the screen to notify the user to check the text file for compile errors.
 MessageBox(hwnd, L"Error compiling shader.  Check shader-error.txt for message.", newString, MB_OK);

 return;
}

void LightShaderClass::OutputLinkerErrorMessage(OpenGLClass* OpenGL, HWND hwnd, unsigned int programId)
{
 int logSize, i;
 char* infoLog;
 ofstream fout;

 // Get the size of the string containing the information log for the failed shader compilation message.
 OpenGL->glGetProgramiv(programId, GL_INFO_LOG_LENGTH, &logSize);

 // Increment the size by one to handle also the null terminator.
 logSize++;

 // Create a char buffer to hold the info log.
 infoLog = new char[logSize];
 if(!infoLog)
 {
  return;
 }

 // Now retrieve the info log.
 OpenGL->glGetProgramInfoLog(programId, logSize, NULL, infoLog);

 // Open a file to write the error message to.
 fout.open("linker-error.txt");

 // Write out the error message.
 for(i=0; i<logSize; i++)
 {
  fout << infoLog[i];
 }

 // Close the file.
 fout.close();

 // Pop a message up on the screen to notify the user to check the text file for linker errors.
 MessageBox(hwnd, L"Error compiling linker.  Check linker-error.txt for message.", L"Linker Error", MB_OK);

 return;
}

void LightShaderClass::ShutdownShader(OpenGLClass* OpenGL)
{
 // Detach the vertex and fragment shaders from the program.
 OpenGL->glDetachShader(m_shaderProgram, m_vertexShader);
 OpenGL->glDetachShader(m_shaderProgram, m_fragmentShader);

 // Delete the vertex and fragment shaders.
 OpenGL->glDeleteShader(m_vertexShader);
 OpenGL->glDeleteShader(m_fragmentShader);

 // Delete the shader program.
 OpenGL->glDeleteProgram(m_shaderProgram);

 return;
}

The SetShaderParameters function now takes in an ambient light color value and then sets the ambientLight uniform variable in the pixel shader.

SetShaderParameters方法增加了环境光作为参数，并设置像素着色器的环境光的一直变量。

bool LightShaderClass::SetShaderParameters(OpenGLClass* OpenGL, float* worldMatrix, float* viewMatrix, float* projectionMatrix, int textureUnit,
        float* lightDirection, float* diffuseLightColor, float* ambientLight)
{
 unsigned int location;

 // Set the world matrix in the vertex shader.
 location = OpenGL->glGetUniformLocation(m_shaderProgram, "worldMatrix");
 if(location == -1)
 {
  return false;
 }
 OpenGL->glUniformMatrix4fv(location, 1, false, worldMatrix);

 // Set the view matrix in the vertex shader.
 location = OpenGL->glGetUniformLocation(m_shaderProgram, "viewMatrix");
 if(location == -1)
 {
  return false;
 }
 OpenGL->glUniformMatrix4fv(location, 1, false, viewMatrix);

 // Set the projection matrix in the vertex shader.
 location = OpenGL->glGetUniformLocation(m_shaderProgram, "projectionMatrix");
 if(location == -1)
 {
  return false;
 }
 OpenGL->glUniformMatrix4fv(location, 1, false, projectionMatrix);

 // Set the texture in the pixel shader to use the data from the first texture unit.
 location = OpenGL->glGetUniformLocation(m_shaderProgram, "shaderTexture");
 if(location == -1)
 {
  return false;
 }
 OpenGL->glUniform1i(location, textureUnit);

 // Set the light direction in the pixel shader.
 location = OpenGL->glGetUniformLocation(m_shaderProgram, "lightDirection");
 if(location == -1)
 {
  return false;
 }
 OpenGL->glUniform3fv(location, 1, lightDirection);

 // Set the light direction in the pixel shader.
 location = OpenGL->glGetUniformLocation(m_shaderProgram, "diffuseLightColor");
 if(location == -1)
 {
  return false;
 }
 OpenGL->glUniform4fv(location, 1, diffuseLightColor);

The ambient value in the pixel shader is set here.

这里设置像素着色器的环境光的值。

 // Set the ambient light in the pixel shader.
 location = OpenGL->glGetUniformLocation(m_shaderProgram, "ambientLight");
 if(location == -1)
 {
  return false;
 }
 OpenGL->glUniform4fv(location, 1, ambientLight);

 return true;
}

Lightclass.h

The LightClass was updated for this tutorial to have an ambient component and related helper functions.

本章更新了LightClass，增加了环境光照部分。

////////////////////////////////////////////////////////////////////////////////
// Filename: lightclass.h
////////////////////////////////////////////////////////////////////////////////
#ifndef _LIGHTCLASS_H_
#define _LIGHTCLASS_H_

////////////////////////////////////////////////////////////////////////////////
// Class name: LightClass
////////////////////////////////////////////////////////////////////////////////
class LightClass
{
public:
 LightClass();
 LightClass(const LightClass&);
 ~LightClass();

 void SetDiffuseColor(float, float, float, float);
 void SetDirection(float, float, float);
 void SetAmbientLight(float, float, float, float);

 void GetDiffuseColor(float*);
 void GetDirection(float*);
 void GetAmbientLight(float*);

private:
 float m_diffuseColor[4];
 float m_direction[3];
 float m_ambientLight[4];
};

#endif

Lightclass.cpp

////////////////////////////////////////////////////////////////////////////////
// Filename: lightclass.cpp
////////////////////////////////////////////////////////////////////////////////
#include "lightclass.h"

LightClass::LightClass()
{
}

LightClass::LightClass(const LightClass& other)
{
}

LightClass::~LightClass()
{
}

void LightClass::SetDiffuseColor(float red, float green, float blue, float alpha)
{
 m_diffuseColor[0] = red;
 m_diffuseColor[1] = green;
 m_diffuseColor[2] = blue;
 m_diffuseColor[3] = alpha;
 return;
}

void LightClass::SetDirection(float x, float y, float z)
{
 m_direction[0] = x;
 m_direction[1] = y;
 m_direction[2] = z;
 return;
}

void LightClass::SetAmbientLight(float red, float green, float blue, float alpha)
{
 m_ambientLight[0] = red;
 m_ambientLight[1] = green;
 m_ambientLight[2] = blue;
 m_ambientLight[3] = alpha;
 return;
}

void LightClass::GetDiffuseColor(float* color)
{
 color[0] = m_diffuseColor[0];
 color[1] = m_diffuseColor[1];
 color[2] = m_diffuseColor[2];
 color[3] = m_diffuseColor[3];
 return;
}

void LightClass::GetDirection(float* direction)
{
 direction[0] = m_direction[0];
 direction[1] = m_direction[1];
 direction[2] = m_direction[2];
 return;
}

void LightClass::GetAmbientLight(float* ambient)
{
 ambient[0] = m_ambientLight[0];
 ambient[1] = m_ambientLight[1];
 ambient[2] = m_ambientLight[2];
 ambient[3] = m_ambientLight[3];
 return;
}

Graphicsclass.h

The header for the GraphicsClass hasn't changed for this tutorial.

////////////////////////////////////////////////////////////////////////////////
// Filename: graphicsclass.h
////////////////////////////////////////////////////////////////////////////////
#ifndef _GRAPHICSCLASS_H_
#define _GRAPHICSCLASS_H_

///////////////////////
// MY CLASS INCLUDES //
///////////////////////
#include "openglclass.h"
#include "cameraclass.h"
#include "modelclass.h"
#include "lightshaderclass.h"
#include "lightclass.h"

/////////////
// GLOBALS //
/////////////
const bool FULL_SCREEN = true;
const bool VSYNC_ENABLED = true;
const float SCREEN_DEPTH = 1000.0f;
const float SCREEN_NEAR = 0.1f;

////////////////////////////////////////////////////////////////////////////////
// Class name: GraphicsClass
////////////////////////////////////////////////////////////////////////////////
class GraphicsClass
{
public:
 GraphicsClass();
 GraphicsClass(const GraphicsClass&);
 ~GraphicsClass();

 bool Initialize(OpenGLClass*, HWND);
 void Shutdown();
 bool Frame();

private:
 bool Render(float);

private:
 OpenGLClass* m_OpenGL;
 CameraClass* m_Camera;
 ModelClass* m_Model;
 LightShaderClass* m_LightShader;
 LightClass* m_Light;
};

#endif

Graphicsclass.cpp

////////////////////////////////////////////////////////////////////////////////
// Filename: graphicsclass.cpp
////////////////////////////////////////////////////////////////////////////////
#include "graphicsclass.h"

GraphicsClass::GraphicsClass()
{
 m_OpenGL = 0;
 m_Camera = 0;
 m_Model = 0;
 m_LightShader = 0;
 m_Light = 0;
}

GraphicsClass::GraphicsClass(const GraphicsClass& other)
{
}

GraphicsClass::~GraphicsClass()
{
}

bool GraphicsClass::Initialize(OpenGLClass* OpenGL, HWND hwnd)
{
 bool result;

 // Store a pointer to the OpenGL class object.
 m_OpenGL = OpenGL;

 // Create the camera object.
 m_Camera = new CameraClass;
 if(!m_Camera)
 {
  return false;
 }

 // Set the initial position of the camera.
 m_Camera->SetPosition(0.0f, 0.0f, -10.0f);

 // Create the model object.
 m_Model = new ModelClass;
 if(!m_Model)
 {
  return false;
 }

 // Initialize the model object.
 result = m_Model->Initialize(m_OpenGL,  "../Engine/data/cube.txt", "../Engine/data/opengl.tga", 0, true);
 if(!result)
 {
  MessageBox(hwnd, L"Could not initialize the model object.", L"Error", MB_OK);
  return false;
 }
 
 // Create the light shader object.
 m_LightShader = new LightShaderClass;
 if(!m_LightShader)
 {
  return false;
 }

 // Initialize the light shader object.
 result = m_LightShader->Initialize(m_OpenGL, hwnd);
 if(!result)
 {
  MessageBox(hwnd, L"Could not initialize the light shader object.", L"Error", MB_OK);
  return false;
 }

 // Create the light object.
 m_Light = new LightClass;
 if(!m_Light)
 {
  return false;
 }

Set the intensity of the ambient light to 15% white color. Also set the direction of the light to point down the positive X axis so we can directly see the effect of ambient lighting on the cube.

设置环境光强度为15%白色。设置光照方向为X轴正方向，这样我们就可以看到盒子上环境光照的效果。

 // Initialize the light object.
 m_Light->SetDiffuseColor(1.0f, 1.0f, 1.0f, 1.0f);
 m_Light->SetDirection(1.0f, 0.0f, 0.0f);
 m_Light->SetAmbientLight(0.15f, 0.15f, 0.15f, 1.0f);

 return true;
}

void GraphicsClass::Shutdown()
{
 // Release the light object.
 if(m_Light)
 {
  delete m_Light;
  m_Light = 0;
 }

 // Release the light shader object.
 if(m_LightShader)
 {
  m_LightShader->Shutdown(m_OpenGL);
  delete m_LightShader;
  m_LightShader = 0;
 }

 // Release the model object.
 if(m_Model)
 {
  m_Model->Shutdown(m_OpenGL);
  delete m_Model;
  m_Model = 0;
 }

 // Release the camera object.
 if(m_Camera)
 {
  delete m_Camera;
  m_Camera = 0;
 }

 // Release the pointer to the OpenGL class object.
 m_OpenGL = 0;

 return;
}

bool GraphicsClass::Frame()
{
 bool result;
 static float rotation = 0.0f;

I have slowed down the rotation by half so the effect is easier to see.

我将旋转速度减半，这样效果很明显。

// Update the rotation variable each frame.
 rotation += 0.0174532925f * 1.0f;
 if(rotation > 360.0f)
 {
  rotation -= 360.0f;
 }

 // Render the graphics scene.
 result = Render(rotation);
 if(!result)
 {
  return false;
 }

 return true;
}

In the render function we have added getting the ambient light value from the light object and then setting it in the shader during rendering.

Render方法增加了从光照对象获取环境光值的代码，并在渲染时设置到着色器中。

bool GraphicsClass::Render(float rotation)
{
 float worldMatrix[16];
 float viewMatrix[16];
 float projectionMatrix[16];
 float lightDirection[3];
 float diffuseLightColor[4];
 float ambientLight[4];

 // Clear the buffers to begin the scene.
 m_OpenGL->BeginScene(0.0f, 0.0f, 0.0f, 1.0f);

 // Generate the view matrix based on the camera's position.
 m_Camera->Render();

 // Get the world, view, and projection matrices from the opengl and camera objects.
 m_OpenGL->GetWorldMatrix(worldMatrix);
 m_Camera->GetViewMatrix(viewMatrix);
 m_OpenGL->GetProjectionMatrix(projectionMatrix);

 // Get the light properties.
 m_Light->GetDirection(lightDirection);
 m_Light->GetDiffuseColor(diffuseLightColor);
 m_Light->GetAmbientLight(ambientLight);

 // Rotate the world matrix by the rotation value so that the triangle will spin.
 m_OpenGL->MatrixRotationY(worldMatrix, rotation);

 // Set the light shader as the current shader program and set the matrices that it will use for rendering.
 m_LightShader->SetShader(m_OpenGL);
 m_LightShader->SetShaderParameters(m_OpenGL, worldMatrix, viewMatrix, projectionMatrix, 0, lightDirection, diffuseLightColor, ambientLight);

 // Render the model using the light shader.
 m_Model->Render(m_OpenGL);
 
 // Present the rendered scene to the screen.
 m_OpenGL->EndScene();

 return true;
}

Summary

总结

With the addition of ambient lighting all surfaces now illuminate to a minimum degree to produce a more realistic lighting effect.

增加环境光照后，我们得到了更加真实的光照效果。

To Do Exercises

练习

1. Recompile the code and ensure you get a spinning cube that is illuminated on the dark side now.

1. 重新编译并运行代码，确保得到一个阴暗面可见的旋转盒子。

2. Change the ambient light value to (0.0f, 0.0f, 0.0f, 1.0f) to see just the diffuse component again.

2. 将环境光的值改为(0.0f, 0.0f, 0.0f, 1.0f)，再看光照效果。

Source Code

源代码

http://www.rastertek.com/gl40src09.zip