Unity Lighting and Visual Effects

Lighting Modes

Realtime Lights

• Calculate lighting every frame at runtime
• Allow dynamic changes to intensity, color, position
• Cast shadows up to Shadow Distance
• Contribute only direct lighting by default (no bounced light)
• Higher runtime cost, especially in complex scenes or low-end hardware
• Best for: dynamic objects, flickering effects, moving light sources

Baked Lights

• Calculations performed in the Unity Editor and saved as lighting data to disk
• At runtime, Unity loads pre-computed data instead of calculating dynamically
• Bake both direct and indirect lighting into lightmaps
• Store information in Light Probes for moving objects
• Cannot modify light properties at runtime; do not illuminate dynamic GameObjects
• No specular contributions
• Best for: static scenery, complex indirect lighting, performance-critical scenarios

Mixed Lights

• Combine baked indirect lighting with real-time direct lighting
• Behavior depends on the Lighting Mode setting in the Lighting window
• Cast real-time shadows (not baked soft shadows)
• Can change properties at runtime (affects real-time component only)
• Always more expensive than fully baked lighting
• Best for: dynamic shadows with baked background lighting

Light Types

Directional Light

• Located infinitely far away, emits light in one direction
• Parallel rays, no distance-based intensity falloff
• Simulates sun/moon; every new scene includes one by default
• Links to procedural sky system; rotate to create time-of-day effects

Point Light

• Located at a point, emits in all directions equally
• Intensity follows inverse square law (diminishes with distance squared)
• Use for lamps, explosions, local illumination

Spot Light

• Located at a point, emits in a cone shape
• Adjustable cone angle; light diminishes at edges (penumbra)
• Wider angles create larger fade areas
• Use for flashlights, headlights, searchlights

Area Light

• Defined by a rectangle or disc; emits uniformly across surface
• Follows inverse square law; produces soft, subtle shading
• Bake-only -- not available at runtime
• Use for street lights, realistic interior lighting

Global Illumination

Baked GI

• Pre-computes indirect lighting into lightmaps using the Progressive Lightmapper (CPU or GPU)
• Results stored in lightmap textures and Light Probes
• Configure in the Lighting window under Bake settings
• GPU Progressive Lightmapper offers faster bake times with configurable tile sizes

Environment Lighting

• Skybox: Uses skybox material colors for ambient light from different angles
• Gradient: Separate sky, horizon, and ground colors with smooth blending
• Color: Uniform ambient light across the scene

Environment Reflections

• Source: Skybox or custom Cubemap/RenderTexture
• Configurable resolution, compression, intensity multiplier
• Bounces setting controls reflection evaluation iterations between objects

Light Probes and Adaptive Probe Volumes

Light Probes

• Capture lighting information in empty space throughout a scene
• At runtime, indirect lighting for dynamic GameObjects is approximated using nearest probes
• Provide indirect bounced light for moving objects and LOD system support
• Must be manually placed using Light Probe Groups
• Store baked lighting information; work with both direct and indirect lighting

Adaptive Probe Volumes (APV)

• Automated probe placement -- eliminates manual Light Probe Group positioning
• Per-pixel lighting -- superior quality compared to per-object approaches
• Scene baking -- bake multiple scenes together using Baking Sets
• Runtime adjustments -- Lighting Scenarios and sky occlusion for dynamic changes
• Large-world support -- streaming data for expansive open-world environments
• Data flexibility -- loading from AssetBundles or Addressables
• Configurable probe density and volume size with visualization tools

Reflection Probes

Types

Key Properties

• Importance: Rendering priority when multiple probes overlap
• Intensity: Texture brightness in shader calculations
• Box Projection: Enables projection mapping for interiors (requires URP config)
• Box Size/Offset: World-space bounding box for reflection contribution
• Blend Distance: Blending distance for deferred probes

Realtime Options

• Refresh Mode: On Awake, Every Frame, or Via Scripting
• Time Slicing: All Faces At Once, Individual Faces, No Time Slicing

Particle System vs VFX Graph

• Use Particle System for mobile targets, simple effects, when you need full CPU-side scripting control, or when targeting the Built-in Render Pipeline
• Use VFX Graph for massive particle counts, GPU-driven simulations, complex node-based authoring, or high-end platforms with URP/HDRP

Particle System Modules

VFX Graph Basics

Systems

1. Spawn System: Single Spawn Context managing emission
2. Particle System: Initialize -> Update -> Output succession
3. Mesh Output System: Single Mesh Output Context

Contexts

• Spawn: Executes each frame to calculate spawn amounts. States: Running, Idle, Waiting. Configurable loop duration, count, and delays
• Initialize: Runs at particle birth, sets initial state. Processes Blocks for newly spawned particles. Configurable bounds and capacity
• Update: Per-frame for all living particles. Automatic: position integration, rotation integration, aging, reaping
• Output: Renders particles (Quad, Mesh, etc.). No output ports. Customizable rendering blocks

Graph Elements

• Blocks: Stackable nodes within Contexts; each handles one operation; top-to-bottom execution
• Operators: Low-level property workflow nodes connecting to Block/Context ports
• Properties: Connectable via property workflow
• Settings: Non-connectable editable values per Context

GPU Events

Common Patterns (C#)

Create and Configure a Light

using UnityEngine;

public class LightSetup : MonoBehaviour
{
    void Start()
    {
        GameObject lightObj = new GameObject("Dynamic Light");
        Light light = lightObj.AddComponent<Light>();
        light.type = LightType.Point;
        light.color = Color.yellow;
        light.intensity = 2.0f;
        light.range = 15f;
        light.shadows = LightShadows.Soft;
        light.shadowResolution = UnityEngine.Rendering.LightShadowResolution.Medium;
    }
}

Create a Realtime Reflection Probe

using UnityEngine;
using UnityEngine.Rendering;

public class ProbeSetup : MonoBehaviour
{
    void Start()
    {
        GameObject probeObj = new GameObject("Realtime Reflection Probe");
        ReflectionProbe probe = probeObj.AddComponent<ReflectionProbe>();
        probe.size = new Vector3(10, 10, 10);
        probe.mode = ReflectionProbeMode.Realtime;
        probe.refreshMode = ReflectionProbeRefreshMode.EveryFrame;
        probe.resolution = 256;
        probe.hdr = true;
    }
}

Control Particle System at Runtime

using UnityEngine;

public class ParticleController : MonoBehaviour
{
    ParticleSystem ps;

    void Start()
    {
        ps = GetComponent<ParticleSystem>();

        // Modify emission rate -- cache module in local variable first
        var emission = ps.emission;
        emission.rateOverTimeMultiplier = 50f;

        // Modify main module
        var main = ps.main;
        main.startLifetime = 3f;
        main.startSpeed = 5f;
        main.simulationSpace = ParticleSystemSimulationSpace.World;
    }

    void OnTriggerEnter(Collider other)
    {
        // Burst emit particles
        ps.Emit(100);
    }

    void OnDisable()
    {
        ps.Stop(true, ParticleSystemStopBehavior.StopEmittingAndClear);
    }
}

VFX Graph Runtime Control

using UnityEngine;
using UnityEngine.VFX;

public class VFXController : MonoBehaviour
{
    VisualEffect vfx;
    VFXEventAttribute eventAttr;

    void Start()
    {
        vfx = GetComponent<VisualEffect>();
        eventAttr = vfx.CreateVFXEventAttribute();

        // Set exposed properties
        vfx.SetFloat("SpawnRate", 100f);
        vfx.SetVector3("Direction", Vector3.up);
        vfx.playRate = 1.5f;
    }

    void OnTriggerEnter(Collider other)
    {
        // Send custom event with attributes
        eventAttr.SetVector3("position", other.transform.position);
        vfx.SendEvent("OnHit", eventAttr);
    }

    public void StopEffect()
    {
        vfx.Stop();
    }
}

Refresh Reflection Probe on Demand

using UnityEngine;

public class ProbeRefresher : MonoBehaviour
{
    ReflectionProbe probe;

    void Start()
    {
        probe = GetComponent<ReflectionProbe>();
        probe.refreshMode = UnityEngine.Rendering.ReflectionProbeRefreshMode.ViaScripting;
    }

    public void RefreshReflections()
    {
        probe.RenderProbe();
    }

    public bool IsReady()
    {
        return probe.IsFinishedRendering(probe.RenderProbe());
    }
}

Anti-Patterns

Lighting Anti-Patterns

1. Too many Realtime lights: Each realtime light adds per-frame cost. Use Baked or Mixed for static lights
2. Forgetting to enable Baked Global Illumination: Mixed/Baked lights silently fall back to Realtime without it
3. Overlapping Reflection Probes without Importance values: Causes flickering; always set Importance to establish priority
4. Using Area Lights expecting runtime behavior: Area lights are bake-only; they produce no light at runtime
5. Ignoring Indirect Multiplier: Leaving at default can cause over-bright or too-dark bounced light; tune per light
6. Not setting Shadow Bias correctly: Too low causes self-shadowing artifacts (shadow acne); too high causes peter-panning (shadows detach from objects)
7. Manual Light Probe placement in large scenes: Use Adaptive Probe Volumes (APV) in URP instead for automated, per-pixel quality

Particle System Anti-Patterns

1. Not caching module references: Each property access on a module struct immediately writes to native code; cache the module variable
2. Using World simulation space for attached effects: Particles drift away from moving parents; use Local space for attached FX
3. Excessive particle counts on CPU: Particle System is CPU-bound; for >10K particles, consider VFX Graph
4. Forgetting to Stop/Clear: Leaked particle systems consume CPU even when invisible

VFX Graph Anti-Patterns

1. Using VFX Graph for simple effects on mobile: GPU overhead and URP/HDRP requirement make it overkill for simple mobile effects
2. Not setting Capacity in Initialize: Default capacity may allocate too much or too little GPU memory
3. Ignoring Bounds: Incorrect bounds cause effects to be culled when visible; always configure bounds in Initialize context
4. Sending events every frame without throttling: SendEvent has CPU-GPU sync cost; batch or throttle event dispatch

Key API Quick Reference

Light (UnityEngine.Light)

type

color

intensity

range

spotAngle

innerSpotAngle

shadows

shadowResolution

shadowBias

shadowNormalBias

bounceIntensity

cookie

cullingMask

colorTemperature

lightmapBakeType

bakingOutput

AddCommandBuffer()

ParticleSystem (UnityEngine.ParticleSystem)

main

emission

shape

particleCount

isPlaying

isPaused

isStopped

Play()

Pause()

Stop()

Emit(count)

Simulate(time)

GetParticles()

SetParticles()

Clear()

TriggerSubEmitter()

VisualEffect (UnityEngine.VFX.VisualEffect)

visualEffectAsset

playRate

aliveParticleCount

Play()

Stop()

Reinit()

SendEvent(name, attr)

CreateVFXEventAttribute()

SetFloat()

SetVector3()

GetFloat()

GetVector3()

HasFloat()

HasVector3()

ResetOverride(property)

ReflectionProbe (UnityEngine.ReflectionProbe)

mode

size

center

intensity

importance

boxProjection

refreshMode

timeSlicingMode

RenderProbe()

IsFinishedRendering()

BlendCubemap()

Related Skills

• unity-graphics

  -- Render pipelines (URP/HDRP/Built-in), shaders, materials, cameras

• unity-2d

  -- 2D lighting (URP 2D Renderer), sprite rendering

• unity-platforms

  -- Platform-specific lighting quality tiers, mobile optimization

Additional Resources

• Lighting Overview
• Light Types
• Light Modes
• Light Probes
• Reflection Probes
• Adaptive Probe Volumes (URP)
• Particle System Modules
• VFX Graph Package
• Light Scripting API
• ParticleSystem Scripting API
• ReflectionProbe Scripting API