Advanced Lighting Techniques in DirectX

This tutorial explores advanced lighting models and techniques that go beyond basic diffuse and specular reflections, enabling more realistic and visually complex scenes in your DirectX applications.

Understanding the Fundamentals

Before diving into advanced methods, it's crucial to have a solid grasp of:

Phong Lighting Model: Ambient, Diffuse, and Specular components.
Normal Mapping: Simulating surface detail and bumps without increasing polygon count.
Shader Programming (HLSL/GLSL): The foundation for implementing custom lighting calculations.

Advanced Lighting Models

Beyond the standard Phong model, several advanced techniques offer greater realism:

Physically Based Rendering (PBR)

PBR aims to simulate how light interacts with materials in the real world. Key concepts include:

Microfacet Theory: Modeling surface roughness at a microscopic level.
Energy Conservation: Ensuring that reflected light does not exceed incoming light.
Common PBR Maps: Albedo (Base Color), Metallic, Roughness, Ambient Occlusion (AO), Normal.

Implementing PBR often involves using specialized shaders and carefully authored material properties. A simplified PBR lighting equation might look like:

float3 Lo = (kD * albedo / PI + ks) * cosThetaI;

Image-Based Lighting (IBL)

IBL uses environment maps (like cubemaps) to illuminate scenes, capturing realistic global illumination from the surrounding environment. This includes:

Diffuse IBL: Pre-convolved diffuse environment map for ambient lighting.
Specular IBL: Using a mipmapped specular environment map or a pre-filtered specular environment map for reflections.

Subsurface Scattering (SSS)

Simulates light that penetrates translucent surfaces, scatters internally, and exits at a different point. This is common for materials like skin, wax, and marble.

Implementing SSS can be computationally expensive and often involves:

Approximation techniques (e.g., Screen Space Subsurface Scattering).
Pre-computation of scattering profiles.

Global Illumination (GI)

GI accounts for indirect lighting – light that bounces off surfaces multiple times. This provides a more natural and immersive lighting environment.

Techniques for achieving GI include:

Light Probes: Capturing lighting at specific points in space.
Radiosity: Simulating diffuse inter-reflection.
Ray Tracing: While computationally intensive, real-time ray tracing offers the most accurate GI.

Advanced Techniques and Implementation Details

Anisotropic Lighting

Simulates materials where highlights are stretched in a particular direction, such as brushed metal or hair. This requires an anisotropic texture map to define the directionality.

Iridescence

Accounts for the phenomenon where the color of a surface appears to change depending on the viewing angle, common in soap bubbles or butterfly wings.

Fresnel Effect

The Fresnel effect describes how reflectivity of a surface changes with the viewing angle. It's more reflective at glancing angles. This is a crucial component of PBR.

float FresnelSchlick(float cosTheta, float eta) {
                return pow(1 - cosTheta, 5) / (1 - eta * eta); // Simplified
            }

Screen Space Reflections (SSR)

A real-time technique that uses the depth buffer to cast rays and find reflections within the visible screen space. It's efficient but limited to what's on screen.

Deferred Shading and Rendering

Deferred shading decouples the lighting calculation from the geometry rendering. It first renders geometric properties (position, normals, albedo) to multiple render targets (a G-buffer) and then performs lighting calculations in a separate pass. This is highly beneficial for scenes with many dynamic lights.

Shader Implementation Examples (HLSL Snippets)

Basic PBR BRDF (Cook-Torrance)

// Microfacet Normal Distribution Function (GGX)
            float D_GGX(float NdotH, float roughness) {
                float a = roughness * roughness;
                float a2 = a * a;
                float NdotH2 = NdotH * NdotH;
                return (a2 / (PI * pow(NdotH2 * (a2 - 1.0) + 1.0, 2)));
            }

            // Fresnel (Schlick approximation)
            float F_Schlick(float VdotH, float F0) {
                return F0 + (1.0 - F0) * pow(1.0 - VdotH, 5.0);
            }

            // Geometry Shadowing (Smith with GGX)
            float V_SmithGGXCorrelated(float NdotV, float NdotL, float roughness) {
                float a = roughness * roughness;
                float a2 = a * a;
                float NdotV2 = NdotV * NdotV;
                float NdotL2 = NdotL * NdotL;

                float lambdaV = NdotV * sqrt((-a2) + 1.0);
                lambdaV = (1.0 - sqrt(1.0 + lambdaV * lambdaV)) / 2.0;
                float lambdaL = NdotL * sqrt((-a2) + 1.0);
                lambdaL = (1.0 - sqrt(1.0 + lambdaL * lambdaL)) / 2.0;

                return 1.0 / ( (1.0 + lambdaV) * (1.0 + lambdaL) );
            }

            // PBR lighting calculation for a single light source
            float3 CalculatePBR(float3 N, float3 V, float3 L, float3 albedo, float metallic, float roughness, float3 F0, float3 lightColor) {
                float3 H = normalize(V + L);
                float NdotV = max(dot(N, V), 0.0);
                float NdotL = max(dot(N, L), 0.0);
                float NdotH = max(dot(N, H), 0.0);
                float VdotH = max(dot(V, H), 0.0);

                float3 F = F_Schlick(VdotH, F0);
                float3 D = D_GGX(NdotH, roughness);
                float3 V_geom = V_SmithGGXCorrelated(NdotV, NdotL, roughness);

                float3 specular = (D * F * V_geom) / (4.0 * NdotV * NdotL + 0.001);
                float3 diffuse = (1.0 - F) * albedo / PI;

                return (diffuse + specular) * lightColor * NdotL;
            }

Best Practices

Profile your shaders: Identify performance bottlenecks.
Use texture arrays: For efficient material loading.
Optimize uniform buffer objects (UBOs) / constant buffers: Minimize data transfers.
Leverage GPU hardware features: Such as texture compression and shader model capabilities.
Test on target hardware: Ensure performance and visual fidelity.

MSDN Documentation

DirectX Computational Graphics