Implementing Ambient Lighting | CodeSignal Learn

Implementing Ambient Lighting | CodeSignal Learn

Introduction

Welcome back to the second lesson of Realistic Lighting with the Phong Model! In our previous lesson, we explored surface normals and learned how these invisible vectors determine surface orientation. Now we're ready to take the next crucial step: implementing ambient lighting, the foundation of the Phong lighting model. Ambient lighting represents the uniform, indirect illumination that fills a scene, ensuring that no surface appears completely black even when not directly lit. Think of it as the gentle, even light that bounces around a room, providing base illumination to every surface regardless of its orientation. By the end of this lesson, we'll transform our normal-visualizing cube into a beautifully lit 3D object with realistic ambient illumination.

Understanding Ambient Lighting

Ambient lighting is the simplest yet most essential component of realistic lighting systems. Unlike directional or point lights that create highlights and shadows based on surface orientation, ambient light provides uniform illumination to all surfaces equally. In the real world, this corresponds to the soft, diffused light that bounces around indoor spaces or the overcast sky that illuminates outdoor scenes. Ambient lighting ensures that surfaces facing away from direct light sources remain visible rather than appearing as pure black silhouettes. This creates more natural-looking scenes where details remain visible even in shadowed areas, just as our eyes experience in real environments.

The Ambient Lighting Equation

\text{Ambient} = \text{Ambient Light} \times \text{Material Color}

Sign up

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Fragment Shader Implementation

Our fragment shader implements ambient lighting with remarkable simplicity, requiring just two lines of code to transform flat colors into naturally illuminated surfaces. uniform vec3 ambientLight = vec3(0.3, 0.3, 0.4); void main() {vec3 ambient = ambientLight * vColor; FragColor = vec4(ambient, 1.0);} The ambientLight uniform defines our global ambient illumination color. In the main function, we calculate the ambient component by multiplying this ambient light with the incoming vertex color vColor . This simple multiplication ensures that every pixel receives the same proportional amount of ambient illumination, regardless of surface orientation. The result is a uniformly lit surface that maintains its material color characteristics while being gently illuminated by our ambient light.

Vertex Shader Color Transmission

Our vertex shader now handles three attributes and passes the color information through to the fragment shader, creating the pipeline necessary for our ambient lighting calculations. layout(location = 0) in vec3 aPos; layout(location = 1) in vec3 aColor; layout(location = 2) in vec3 aNormal; uniform mat4 uModel; uniform mat4 uView; uniform mat4 uProjection; out vec3 vColor; out vec3 vNormal; void main() { vColor = aColor; vNormal = mat3(transpose(inverse(uModel))) * aNormal; gl_Position = uProjection * uView * uModel * vec4(aPos, 1.0); } The vertex shader declares three input attributes: position at location 0, color at location 1, and normal at location 2. We pass both the color and normal as output variables to the fragment shader, even though we currently only use the color for ambient lighting. This forward-thinking approach prepares our shader pipeline for the diffuse and specular lighting components we'll add in future lessons. The position transformation remains identical to our previous lesson, applying the standard model-view-projection matrix sequence.

Vertex Attribute Configuration

The vertex attribute setup now accommodates our expanded vertex format with nine floats per vertex, requiring careful stride and offset calculations to properly feed data to our shaders. // Position attribute (location = 0) glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 9 * sizeof(float), (void *)0); glEnableVertexAttribArray(0); // Color attribute (location = 1) glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 9 * sizeof(float), (void *)(3 * sizeof(float))); glEnableVertexAttribArray(1); // Normal attribute (location = 2) glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 9 * sizeof(float), (void *)(6 * sizeof(float))); glEnableVertexAttribArray(2); The stride value changes to 9 * sizeof(float) to reflect our expanded vertex size. The position attribute starts at offset 0, the color attribute starts after the position data at offset 3 * sizeof(float), and the normal attribute starts after both position and color at offset 6 * sizeof(float) . This careful configuration ensures that OpenGL correctly interprets our interleaved vertex data and delivers the right information to each shader attribute location.

Our vertex data structure has evolved from the previous lesson to include color information alongside position and normal data. Each vertex now contains nine floating-point values, creating a richer data foundation for our lighting calculations.

C++

float verts[] = {
    // Front face: position (3), color (3), normal (3)
    -0.5f, -0.5f,  0.5f,  1.0f, 0.8f, 0.6f,  0.0f,  0.0f,  1.0f,
     0.5f, -0.5f,  0.5f,  1.0f, 0.8f, 0.6f,  0.0f,  0.0f,  1.0f,
     0.5f,  0.5f,  0.5f,  1.0f, 0.8f, 0.6f,  0.0f,  0.0f,  1.0f,
    -0.5f,  0.5f,  0.5f,  1.0f, 0.8f, 0.6f,  0.0f,  0.0f,  1.0f,
    // Additional faces follow the same pattern...
};

The warm color $(1.0, 0.8, 0.6)$ represents a cream or beige material that will interact beautifully with our cool ambient lighting. As you may recall from the previous lesson, we still maintain the surface normals for each face, though we won't use them until we implement the diffuse and specular components of the Phong model. This interleaved data structure efficiently packs all the information our shaders need while maintaining good memory access patterns for the graphics hardware.

glsl

layout(location = 0) in vec3 aPos;
layout(location = 1) in vec3 aColor;
layout(location = 2) in vec3 aNormal;

uniform mat4 uModel;
uniform mat4 uView;
uniform mat4 uProjection;
out vec3 vColor;
out vec3 vNormal;

void main() {
    vColor = aColor;
    vNormal = mat3(transpose(inverse(uModel))) * aNormal;
    gl_Position = uProjection * uView * uModel * vec4(aPos, 1.0);
}

C++

// Position attribute (location = 0)
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 9 * sizeof(float), (void *)0);
glEnableVertexAttribArray(0);

// Color attribute (location = 1)
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 9 * sizeof(float), (void *)(3 * sizeof(float)));
glEnableVertexAttribArray(1);

// Normal attribute (location = 2)
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 9 * sizeof(float), (void *)(6 * sizeof(float)));
glEnableVertexAttribArray(2);