✨ Lesson 11.4: Polishing a 2D Scene (Mini-Project)

The Goal: From Flat to Atmospheric

Your Module 10 platformer works — the hero runs, jumps, and collides with a tilemap. But it probably looks flat: a single background, even lighting, no sense of depth or mood. Polish is the art of adding a handful of cheap, high-impact touches that make a scene feel like a place.

We'll assemble it in layers, back to front: a parallax sky, a lit tilemap world, the animated hero, particle atmosphere, and a post-processing grade over the whole thing. Here's how those layers stack:

Parallax Backgrounds

Parallax is the effect where distant things appear to move slower than close things — look out a moving car window and the far hills crawl while the roadside blurs past. In 2D you fake it by putting each background layer on its own object and scrolling it a fraction of the camera's movement.

Set up several layers (sky, hills, trees) on separate sorting layers, then drive each with a small script. Using the new Input System-driven camera from earlier modules, the parallax reads the camera's position each frame:

using UnityEngine;

// Attach to each background layer. Lower parallaxFactor = further away = slower.
public class ParallaxLayer : MonoBehaviour
{
    [SerializeField, Range(0f, 1f)] float parallaxFactor = 0.5f;

    Transform cam;
    Vector3 previousCamPos;

    void Start()
    {
        cam = Camera.main.transform;
        previousCamPos = cam.position;
    }

    void LateUpdate()
    {
        // how far the camera moved since last frame
        Vector3 delta = cam.position - previousCamPos;

        // move this layer a fraction of that — nearer layers use a bigger factor
        transform.position += new Vector3(delta.x * parallaxFactor, delta.y * parallaxFactor, 0f);

        previousCamPos = cam.position;
    }
}

Give the sky a parallaxFactor near 0.1, the hills ~0.4, the tree line ~0.7, and leave the gameplay layer at 1 (it moves with the world). Run in LateUpdate so the layers move after the camera has finished following the player — otherwise you get jitter.

A Lit Tilemap Scene

Your Module 10 platformer already uses a Tilemap for the ground. To make it respond to your Lesson 11.3 lights, its tiles need to render lit: assign a material using the Sprite-Lit-Default shader to the Tilemap Renderer (or ensure the tile sprites use a lit material). Now your Global and Spot lights fall on the terrain, not just the character.

• Drop the animated hero (from Lessons 11.1–11.2) into the scene on the gameplay sorting layer.
• Add a Global Light 2D at low intensity for a night mood, plus a warm Spot/Point light following the hero as a lantern.
• Give a few foreground tiles or pillars a Shadow Caster 2D so the lantern throws shadows across the ground.

Sorting layers matter here: background parallax layers behind the tilemap, the tilemap and hero in the middle, and any foreground silhouette layer in front. Lights can target specific sorting layers if you want the background unlit and only the play area lit.

💡 Callback: the hero's Animator is the same state machine from Module 1 and Lesson 11.1 — Speed drives Idle ⇄ Run, a Jump trigger fires the jump. Polishing the scene doesn't touch that logic; you're dressing the stage the character already performs on.

Particles for Life

A still scene feels dead; a little constant motion sells "living world." Unity's Particle System (GameObject ▸ Effects ▸ Particle System) is perfect for cheap atmosphere:

• Floating motes / dust — a wide emitter, tiny slow particles drifting upward, low emission rate. Instant "dusty cave" or "magical forest."
• Landing dust — a short burst emitted from the hero's feet when they land (trigger it from your landing code).
• Sparks / embers — small additive particles near torches, glowing because their material uses an additive blend.

Keep counts low — a few dozen particles read as atmosphere; thousands tank performance (a topic for Module 12). Set the Particle System's Renderer ▸ Material to a lit or additive sprite material so it matches your lighting.

Post-Processing

Post-processing grades the entire rendered image after everything is drawn — the final layer of polish. In URP it's driven by a Volume. Add GameObject ▸ Volume ▸ Global Volume, create a new Volume Profile, and add overrides:

• Bloom — makes bright areas glow softly. This is what makes your lanterns, sparks, and glowing gems feel luminous. The single highest-impact effect for a lit 2D scene.
• Vignette — darkens the screen edges, focusing the eye on the center and adding drama.
• Color Adjustments — shift the whole scene's temperature and contrast. Cool it blue for night, warm it amber for sunset.

Make sure your Camera has Post Processing ticked in its Inspector, or the Volume does nothing. For 2D, Bloom needs some pixels above the bloom threshold — which is exactly what an Additive light or bright particle provides.

The Polish Checklist

Here's a repeatable order of operations for polishing any 2D scene. Work back-to-front and top-down, checking as you go:

Figure 2: The 2D polish checklist. Each step is optional and cheap on its own; together they transform a prototype into an atmosphere.

Mini-Project: Polish the Platformer

Summary

🚀 What's Next?

Your 2D world now looks the part. But parallax scripts, particles, and post-processing all cost performance — and eventually something will stutter. In Lesson 12.1: Profiling: Finding Bottlenecks you'll open the Profiler and learn to measure exactly where your frames are going, so your beautiful scene also runs smoothly.