7.3 Lighting & PBR

Every shader you wrote in the last lesson picked a color and used it directly — a texture sample, a flat tint, maybe a gradient. None of it knew where the light in the scene was coming from. This lesson adds light. You will build a shader that actually reacts to a light source, see exactly why the classic tricks programmers used for decades eventually stopped looking right, and learn the ideas behind PBR (Physically Based Rendering — writing lighting math that follows real physics closely enough that a material looks correct under any lighting, not just the one light you happened to test with).

1. The Three Vectors Every Lighting Shader Needs

Recall from the rendering pipeline lesson: the vertex shader runs once per vertex and the fragment shader runs once per pixel, with the GPU smoothly interpolating (blending) whatever the vertex shader outputs across each triangle's surface. Every lighting formula in this lesson is built from three arrows, all drawn from the same point on the surface being shaded:

• N — the surface normal (a unit-length vector pointing straight out of the surface, perpendicular to it — "which way is this tiny patch of surface facing").
• L — the direction from the surface point to the light.
• V — the direction from the surface point to the camera (also called the view direction).

To get N and V in world space, every shader below starts from the same small building block. This is worth typing out once, since every shader in this lesson reuses it:

struct appdata
{
    float4 vertex : POSITION;
    float3 normal : NORMAL;
};

struct v2f
{
    float4 pos         : SV_POSITION;
    float3 worldNormal : TEXCOORD0;
    float3 worldPos    : TEXCOORD1;
};

v2f vert(appdata v)
{
    v2f o;
    o.pos         = UnityObjectToClipPos(v.vertex);
    o.worldNormal = UnityObjectToWorldNormal(v.normal);
    o.worldPos    = mul(unity_ObjectToWorld, v.vertex).xyz;
    return o;
}

Inside frag(), N comes from normalizing i.worldNormal (normalizing (scaling a vector so its length becomes exactly 1) matters because interpolating two unit-length normals across a triangle can produce a slightly-shorter-than-1 result). V comes from normalize(_WorldSpaceCameraPos - i.worldPos) — the camera's world position minus this pixel's world position, pointing back toward the eye. L, for a single directional light, is simply normalize(_WorldSpaceLightPos0.xyz), a Unity built-in variable that already holds the direction toward the scene's main directional light.

2. Faking Light, Take One: Lambertian Diffuse

Think about a matte surface — chalk, a sheet of paper, unpolished wood. Light hitting it scatters roughly evenly in every direction, so from any viewing angle the surface's brightness only depends on one thing: how directly it faces the light. A patch of surface facing straight at the light gets hit by a dense bundle of light rays; the same patch tilted away catches the same rays spread over a wider area, so it looks dimmer. This is called Lambertian reflectance (named after Johann Lambert), and it is the oldest trick for faking light on a surface.

The angle between N and L tells you exactly how "facing" the surface is, and there is a one-line way to get it: the dot product. For two unit-length vectors, dot(N, L) equals the cosine of the angle between them — this is the same dot product from the linear algebra lessons, now doing real work in a shader.

Worked trace: say N = (0, 1, 0) (straight up) and L = (0, 0.707, 0.707) (the light sits about 45 degrees above the horizon). dot(N, L) = (0)(0) + (1)(0.707) + (0)(0.707) = 0.707, and cos(45°) ≈ 0.707 — matching exactly, as it should. Now say the light is almost level with the surface, L = (0, 0.1, 0.995): dot(N, L) = 0.1, so the surface is barely lit, even though the light is still technically above the horizon.

fixed4 _Color;

fixed4 frag(v2f i) : SV_Target
{
    float3 N = normalize(i.worldNormal);
    float3 L = normalize(_WorldSpaceLightPos0.xyz);

    float NdotL = max(0, dot(N, L));
    fixed3 diffuse = _Color.rgb * _LightColor0.rgb * NdotL;

    return fixed4(diffuse, 1);
}

Expected result: on a sphere, the side facing the light is brightest, brightness fades smoothly toward the "terminator" (the line where the surface turns edge-on to the light), and the far side — which never faces the light at all — is completely black. Rotating the camera around the sphere changes nothing, because this formula never uses V at all; a Lambertian surface looks the same brightness from every viewing angle.

3. Faking Shine: Blinn-Phong Specular

Lambertian diffuse alone makes every surface look like chalk — flat and matte. Shiny materials (polished metal, wet surfaces, plastic) also show a bright specular highlight (the blurred, bright reflection of the light source itself). Unlike diffuse light, the highlight's position depends on where the camera is, because you are seeing a rough mirror-image of the light.

The classic (and still very fast) way to fake this is Blinn-Phong shading. Instead of computing the true mirror-reflection direction of L off the surface (which is what the older, more expensive Phong model did), Blinn's trick uses a cheaper stand-in: the half vector H, which sits exactly halfway between L and V. When N points close to H, the surface is near the "sweet spot" where light bounces almost straight from the light into the camera — the highlight.

float3 V = normalize(_WorldSpaceCameraPos - i.worldPos);
float3 H = normalize(L + V);

float NdotH = max(0, dot(N, H));
float specular = pow(NdotH, _Shininess);

pow(NdotH, _Shininess) raises a number between 0 and 1 to a power — the higher the exponent, the faster the value collapses toward 0 as N.H drops even slightly below 1. That is exactly the shape a highlight needs: a small, bright spot that fades out quickly around its edges. _Shininess here is a plain float the artist tunes by hand (typically 8 to 256) — a low value spreads the highlight into a wide, soft glow; a high value squeezes it into a tiny, sharp glint. Hold onto that idea; it comes back with a real physical meaning in Section 7.

4. A Complete Diffuse + Specular Shader

Putting Sections 2 and 3 together, plus a flat ambient term (a constant amount of light added everywhere, standing in for all the indirect bounce light a single directional light ignores), gives the classic lighting model almost every game used before PBR became standard:

Shader "Lesson/07_3_BlinnPhong"
{
    Properties
    {
        _Color      ("Diffuse Color",  Color) = (0.8, 0.8, 0.8, 1)
        _SpecColor  ("Specular Color", Color) = (1, 1, 1, 1)
        _Shininess  ("Shininess", Range(8, 256)) = 64
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" "LightMode"="ForwardBase" }
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"
            #include "Lighting.cginc"

            fixed4 _Color;
            fixed4 _SpecColor;
            float  _Shininess;

            struct appdata { float4 vertex:POSITION; float3 normal:NORMAL; };
            struct v2f
            {
                float4 pos         : SV_POSITION;
                float3 worldNormal : TEXCOORD0;
                float3 worldPos    : TEXCOORD1;
            };

            v2f vert(appdata v)
            {
                v2f o;
                o.pos         = UnityObjectToClipPos(v.vertex);
                o.worldNormal = UnityObjectToWorldNormal(v.normal);
                o.worldPos    = mul(unity_ObjectToWorld, v.vertex).xyz;
                return o;
            }

            fixed4 frag(v2f i) : SV_Target
            {
                float3 N = normalize(i.worldNormal);
                float3 L = normalize(_WorldSpaceLightPos0.xyz);
                float3 V = normalize(_WorldSpaceCameraPos - i.worldPos);
                float3 H = normalize(L + V);

                float NdotL = max(0, dot(N, L));
                float NdotH = max(0, dot(N, H));

                fixed3 ambient  = UNITY_LIGHTMODEL_AMBIENT.rgb * _Color.rgb;
                fixed3 diffuse  = _Color.rgb * _LightColor0.rgb * NdotL;
                fixed3 specular = _SpecColor.rgb * _LightColor0.rgb * pow(NdotH, _Shininess);

                return fixed4(ambient + diffuse + specular, 1);
            }
            ENDCG
        }
    }
}

Expected result: a sphere with a smooth Lambert gradient across most of its surface, plus a small, bright, white-ish highlight near where the light reflects toward the camera. Orbiting the camera around the sphere slides the highlight across the surface — it is chasing V — while the diffuse gradient underneath stays fixed, since it only depends on L. This is the look of "plastic" in almost every 2000s-era game.

5. Why Blinn-Phong Breaks Down

Blinn-Phong shipped in thousands of games for good reason — it is cheap and looks reasonable. But it is a hand-tuned illusion, not a model of how light actually behaves, and that catches up with it in a few specific ways:

• The shininess exponent means nothing physical. There is no way to measure "64" off a real material. Two artists lighting the same "rough concrete" surface will pick different numbers by eye, and neither is more correct than the other.
• It does not conserve energy. Nothing stops diffuse and specular from adding up to more light than the surface received. A surface could reflect 60% of the light as diffuse and, at the peak of its highlight, another 100% as specular — 160% of the incoming light coming back out, which is physically impossible. Under a bright light this often shows up as a blown-out, overexposed-looking highlight.
• No Fresnel effect. Real surfaces — even matte-looking ones — get noticeably more reflective at a shallow, grazing viewing angle (Section 9). Blinn-Phong's highlight strength does not change with viewing angle at all, so materials like water, skin, or car paint look wrong from the side.
• Specular color is a free art choice, disconnected from the base color. An artist picks _SpecColor by hand, separately from _Color. Nothing ties them together the way real materials tie their specular tint to whether they are metal or not (Section 8) — so it is easy to make a material that looks physically wrong without any obvious mistake in the code.
• No awareness of the surrounding environment. A shiny floor should faintly reflect the room around it. Blinn-Phong only reacts to explicit lights placed in the scene — under an HDR sky, in a colorful room, next to a bright wall, it stays exactly the same, which is a dead giveaway that it is fake.

Every one of these problems has the same root cause: Blinn-Phong is a shape that happens to look plausible, not a model grounded in physics. PBR replaces the "shape that looks plausible" with a formula grounded in three physical ideas — energy conservation, the microfacet model, and Fresnel reflectance — plus a workflow that ties a material's parameters together the way real materials actually behave. The rest of this lesson builds each of those pieces.

6. What "Physically Based" Means: Radiance and Energy Conservation

Radiance is the technical name for "how much light energy is arriving at, or leaving, a point, in a specific direction." You do not need the full physics definition — for this lesson, just read it as "brightness, but precise about which direction it is measured in." A PBR shader's whole job is computing outgoing radiance toward the camera, given incoming radiance from a light.

The function that describes how a material redirects that incoming light is called a BRDF (Bidirectional Reflectance Distribution Function — a recipe for "given light coming in from direction L, what fraction of it leaves toward direction V"). Lambert's N.L and Blinn-Phong's pow(N.H, shininess) are both extremely simple BRDFs. PBR does not throw the idea of a BRDF away — it replaces those two ad hoc formulas with ones built to respect a hard physical rule:

Think of it as a budget: if a point receives 100 units of light and the material's specular response sends 90 of them straight back out, at most 10 units are left over for the diffuse bounce — never both 90 and, say, 80. PBR BRDFs bake this budget into the math itself (you will see exactly how in Sections 8 and 10), so a material can never accidentally look brighter than the light hitting it.

7. The Microfacet Model: Millions of Tiny Mirrors

Here is the idea that PBR specular is built on: zoom in far enough on almost any surface — even one that looks perfectly smooth to the eye — and it is not flat at all. It is covered in millions of microscopic bumps, each one too small to see individually, and each one acting like a tiny, perfect mirror. This is the microfacet model, and each of those tiny mirrors is a microfacet.

A single microfacet only reflects light in one exact mirror direction, same as a real mirror. What looks like a soft, spread-out highlight on a "rough" material is really millions of these tiny perfect mirrors, each tilted slightly differently, each bouncing its own ray in its own direction — and your eye (or a pixel on the screen) is averaging all of those tiny reflections together. Roughness is simply a number describing how much those microfacet directions spread out around the average surface normal N.

This single idea explains something Blinn-Phong's exponent could only fake by trial and error: roughness has a direct, physical meaning — it literally is "how scattered are this surface's tiny mirrors" — and one roughness value works correctly no matter which direction the light comes from or where the camera stands, because it describes the surface itself, not a particular lighting setup. Section 10 shows the formula PBR uses to turn "how scattered" into an actual number for the highlight's brightness and shape — a direct replacement for pow(NdotH, _Shininess), driven by something measurable instead of an artist's guess.

8. The Metallic/Roughness Workflow

Almost every modern game engine (Unity's Standard Shader, URP's Lit shader, Unreal's default materials) authors materials using four textures, called the metallic/roughness workflow:

• _Albedo — the base color. For a non-metal (also called a dielectric — any material that is not a bare metal: wood, plastic, skin, cloth, stone) this is the actual diffuse reflectance color, same as _Color in Section 2. For a metal, it is reused for a different purpose, explained below.
• _Metallic — usually close to 0 or close to 1 for any given pixel, since almost nothing in the real world is "40% metal." It shows up as a gradient mainly at material transitions — worn edges of paint on steel, rust patches, dust on a chrome bumper.
• _Roughness — the microfacet spread from Section 7, painted per pixel so a single object can have both a polished center and a scuffed, matte edge.
• Normal map — the same trick from your earlier shader lesson: a texture that stores a slightly tilted replacement normal per pixel (packed into an RGB texture, decoded with UnpackNormal), adding the appearance of fine detail — scratches, fabric weave, pores — without adding a single extra triangle. Every formula in this lesson that uses N should use this per-pixel normal, not the smooth one straight off the mesh.
• Ambient occlusion (AO) map — a grayscale texture marking the crevices, seams, and contact points that stay dim because nearby geometry blocks the surrounding indirect light: the inside of a bolt hole, the gap between two bricks, the crease where a sleeve meets a shoulder. The key rule is that AO multiplies only the ambient / IBL term (Section 11), never the direct light — a deep crack should still catch a direct highlight if a lamp points into it; it just should not receive the general skylight. Baked once from the high-detail model, so the shader gets soft contact shadows for the cost of one texture lookup.

Why does metal need special treatment? A metal's surface electrons absorb incoming light and immediately re-radiate it right at the surface — none of it enters the material and scatters back out the way it does in a dielectric. That means metals have no diffuse term at all: 100% of the light a metal reflects is specular, and that specular reflection is tinted by the metal's own color (gold looks yellow, copper looks orange). Since metals have no diffuse color to store, engines reuse the albedo slot to instead hold the specular tint when _Metallic is 1. A dielectric's specular reflection, by contrast, is almost always a dim, colorless white, regardless of the material's own color — that's why a red plastic ball's highlight is white, not red.

sampler2D _AlbedoMap;
sampler2D _MetallicMap;
sampler2D _RoughnessMap;
sampler2D _BumpMap;

fixed4 frag(v2f i) : SV_Target
{
    fixed3 albedo    = tex2D(_AlbedoMap, i.uv).rgb;
    float  metallic  = tex2D(_MetallicMap, i.uv).r;
    float  roughness = tex2D(_RoughnessMap, i.uv).r;
    float3 tangentNormal = UnpackNormal(tex2D(_BumpMap, i.uv));

    // Combine the per-pixel normal map with the mesh's own
    // tangent-space basis (built the same way your earlier
    // normal-mapping shader did) to get the final world normal.
    float3 N = normalize(mul(tangentNormal, i.tangentToWorld));

    // albedo, metallic, roughness, and N now feed every formula
    // in the rest of this lesson.
    return fixed4(albedo, 1);
}

9. Fresnel: Everything Gets Shinier at Grazing Angles

Look straight down into a still lake and you mostly see through the water to the bottom. Look across the same lake, almost level with the surface, and it turns into a near-perfect mirror reflecting the sky — even though the water itself never changed. This is the Fresnel effect (named after Augustin-Jean Fresnel): every surface, no matter how dull it looks head-on, becomes dramatically more reflective at a shallow, grazing viewing angle.

The reflectance when looking straight at a surface (angle = 0) is called F0 (pronounced "F-zero," short for base reflectance). Dielectrics all cluster around a low F0, roughly 0.02–0.05, regardless of their color — water, glass, plastic, and skin are all close to this range. Metals, on the other hand, have a high F0 equal to their own albedo color, which is exactly the "specular tint" idea from Section 8. Every material's actual reflectance climbs from its F0 up toward nearly 1.0 (100% reflective, like a perfect mirror) as the viewing angle approaches grazing.

The industry-standard way to compute this in a shader is Schlick's approximation — a cheap formula that gets extremely close to the real physics without needing anything exotic:

float3 F_Schlick(float3 F0, float VdotH)
{
    return F0 + (1 - F0) * pow(saturate(1 - VdotH), 5);
}

saturate(x) is HLSL shorthand for clamp(x, 0, 1). VdotH is 1 when V lines up exactly with H (a near-straight-on view) and drops toward 0 as the view becomes grazing, so 1 - VdotH grows toward 1 exactly when the angle gets shallow.

Worked trace for a dielectric with F0 = 0.04: looking straight on, VdotH ≈ 1, so F = 0.04 + 0.96 * (0)^5 = 0.04 — only 4% reflective, matching intuition (you mostly see the material's own diffuse color). Looking at a shallow, grazing angle, VdotH ≈ 0.05, so (1 - 0.05)^5 = 0.95^5 ≈ 0.774, giving F = 0.04 + 0.96 * 0.774 ≈ 0.783 — suddenly 78% reflective. That is the same material, same lighting, same code — only the viewing angle changed, and the surface went from "barely reflective" to "almost a mirror."

10. A Simplified PBR Shader: Putting It Together

Production engines compute specular PBR lighting with a formula called the Cook-Torrance model:

You do not need to derive D and G by hand to understand what they are for, and real projects essentially never hand-roll them — Unity's Standard Shader and URP's Lit shader already implement this exact formula, and you drive it entirely through the Albedo, Metallic, and Smoothness (Smoothness is just 1 - Roughness) fields in the Inspector. What follows is a simplified, hand-written stand-in that captures the same shape using tools you already have from Sections 2–9 — not the exact production formula, but enough to see, and modify, every piece with your own hands:

Shader "Lesson/07_3_SimplifiedPBR"
{
    Properties
    {
        _Albedo    ("Albedo",    Color) = (0.8, 0.8, 0.8, 1)
        _Metallic  ("Metallic",  Range(0, 1))    = 0
        _Roughness ("Roughness", Range(0.02, 1)) = 0.5
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" "LightMode"="ForwardBase" }
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"
            #include "Lighting.cginc"

            fixed4 _Albedo;
            float  _Metallic;
            float  _Roughness;

            struct appdata { float4 vertex:POSITION; float3 normal:NORMAL; };
            struct v2f
            {
                float4 pos         : SV_POSITION;
                float3 worldNormal : TEXCOORD0;
                float3 worldPos    : TEXCOORD1;
            };

            v2f vert(appdata v)
            {
                v2f o;
                o.pos         = UnityObjectToClipPos(v.vertex);
                o.worldNormal = UnityObjectToWorldNormal(v.normal);
                o.worldPos    = mul(unity_ObjectToWorld, v.vertex).xyz;
                return o;
            }

            fixed4 frag(v2f i) : SV_Target
            {
                float3 N = normalize(i.worldNormal);
                float3 L = normalize(_WorldSpaceLightPos0.xyz);
                float3 V = normalize(_WorldSpaceCameraPos - i.worldPos);
                float3 H = normalize(L + V);

                float NdotL = saturate(dot(N, L));
                float NdotH = saturate(dot(N, H));
                float VdotH = saturate(dot(V, H));

                // Non-metals start near 4% reflective and colorless;
                // metals reflect their own albedo color instead (Section 9).
                float3 F0 = lerp(float3(0.04, 0.04, 0.04), _Albedo.rgb, _Metallic);
                float3 fresnel = F0 + (1 - F0) * pow(1 - VdotH, 5);

                // Stand-in for the D * G terms: rough surfaces spread the
                // highlight into a wide, dim hump; smooth surfaces squeeze
                // it into a tight, bright spot (Section 7's microfacet idea).
                float shininess = lerp(512.0, 2.0, _Roughness);
                float specular  = pow(NdotH, shininess) * NdotL;

                // Metals have (almost) no diffuse bounce (Section 8), so
                // scale diffuse down to zero as metallic goes to 1 -- this
                // is the energy-conservation budget from Section 6, made real.
                float3 diffuse = _Albedo.rgb * (1 - _Metallic) * NdotL;

                float3 color = (diffuse + specular * fresnel) * _LightColor0.rgb;
                return fixed4(color, 1);
            }
            ENDCG
        }
    }
}

Expected result: set _Metallic = 1 and _Roughness = 0.05 on a sphere, and it renders as a near-mirror with almost no visible flat base color, just a tight, bright, albedo-tinted highlight — chrome. Set _Metallic = 0 and _Roughness = 0.9 on the same mesh, and it renders as a soft, matte, mostly-diffuse ball with only a faint, broad sheen — rubber. Notice what did not happen: no _SpecColor to hand-tune, no per-material shininess guesswork. Three sliders, each with a real physical meaning, produce two convincingly different materials.

11. Image-Based Lighting: Ambient From an Environment Map

Every shader so far only reacts to one directional light. Real scenes are also lit by the sky, nearby walls, and bounced light from everything around an object — and a shiny surface should faintly reflect all of that, not just show flat black wherever no direct light lands. This is the problem image-based lighting (IBL) solves.

An environment map (usually a cubemap — six square images stitched into a box around a point, together covering a full 360-degree view) captures what the surroundings look like from roughly the center of a scene, baked once ahead of time. In Unity this is a Reflection Probe — an object you place in the scene that captures a cubemap of its surroundings, either once ("baked") or continuously ("realtime"), and hands it to any nearby shader that asks for it.

IBL actually supplies two separate things, replacing the single flat UNITY_LIGHTMODEL_AMBIENT constant from Section 4 with something that actually looks like the room:

• Diffuse IBL — a heavily pre-blurred version of the environment map (called an irradiance map), sampled using N. Since diffuse light scatters in every direction anyway, only a rough, blurry average of "what color is generally around this surface" is needed.
• Specular IBL — a prefiltered environment map: the same cubemap saved at multiple blur levels (mip levels, the same mipmap idea used to avoid texture aliasing at a distance, reused here for a different purpose), sampled using the reflection vector R = reflect(-V, N). A smooth, low-roughness surface samples a nearly unblurred mip for a crisp reflection; a rough surface samples a heavily blurred mip, spreading the reflection out — exactly the same smooth-vs-rough logic from Section 7's microfacets, just applied to a picture of the room instead of a single light.
• The BRDF LUT — the third piece that makes specular IBL affordable. Epic's split-sum approximation breaks the specular-IBL integral into two independent lookups multiplied together: (the prefiltered environment color above) × (a tiny 2D lookup texture called the BRDF LUT). That LUT is indexed by (N·V, roughness) and stores a scale and bias for F0 — it has pre-integrated the Fresnel and geometry (G) terms over the whole hemisphere so the shader doesn't have to. It is generated once, is identical for every scene and every material, and turns an otherwise expensive integral into one extra texture fetch: iblSpecular = prefiltered * (F0 * scale + bias).

// Conceptual only -- Unity's built-in macros (UNITY_SAMPLE_TEXCUBE_LOD
// and friends) handle the real version of this for you.
float3 R   = reflect(-V, N);
float  mip = _Roughness * MAX_REFLECTION_MIP;

// Diffuse IBL: blurry average of the surroundings, tinted by albedo.
float3 iblDiffuse = SampleIrradianceMap(N) * albedo * (1 - metallic);

// Specular IBL via the split-sum: prefiltered color x BRDF LUT.
float3 prefiltered = SampleEnvironmentMap(R, mip);
float2 envBRDF     = SampleBRDFLUT(float2(NdotV, _Roughness)).rg; // (scale, bias)
float3 iblSpecular = prefiltered * (F0 * envBRDF.x + envBRDF.y);

// Ambient occlusion dims the AMBIENT term only -- never direct light.
float3 ambient = (iblDiffuse + iblSpecular) * ao;

Expected result: place a _Metallic = 1, _Roughness ≈ 0.1 sphere in a scene with a Reflection Probe, with no direct light hitting part of it at all — instead of going pure black in the unlit area, that side of the sphere shows a blurry, mirror-like reflection of the sky or room around it, exactly like a real chrome ball would.

12. Why PBR Looks Consistent Under Any Lighting

Put the pieces from this lesson together and a pattern shows up: nothing about _Albedo, _Metallic, or _Roughness mentions a specific light, a specific scene, or a specific engine. They describe the material itself — what a real, physical version of this surface would do to any light that hits it. Compare that to Blinn-Phong's _Shininess and _SpecColor, which were tuned by eye against one particular lighting setup and often looked wrong the moment you moved the object into a different level with different lights.

That is the actual payoff of everything in this lesson: because the BRDF respects energy conservation (Section 6), because roughness is grounded in an actual physical model of the surface (Section 7) instead of an arbitrary exponent, because Fresnel is always active (Section 9), and because ambient light comes from a real picture of the surroundings instead of one flat constant (Section 11) — the exact same chrome material looks correct under a bright noon sun, inside a dim torch-lit cave, and next to a colored neon sign, with zero per-scene retuning. Light the scene once; every correctly authored PBR material just responds.

There is a practical bonus too: because albedo, metallic, and roughness are standardized, physically-grounded quantities rather than one engine's private magic numbers, the same texture set exported from a tool like Substance Painter looks correct — not identical, but correct — whether it lands in Unity, Unreal, or Blender. A Blinn-Phong shininess value of "64" never meant anything outside the one shader it was written for.

13. The One Equation Everything So Far Approximates: The Rendering Equation

Every model in this lesson — Lambert, Blinn-Phong, Cook-Torrance, IBL — is a different shortcut for the same underlying formula. In 1986 Jim Kajiya wrote it down in a single line, and all of real-time lighting is the craft of approximating it cheaply enough to run 60 times a second. In plain words:

Read it left to right: the light leaving a point toward your eye (Lo) is whatever the surface glows on its own (Le — zero for everything except lamps, screens, lava, and other emissive materials) plus the total of every ray arriving from the hemisphere of directions above the surface, each ray multiplied by two things: the BRDF (what fraction of light from that incoming direction bounces toward the camera — Section 6) and N·L (the same Lambert cosine from Section 2, because light arriving at a grazing angle is spread thinner). The ∫ ("integral") just means "add it up over every incoming direction" — the continuous version of a loop over infinitely many light directions.

Nothing in this lesson escaped this equation; each technique is just a way to make the "add up over every direction" part affordable:

• A handful of point or directional lights (Sections 2–10): the integral collapses into a plain sum. Each light is a single direction, so instead of integrating over a whole hemisphere you add one BRDF * lightColor * NdotL term per light. That is literally what the shaders above do inside frag().
• Image-based lighting (Section 11): light arrives from every direction (the whole sky and room), so the integral does not collapse — instead it is precomputed once and baked into the irradiance and prefiltered maps, then looked up per pixel.
• The emitted term Le is where an emissive map plugs in: a texture added straight onto the output so a material can glow (neon, screens, sci-fi panels) with no light in the scene at all.

You will almost never type this equation into a shader. Its value is as a map: any time a lighting result looks wrong, the cause is a poor approximation of one of its three pieces — the BRDF (wrong D/F/G, Section 14), the incoming light (missing IBL or bounce light, Section 11), or the cosine and energy bookkeeping (Section 6).

14. Inside Cook-Torrance: The D, F, G Terms in Full

Section 10 used pow(NdotH, shininess) as a stand-in and pointed at the real formula. Here is the actual Cook-Torrance BRDF that Unity's Standard shader, URP/HDRP Lit, and Unreal all use, with every term written out as valid HLSL you could paste into the shaders from earlier sections. There are exactly three functions — one each for D, F, and G — plus the assembly.

D — the GGX / Trowbridge-Reitz normal distribution. This is Section 7's "how scattered are the tiny mirrors" turned into a number: given a roughness, what fraction of the microfacets are tilted to point exactly at H (and so bounce the light straight at your eye)?

// UNITY_PI is defined by UnityCG.cginc; use 3.14159265 elsewhere.
float D_GGX(float NdotH, float roughness)
{
    float a  = roughness * roughness;      // alpha = roughness^2 (Disney remap)
    float a2 = a * a;
    float d  = (NdotH * NdotH) * (a2 - 1.0) + 1.0;
    return a2 / (UNITY_PI * d * d);
}

Worked numbers (roughness 0.5, so α = 0.25): at the exact center of the highlight NdotH = 1, and D_GGX(1, 0.5) = 5.09. Tilt the surface so NdotH = 0.9 and it collapses to 0.34 — a 15× drop for a tiny change in angle, and that steep peak is what your eye reads as a highlight. Now make it glossy (roughness 0.1): D_GGX(1, 0.1) = 3183, but D_GGX(0.99, 0.1) = 0.08. A near-mirror concentrates almost all its reflected energy into a pinpoint — a towering, razor-thin spike — which is exactly why chrome shows a tiny blinding glint instead of a soft glow.

G — the Smith geometry (shadowing-masking) term. At grazing angles microfacets block each other: some sit in the shadow of a neighbor (light can't reach them), some are masked (their reflection can't reach the eye). G is the surviving fraction. The standard real-time choice is Schlick-GGX applied twice via Smith's method — once for the light direction, once for the view:

float G_SchlickGGX(float NdotX, float k)
{
    return NdotX / (NdotX * (1.0 - k) + k);
}

float G_Smith(float NdotV, float NdotL, float roughness)
{
    float r = roughness + 1.0;
    float k = (r * r) / 8.0;               // direct-light remap; use k = a*a/2 for IBL
    return G_SchlickGGX(NdotV, k) * G_SchlickGGX(NdotL, k);
}

Worked numbers (roughness 0.5): looking fairly head-on, NdotV = NdotL = 0.5 gives G = 0.61 — most microfacets are visible. At a grazing NdotV = NdotL = 0.1, G = 0.08 — nearly all of them shadow each other, so G darkens the specular right at the silhouette. This is the term that stops Fresnel brightening (Section 9) from making edges reflect impossibly hard: Fresnel pushes reflectance up at grazing angles while G pulls it back down, and together they match what real measured surfaces do.

F — Fresnel is exactly F_Schlick(F0, VdotH) from Section 9, unchanged. Now assemble all three into the full Cook-Torrance specular term and split the leftover energy into diffuse — this is the energy budget from Section 6 made literal:

float3 F0 = lerp(float3(0.04, 0.04, 0.04), albedo, metallic);

float  D = D_GGX(NdotH, roughness);
float  G = G_Smith(NdotV, NdotL, roughness);
float3 F = F0 + (1.0 - F0) * pow(1.0 - VdotH, 5.0);

// Cook-Torrance specular = D * F * G / (4 (N.V)(N.L)).
// The + 1e-4 stops a divide-by-zero firefly when N.V or N.L hits 0 at the edge.
float3 specular = (D * G * F) / (4.0 * NdotV * NdotL + 1e-4);

// Energy conservation: kS is the specular fraction (= Fresnel), so at most
// (1 - kS) is left for diffuse -- and metals get no diffuse at all.
float3 kS = F;
float3 kD = (1.0 - kS) * (1.0 - metallic);
float3 diffuse = kD * albedo / UNITY_PI;

float3 Lo = (diffuse + specular) * _LightColor0.rgb * NdotL;

Two details trip people up. First, the / UNITY_PI on the diffuse term is physically correct — the Lambert BRDF is albedo / π, not albedo — but many game shaders quietly drop it and fold the missing π into the light's intensity, which is why the simplified shader in Section 10 left it out. Second, kD = (1 - F)(1 - metallic) is the real reason those earlier shaders multiplied diffuse by (1 - metallic): it is the energy budget. Whatever the specular Fresnel reflects (kS) is subtracted from the diffuse (kD), so the two can never sum past the incoming light no matter what sliders an artist sets.

15. Working in Linear Space: sRGB, Gamma, and Why the Math Demands It

Section 6's tip said the energy math "only comes out correct if colors are stored as linear light values." Here is what that actually means, and why skipping it silently ruins every formula above.

A monitor does not display brightness linearly. Feed it the value 0.5 and it emits roughly 22% of full brightness, not 50% — screens follow an sRGB curve, close to a gamma of 2.2. To compensate, image files (PNGs, JPEGs, the albedo textures an artist paints) are sRGB-encoded: their stored numbers are pre-bent so that after the monitor's curve they look right. That encoding is baked into essentially every color image you have ever seen.

Here is the problem: light adds up linearly, but sRGB values do not. Every + in every shader above — two lights summing, diffuse plus specular, ambient plus direct — is real physical light energy being added, and that addition is only correct on linear numbers. Add two sRGB-encoded values directly and the result means nothing physical (it lands too dark). So the pipeline must be:

Which textures get decoded, and which must not — this is the part people get wrong. A texture is decoded from sRGB only if it stores a color a human picked by eye. A texture that stores numbers must be left linear:

• Decode (mark as sRGB): albedo / base color, and emissive — these are colors.
• Do NOT decode (mark as linear — in Unity, uncheck "sRGB (Color Texture)"): normal maps (they store XYZ directions), roughness, metallic, ambient occlusion, height, and any mask. Pushing a normal map through the 2.2 decode skews every direction it stores and tilts your lighting subtly but everywhere.

The true sRGB curve is a piecewise function with a small linear segment near black; pow(x, 2.2) is the standard approximation and is what most explanations (this one included) use. The hardware sRGB path uses the exact curve, so prefer flipping the texture's sRGB checkbox over doing pow by hand.

16. HDR and Tonemapping: Fitting Bright Light Into a 0–1 Screen

Real light has no upper limit. The sun is thousands of times brighter than a sheet of paper; a bright window beside a dim wall can differ by 100×. Once you sum several lights plus specular plus IBL, the linear result routinely blows past 1.0 — a chrome glint might compute to 40.0. But a screen channel maxes out at 1.0. Naively clamping everything above 1.0 to pure white throws away all that range and gives you flat, plasticky blowouts (the same overexposed look Section 5 blamed on Blinn-Phong).

The fix has two parts. First, HDR (High Dynamic Range) rendering: do all the lighting into a floating-point render target that can hold values far above 1.0, instead of an 8-bit one that clamps. Second, tonemapping: a curve applied at the very end that gently compresses the open-ended [0, ∞) range down into the displayable [0, 1], keeping detail in both shadows and highlights the way real film does. The two curves you will meet most often:

// Reinhard -- the simplest tonemap. Cheap, but desaturates and flattens highlights.
float3 Reinhard(float3 c)
{
    return c / (1.0 + c);
}

// ACES filmic (Narkowicz 2015 fit) -- the modern default in Unity and Unreal.
// Deeper contrast, filmic highlight rolloff, keeps color better than Reinhard.
float3 ACESFilmic(float3 x)
{
    const float a = 2.51, b = 0.03, c = 2.43, d = 0.59, e = 0.14;
    return saturate((x * (a * x + b)) / (x * (c * x + d) + e));
}

Worked numbers, feeding the same HDR inputs through both curves:

You usually also apply an exposure multiply before the tonemap (color *= exposure;) — the digital version of a camera's exposure dial, letting you brighten a dim night scene or pull back a blown-out desert without touching a single light. The complete tail of the frame is therefore: linear HDR lighting → multiply by exposure → tonemap → encode to sRGB (Section 15) → display. Get the order wrong — tonemapping after the sRGB encode, say — and the curve operates on the wrong numbers and the whole image shifts.

17. Common Lighting Artifacts and How to Fix Them

Correct-looking PBR math still produces recognizable, named failures on real hardware. Four you will hit, each with its cause and its standard fix:

Banding. A smooth, dim gradient — a sunset sky, a soft IBL falloff, a subtle spotlight pool — shows visible stair-step stripes instead of a clean fade. Cause: an 8-bit screen channel has only 256 levels, and across a wide gentle gradient the jump between two adjacent levels grows big enough for your eye to catch as a hard edge. Fix: dithering — add a tiny sub-pixel noise (about ±1/255) just before the 8-bit quantization, trading one visible hard edge for invisible fine noise the eye happily averages away.

// Add just before writing the final 8-bit color. screenPos = pixel coordinates.
float dither = frac(sin(dot(screenPos.xy, float2(12.9898, 78.233))) * 43758.5453);
color.rgb += (dither - 0.5) / 255.0;

Specular aliasing (shimmer / crawling). A surface with fine normal-map detail, or a glossy object seen at a distance, sparkles and crawls with flickering white dots as the camera moves. Cause: one pixel covers many microfacet orientations, but the shader samples a single normal and a single (low) roughness — it undersamples that razor-thin GGX spike from Section 14, so the highlight pops in and out between frames. Fix: raise roughness wherever the normals vary faster than the pixels can resolve. Mip-mapped normal maps feed a normal-variance-to-roughness step (Toksvig, or the "Specular AA" toggle in Unity HDRP / Unreal) that automatically roughens minified surfaces; a minimum-roughness clamp and temporal anti-aliasing (TAA) help too. The one-line intuition: if you can't resolve the detail, blur the highlight instead of letting it flicker.

Wrong gamma. The whole scene looks murky and too dark, midtones crushed and muddy — or lights that should sum to "twice as bright" barely change anything. Cause: lighting math done on sRGB values, or the final linear→sRGB encode skipped (Section 15). A linear 0.25 written straight to an sRGB screen displays as pow(0.25, 2.2) ≈ 0.047 — about five times too dark. Fix: Color Space = Linear, color textures flagged sRGB, data textures flagged linear. This is the single most common reason a from-scratch shader "looks off" in a way you can't quite name.

Fireflies. Isolated, blindingly bright single pixels that flicker along edges and on glossy surfaces. Cause: the 4·(N·V)·(N·L) denominator in the Cook-Torrance specular (Section 14) approaching zero at grazing angles, plus very bright HDR values landing on a lone sample. Fix: the + 1e-4 denominator clamp from Section 14, clamping maximum luminance before it enters any bloom/blur pass, and TAA to average across frames.

18. Glossary

• PBR (Physically Based Rendering) — writing lighting shaders whose math follows real physics closely enough that a material looks correct under any lighting setup.
• Normal (N) — a unit-length vector pointing straight out of a surface, perpendicular to it.
• Light direction (L) — the direction from a surface point toward the light.
• View direction (V) — the direction from a surface point toward the camera.
• Half vector (H) — the vector exactly halfway between L and V, used by Blinn-Phong as a cheap stand-in for the true mirror-reflection direction.
• Dot product — for two unit-length vectors, equals the cosine of the angle between them; used throughout lighting math (N.L, N.H, V.H).
• Lambertian reflectance — the model where a matte surface's brightness depends only on the angle between N and L, not on the viewing angle.
• Specular highlight — the bright, blurred reflection of a light source itself, visible on shiny surfaces.
• Blinn-Phong — the classic, non-physically-based lighting model combining Lambertian diffuse with a pow(N.H, shininess) specular highlight.
• Energy conservation — the physical rule that a surface can never reflect more light energy than it received.
• Radiance — how much light energy is arriving at, or leaving, a point, in a specific direction.
• BRDF (Bidirectional Reflectance Distribution Function) — a function describing what fraction of incoming light from one direction leaves toward another direction.
• Microfacet model — the idea that any surface is covered in millions of microscopic, perfectly mirror-like bumps (microfacets), and visible roughness is really the statistical spread of their tiny reflections.
• Roughness — how much a surface's microfacet directions spread out around the average surface normal; low roughness = tight, sharp highlights, high roughness = broad, soft ones.
• Metallic/roughness workflow — the standard PBR material authoring approach using albedo, metallic, roughness, and normal map textures.
• Albedo — the base color texture; the diffuse reflectance color for non-metals, or the specular tint for metals.
• Metallic — a 0–1 value (usually near 0 or near 1) marking whether a pixel is a bare metal or a dielectric (non-metal).
• Dielectric — any non-metal material (wood, plastic, skin, stone, and so on).
• Fresnel effect — the increase in a surface's reflectivity as the viewing angle becomes shallower (more grazing).
• F0 (base reflectance) — a surface's reflectance when viewed straight-on (zero degrees).
• Schlick's approximation — a cheap, widely used formula for computing the Fresnel effect in real-time shaders.
• Cook-Torrance model — the standard PBR specular formula, combining a normal distribution term (D), Fresnel (F), and a geometry term (G).
• GGX (Trowbridge-Reitz) — the most commonly used real-time normal distribution function (D term), shaped to match measured real-world materials.
• Image-based lighting (IBL) — using a captured image of a scene's surroundings (an environment map) as a source of ambient light and reflections.
• Environment map / cubemap — six images stitched into a box, together representing a full 360-degree view from one point.
• Reflection Probe — a Unity object that captures a cubemap of its surroundings for nearby shaders to sample.
• Irradiance map — a heavily blurred environment map used for diffuse ambient lighting.
• Prefiltered environment map — an environment map stored at multiple blur (mip) levels, so roughness can select how blurry a specular reflection looks.
• Rendering equation — the master formula (Kajiya, 1986): outgoing light = emitted light + the integral over all incoming directions of (incoming light × BRDF × cos θ). Every technique in this lesson is an approximation of it.
• Emissive — a material's self-emitted light (the Le term of the rendering equation); added straight to the output via an emissive map so a surface glows without any scene light.
• Normal distribution function (D) — the Cook-Torrance term giving the fraction of microfacets aligned with H; GGX/Trowbridge-Reitz is the standard choice, D = α² / (π ((N·H)²(α²−1)+1)²) with α = roughness².
• Geometry / shadowing-masking term (G) — the Cook-Torrance term for microfacets blocking each other's light at grazing angles; commonly Smith's method with Schlick-GGX.
• kS / kD — the specular and diffuse energy fractions in an energy-conserving BRDF: kS = Fresnel, kD = (1 − kS)(1 − metallic). They sum to at most 1.
• Linear color space — storing/processing color as actual light energy (not gamma-encoded), which is the only space in which lighting math adds up correctly.
• sRGB / gamma — the ~2.2 encoding curve that display images use; decode to linear with pow(c, 2.2), encode back with pow(c, 1/2.2).
• HDR (High Dynamic Range) — rendering into a floating-point target that can hold light values far above 1.0 instead of clamping them.
• Tonemapping — a curve that compresses open-ended HDR light down into the displayable [0, 1] range while preserving shadow and highlight detail.
• Reinhard — the simplest tonemap, c / (1 + c); cheap but desaturates and flattens highlights.
• ACES (filmic) — the modern default tonemap; filmic contrast and highlight rolloff, keeps color better than Reinhard.
• Exposure — a multiply applied to HDR color before tonemapping, the digital equivalent of a camera's exposure setting.
• Split-sum approximation / BRDF LUT — Epic's trick for real-time specular IBL: prefiltered environment color × a small 2D lookup texture (indexed by N·V and roughness) that pre-integrates the Fresnel and geometry terms.
• Ambient occlusion (AO) map — a grayscale texture darkening crevices and contact points; multiplies only the ambient/IBL term, never direct light.
• Banding — visible stair-step stripes in a smooth dim gradient, caused by only 256 levels per 8-bit channel; fixed with dithering.
• Dithering — adding tiny sub-pixel noise before 8-bit quantization to hide banding.
• Specular aliasing — flickering/crawling highlights when a pixel undersamples fine normal detail or a tight highlight; fixed by raising roughness on minified surfaces (Toksvig / specular AA) and TAA.
• Fireflies — isolated blindingly bright flickering pixels, often from the Cook-Torrance denominator hitting zero at grazing angles; fixed with a small denominator epsilon and luminance clamping.

19. Exercises

fixed4 _Color;

fixed4 frag(v2f i) : SV_Target
{
    float3 N = normalize(i.worldNormal);
    float3 L = normalize(_WorldSpaceLightPos0.xyz);

    float NdotL = max(0, dot(N, L));
    fixed3 diffuse = _Color.rgb * _LightColor0.rgb * NdotL;

    return fixed4(diffuse, 1);
}

fixed4 _Color;
float  _Shininess;

fixed4 frag(v2f i) : SV_Target
{
    float3 N = normalize(i.worldNormal);
    float3 L = normalize(_WorldSpaceLightPos0.xyz);
    float3 V = normalize(_WorldSpaceCameraPos - i.worldPos);
    float3 H = normalize(L + V);

    float NdotL = max(0, dot(N, L));
    float NdotH = max(0, dot(N, H));

    fixed3 diffuse  = _Color.rgb * _LightColor0.rgb * NdotL;
    fixed3 specular = _Color.rgb * _LightColor0.rgb * pow(NdotH, _Shininess);

    return fixed4(diffuse + specular, 1);
}

fixed4 frag(v2f i) : SV_Target
{
    float3 N = normalize(i.worldNormal);
    float3 L = normalize(_WorldSpaceLightPos0.xyz);
    float3 V = normalize(_WorldSpaceCameraPos - i.worldPos);
    float3 H = normalize(L + V);

    float NdotL = saturate(dot(N, L));
    float NdotH = saturate(dot(N, H));
    float VdotH = saturate(dot(V, H));

    float3 F0 = lerp(float3(0.04, 0.04, 0.04), _Albedo.rgb, _Metallic);
    float3 fresnel = F0 + (1 - F0) * pow(1 - VdotH, 5);

    float shininess = lerp(512.0, 2.0, _Roughness);
    float specular  = pow(NdotH, shininess) * NdotL;

    float3 diffuse = _Albedo.rgb * NdotL;
    float3 color = (diffuse + specular * fresnel) * _LightColor0.rgb;
    return fixed4(color, 1);
}

float3 diffuse = _Albedo.rgb * NdotL;

float3 diffuse = _Albedo.rgb * (1 - _Metallic) * NdotL;

float  D = D_GGX(NdotH, roughness);
float  G = G_Smith(NdotV, NdotL, roughness);
float3 F = F_Schlick(F0, VdotH);

// (a) specular = D * F * G / (4 (N.V)(N.L)); +1e-4 guards the divide.
float3 specular = (D * G * F) / (4.0 * NdotV * NdotL + 1e-4);

// (b) energy split: kS is the specular fraction, kD is what's left,
//     and metals get no diffuse at all.
float3 kS = F;
float3 kD = (1.0 - kS) * (1.0 - metallic);
float3 diffuse = kD * albedo / UNITY_PI;

// (c) combine, apply the light color and the Lambert cosine.
float3 Lo = (diffuse + specular) * _LightColor0.rgb * NdotL;