DirectX Computational Graphics: Lighting

Introduction to Lighting Models in DirectX

Effective lighting is crucial for creating realistic and immersive 3D environments in DirectX applications. It simulates how light interacts with surfaces, influencing their perceived color, brightness, and texture. This section delves into the fundamental concepts and common models used for lighting computation within the DirectX framework.

The Role of Light in Rendering

Light sources emit photons that travel through the scene and interact with objects. These interactions, including reflection, refraction, and absorption, determine the color and intensity of light that reaches the viewer's eye. By simulating these phenomena, we can achieve a wide range of visual effects, from the soft glow of a lamp to the harsh glare of the sun.

In real-time graphics, we approximate these physical processes using various lighting models. These models take into account:

Light Properties: Color, intensity, type (directional, point, spot).
Material Properties: How a surface reflects or absorbs light (e.g., diffuse color, specular highlights, shininess).
Surface Normals: The orientation of the surface at a given point, which dictates how light reflects off it.
View Direction: The direction from which the viewer is observing the surface, affecting specular highlights.

Basic Lighting Components

Most lighting models can be broken down into three primary components:

1. Ambient Light

Ambient light represents indirect lighting that illuminates the entire scene uniformly, regardless of the position or direction of light sources. It simulates light that has bounced off multiple surfaces and scattered throughout the environment, preventing areas from being completely black.

The formula is simple:


                            final_color = material_ambient * light_ambient;

Here, material_ambient is the ambient color of the material, and light_ambient is the ambient intensity of the light source.

2. Diffuse Light

Diffuse light is the light that is scattered equally in all directions from a surface. Its intensity depends on the angle between the light source's direction and the surface's normal vector. When the light hits the surface perpendicularly (dot product of light direction and normal is 1), it's brightest. As the angle increases, the intensity decreases.

The calculation often involves the dot product:


                            diffuse_factor = max(0, dot(light_direction, surface_normal));
                            final_color = material_diffuse * light_diffuse * diffuse_factor;

material_diffuse is the diffuse color of the material, and light_diffuse is the diffuse intensity of the light. The max(0, ...) ensures that light coming from behind the surface doesn't contribute.

3. Specular Light

Specular light creates bright, shiny highlights on surfaces. It occurs when light reflects directly off a surface towards the viewer. The intensity of specular highlights depends on the shininess of the material and the viewing angle relative to the light's reflection direction.

A common model uses the Blinn-Phong or Phong specular component:


                            // For Phong
                            reflection_vector = reflect(-light_direction, surface_normal);
                            specular_factor = pow(max(0, dot(view_direction, reflection_vector)), shininess);

                            // For Blinn-Phong (often more efficient)
                            half_vector = normalize(light_direction + view_direction);
                            specular_factor = pow(max(0, dot(surface_normal, half_vector)), shininess);

                            final_color = material_specular * light_specular * specular_factor;

material_specular is the specular color, light_specular is the specular intensity, and shininess controls the size and intensity of the highlight.

Common Lighting Models

By combining these components, we can implement various lighting models:

Phong Lighting Model

The Phong model sums ambient, diffuse, and specular components. It's a widely used and understood model for achieving realistic shading.


                            Total Light = Ambient Light + Diffuse Light + Specular Light

Visual representation of Phong lighting components on a sphere.

Gouraud Shading

While not strictly a lighting model itself, Gouraud shading is a technique for interpolating lighting calculations across a polygon. Lighting is calculated at each vertex and then linearly interpolated across the face. This is faster than per-pixel lighting but can result in less accurate specular highlights.

Per-Pixel Lighting (DirectX 7+)

With the advent of programmable shaders, per-pixel lighting became commonplace. Here, lighting calculations are performed for every pixel (fragment) on the screen, leading to much more accurate and detailed lighting effects, especially for specular highlights and complex surface interactions. The Phong or Blinn-Phong models are typically implemented in pixel shaders for per-pixel lighting.

Implementing Lighting in DirectX

DirectX provides powerful tools and APIs to implement sophisticated lighting. You'll typically define:

Light Structures: Using structures like D3DLIGHT9 (for DirectX 9) or shader constants for modern versions to define light properties.
Material Structures: Using structures like D3DMATERIAL9 (for DirectX 9) or shader constants to define surface properties.
Shader Programs: Writing HLSL (High-Level Shading Language) code for both vertex and pixel shaders to perform the lighting calculations.

The vertex shader might transform vertices and calculate basic lighting per vertex (for Gouraud), while the pixel shader performs the detailed per-pixel lighting calculations based on interpolated data and surface normals.

For example, a basic HLSL pixel shader might look like this:


                        float4 PSMain(float4 pos : SV_POSITION, float2 tex : TEXCOORD0, float3 normal : NORMAL) : SV_TARGET
                        {
                            // ... (get material properties, light properties, view direction) ...

                            float3 lightDir = normalize(-LightPosition.xyz); // Assuming a point light
                            float3 viewDir = normalize(-pos.xyz);           // Simplified view direction
                            float3 surfaceNormal = normalize(normal);

                            // Ambient
                            float4 ambient = Material.Ambient * Light.Ambient;

                            // Diffuse
                            float diff = max(0, dot(surfaceNormal, lightDir));
                            float4 diffuse = Material.Diffuse * Light.Diffuse * diff;

                            // Specular (using Blinn-Phong)
                            float3 halfVector = normalize(lightDir + viewDir);
                            float spec = pow(max(0, dot(surfaceNormal, halfVector)), Material.Power);
                            float4 specular = Material.Specular * Light.Specular * spec;

                            float4 finalColor = ambient + diffuse + specular;
                            finalColor.a = Material.Diffuse.a; // Preserve alpha from diffuse

                            return finalColor;
                        }

MSDN Documentation