The short answer
An illumination model (also called a lighting model or reflection model) is the set of rules a renderer uses to calculate how much light, and of what colour, leaves a point on a surface towards the viewer. It takes into account the light sources, the surface’s orientation, the material’s properties and the viewing direction.
Illumination models range from simple formulas, like the classic ambient + diffuse + specular combination, to physically based models that simulate how real materials scatter light. They fall into two broad families:
- Local illumination models consider only light arriving directly from light sources.
- Global illumination models also account for light that bounces between surfaces, plus shadows, reflections and refraction.
What an illumination model needs to know
At any point on a surface, a lighting calculation typically uses:
- The surface normal (N): which way the surface faces.
- The light direction (L): from the point towards each light.
- The view direction (V): from the point towards the camera.
- Material properties: colour, how matte or glossy it is, whether it’s metallic or transparent.
- Light properties: colour, intensity, type and distance.
The model combines these into a colour value for that point.
Local illumination models
The classic local model splits reflected light into three components. Together they form the Phong reflection model, which has a dedicated article of its own.
Ambient light
I = k_a * i_a
Ambient light is a constant amount added to every surface, a crude stand-in for all the light that bounces around a real environment. k_a is the material’s ambient reflectivity and i_a the ambient light level. It stops unlit sides from being totally black, but it adds no shape or depth on its own.
Diffuse reflection (Lambertian)
I = k_d * i_d * max(N · L, 0)
Diffuse reflection models matte surfaces that scatter light equally in all directions, such as paper, plaster or unpolished stone. It follows Lambert’s cosine law: the amount of light a surface receives is proportional to the cosine of the angle between its normal and the light direction. Surfaces facing the light are bright, while those at a grazing angle are dim. Since the light scatters evenly, diffuse brightness doesn’t change with viewing angle.
Specular reflection
Phong: I = k_s * i_s * max(R · V, 0)^n
Blinn-Phong: I = k_s * i_s * max(N · H, 0)^n
Specular reflection produces the highlights on shiny surfaces. It depends on where the viewer is: the highlight is brightest when the view direction lines up with the mirror reflection of the light (R). Blinn-Phong uses the half vector H between the light and view directions instead. The exponent n (shininess) controls how small and sharp the highlight is.
Putting them together
The complete local model adds the terms and sums over every light:
I = k_a * i_a + Σ_lights [ k_d * i_d * max(N · L, 0) + k_s * i_s * max(R · V, 0)^n ]
This is cheap to compute and was the standard lighting model in real-time graphics for decades.
Light sources and attenuation
Illumination models also depend on how lights are defined:
- Ambient light: no direction, applied uniformly.
- Directional light: parallel rays from an infinitely distant source, like the sun. No distance falloff.
- Point light: emits in all directions from a single point, like a bare bulb.
- Spotlight: a point light limited to a cone, with a soft edge.
- Area light: emits from a surface such as a rectangle or disc. It produces soft shadows and is common in offline and physically based rendering.
Real light intensity falls off with the square of the distance from the source (the inverse-square law). Older real-time models often used an adjustable formula like 1 / (c + l·d + q·d²) for artistic control. Physically based renderers generally use inverse-square falloff.
Global illumination models
Local models ignore everything except the direct path from light to surface: no shadows from other objects, no reflections of the environment, no light bouncing off a red wall onto a white floor. Global illumination (GI) methods address this:
- Ray tracing (Turner Whitted, 1980): traces rays from the camera, spawning shadow, reflection and refraction rays at each hit. It gives accurate mirror reflections, refraction and hard shadows.
- Radiosity (introduced to graphics in 1984): divides the scene into patches and solves for how diffuse light bounces between them. It’s good for soft indirect light in architectural interiors, but it doesn’t handle shiny surfaces.
- Path tracing (based on James Kajiya’s 1986 rendering equation): traces random light paths with many bounces and averages them. It handles soft shadows, indirect light, glossy reflections and more. Most modern offline renderers, including Blender’s Cycles, work this way.
- Photon mapping (Henrik Wann Jensen, 1990s): first shoots photons from the lights and stores where they land, then uses them to estimate indirect light and caustics during rendering.
Our explainer on ray tracing vs rasterization vs path tracing covers these techniques in more depth. In real-time graphics, GI is often approximated with baked lightmaps, light probes and screen-space tricks such as SSAO.
Physically based illumination models
Modern renderers have largely moved beyond Phong-style formulas to physically based models. The key idea is the BRDF (bidirectional reflectance distribution function). It describes, for any incoming light direction and outgoing view direction, how much light a material reflects.
Physically based BRDFs generally:
- Conserve energy: a surface never reflects more light than it receives.
- Model microfacets: they treat rough surfaces as many tiny mirror-like facets. The Cook-Torrance model (1982) with a GGX distribution is a common choice.
- Include Fresnel: surfaces become more reflective at grazing angles.
- Use intuitive parameters such as base colour, roughness and metallic, which artists supply as PBR texture maps.
Blender’s Principled BSDF, Unreal Engine’s materials and most current production renderers follow this approach. The rendering equation ties it all together: the light leaving a point equals the light it emits plus the integral of all incoming light weighted by the BRDF. Path tracers solve this equation numerically.
Illumination model vs shading model
These terms are often mixed up, especially in textbooks:
- The illumination model answers “how much light leaves this point?”
- The shading model (or shading method) answers “which points do we evaluate it at, and how do we fill in the rest of the polygon?”
Common shading methods are flat shading (once per polygon), Gouraud shading (at vertices, colours interpolated) and Phong shading (normals interpolated, lighting evaluated per pixel). You can combine any illumination model with any of these.
Comparison table
| Model | Type | What it captures | What it misses | Cost |
|---|---|---|---|---|
| Ambient | Local | Base fill light | Shape, direction, shadows | Very low |
| Lambert (diffuse) | Local | Matte shading from light direction | Highlights, bounced light | Very low |
| Phong / Blinn-Phong | Local | Matte + shiny highlights | Shadows, reflections, GI; not energy-conserving | Low |
| Physically based BRDF (e.g. Cook-Torrance/GGX) | Local (used inside global methods) | Realistic roughness, metals, Fresnel | GI unless combined with a global method | Low–moderate |
| Ray tracing (Whitted) | Global | Mirror reflections, refraction, hard shadows | Soft indirect light | Moderate–high |
| Radiosity | Global | Diffuse interreflection | Glossy/specular effects | High (precomputed) |
| Path tracing | Global | Nearly all light transport | Can be noisy; slow | High |
| Photon mapping | Global | Caustics, indirect light | Slight blur (bias) | High |
Applications span almost everything in 3D: games and VR (mostly fast local models plus approximations), CAD viewports, film and animation (path tracing), architectural visualization, and product design. For a practical look at how this plays out in real tools, see our guide to 3D rendering software.