💡 Lesson 8.1: URP Lighting: Real-time & Baked

Why Lighting Is a Budget

Every light in a scene is a promise your GPU has to keep, sixty times a second. A real-time light recomputes how it strikes every surface, every frame — cheap for one directional sun, expensive for twenty flickering torches. That's the tension the whole rest of this module dances around: how good can it look versus how much can we afford.

Unity gives you two ways to pay. You can pay at runtime (real-time lighting — flexible, dynamic, costs frame time) or you can pay once, ahead of time (baked lighting — the result is precomputed into a texture, nearly free at runtime, but frozen). Most real games mix both. Learning to choose is the skill.

The Four Light Types

Add a light with GameObject ▸ Light ▸ …. Each type describes a different real-world source:

• Directional — parallel rays from infinitely far away, like the sun. Position doesn't matter, only rotation. Every new scene ships with one. Use it as your key light / sun.
• Point — radiates in all directions from a single point, fading with distance (the Range). Think a bare bulb, a torch, a campfire.
• Spot — a cone of light from a point in one direction, with a Spot Angle. Think a flashlight, a stage spotlight, headlights.
• Area — light emitted from a rectangle or disc surface, giving soft, wrapping illumination. Area lights are Baked-only — they don't work in real-time — so they're reserved for lightmapping.

Reading the Light Component

Select a light and its Light component appears in the Inspector. In URP this is where you set the type, how it's computed, how bright it is, and whether it casts shadows. Here is that component, rebuilt exactly as it appears for a Point light set to Mixed mode:

💡 Why a diagram and not a screenshot? The Inspector is drawn with Unity's UI toolkit, which doesn't screenshot cleanly. As in Lesson 1.2, these panels are rebuilt precisely from the real component — every field and value matches what you'll see.

Light Mode: Realtime, Mixed, Baked

The Mode dropdown is the field that decides your whole budget. It has three values:

• Realtime — recomputed every frame. Can move, change colour, turn on/off at runtime. Casts real-time shadows on everything. Costs frame time. Use for the sun, a swinging lamp, a muzzle flash.
• Baked — computed once by the lightmapper and stored in a texture. Free at runtime, includes gorgeous indirect bounce, but cannot move or change and only affects objects marked Static. Use for fixed environment lights.
• Mixed — the best of both. It bakes indirect light onto static geometry and still casts real-time direct shadows for moving objects. This is the usual choice for a scene's main sun.

Here's how the three modes split the work:

Figure 2: The three light modes and what each one actually computes.

The URP Lit Shader

Light doesn't show up on its own — it has to land on a material, and the material's shader decides how that light becomes colour. In URP, the default workhorse is the Universal Render Pipeline / Lit shader, a physically based (PBR) shader. When you create a material (Assets ▸ Create ▸ Material) in a URP project, it uses Lit automatically.

Its key inputs:

• Base Map — the albedo (surface colour / texture).
• Metallic & Smoothness — how metal-like and how glossy the surface is. These drive how sharply it reflects light.
• Normal Map — fakes surface bumps by perturbing how light reflects.
• Emission — makes the surface emit light (glow). With baking on, emissive materials can even contribute GI.

Conceptually, for every pixel the Lit shader combines the surface properties above with the incoming light to produce the final shaded colour:

// Pseudocode for what the Lit shader does per pixel (not code you write)
finalColor = BaseColor
           * (DirectLight  + IndirectLight/GI)   // how much light hits it
           + Specular(Metallic, Smoothness)       // shiny highlights
           + Emission;                            // its own glow

You rarely touch the Lit shader's math directly — but in Lesson 8.3 you'll build your own shader in Shader Graph, and knowing that a shader's job is "turn surface + light into a pixel colour" is exactly the mental model you'll need.

Ambient & Skybox Light

Notice that in a normal scene the shadowed side of an object isn't pure black — it's a dim version of the sky. That fill comes from ambient lighting, configured in Window ▸ Rendering ▸ Lighting ▸ Environment.

The default Ambient Source is Skybox: Unity samples the skybox material and uses it as soft light coming from all directions. That's why a scene with the default blue-sky skybox has slightly blue shadows. You can also set a flat ambient Color or a three-band Gradient (sky / equator / ground) for stylized looks.

The Skybox Material field (also under Environment) sets what the camera sees in the distance and, by extension, the ambient tint. Swap it for a sunset skybox and your whole scene warms up for free.

Bake or Real-time?

Here's the decision that separates a smooth-running scene from a stuttering one. Ask two questions about each light: does it need to move or change? and what does it light?

Figure 3: A practical realtime-vs-baked decision flow for any light.

Rules of thumb that hold up in production:

• The sun: almost always Mixed — you want baked bounce on the world but crisp real-time shadows under your moving character.
• Static decorative lights (wall sconces, ceiling lights in a fixed room): Baked. They're the cheapest beautiful light you'll ever get.
• Anything dynamic (a lamp you can shoot out, a car headlight, a spell effect): Realtime.
• Keep the number of real-time lights hitting any one object small. On mobile especially, per-pixel real-time lights are the classic frame-rate killer.

💡 The mixed strategy in one line: bake the world, run the sun, probe the movers. That single sentence describes how most 3D games you've played are lit — and it's exactly what Lesson 8.2 sets up.

Hands-on Challenge

Summary

🚀 What's Next?

You now know which lights to bake — next you'll actually bake them. In Lesson 8.2: Lightmapping & Light Probes we mark objects Static, drive the Lighting window, generate lightmaps, and drop Light Probes so your moving characters finally pick up all that baked light.