Particle Systems Mastery

1. Main Module: Duration: 5, Loop: ✅, Start Lifetime: 1.5, Start Speed: 15, Start Size: 0.05, Gravity: 1, Max Particles: 2000.
2. Emission: Rate over Time: 400. For a storm, use 600–800.
3. Shape: Box. Width: 20, Height: 1, Depth: 20. Position Y: 8 (above the scene). This rains down over a 20×20 meter area.
4. Renderer: Render Mode: Stretched Billboard, Speed Scale: 0.5, Length Scale: 2. This makes drops look like streaks moving downward.
5. Color over Lifetime: Start: rgba(180,220,255,0.9), End: rgba(180,220,255,0). Fades out at the end.
6. Sub Emitters: Enable → Birth: assign a "Splash" particle system (small upward burst of 3–5 tiny white particles).

1. Create a child Particle System called "RainSplash".
2. Main: Duration: 0.3, Loop: ❌, Start Lifetime: 0.4, Start Speed: 1.5, Start Size: 0.08, Gravity: 2.
3. Emission: Burst at time 0 → Count: 5.
4. Shape: Hemisphere, Radius: 0.1. Particles spread outward and upward.
5. Color: white → transparent. Size over Lifetime: big → small.
6. In the parent Rain system → Sub Emitters → + → set Splash here. Condition: Collision.

1. Create another child Particle System: "RainRipple".
2. Main: Lifetime: 1.2, Start Size: 0.3, Start Speed: 0, Max Particles: 100.
3. Shape: Circle, Radius: 0 (emit from center point).
4. Size over Lifetime: 0 → 1 (ring expands outward).
5. Color over Lifetime: solid → fully transparent (ring fades as it expands).
6. Renderer: Material using a ring sprite (white circle with hole in center). Render Mode: Billboard.

1. Main Module: Duration: 5, Loop: ✅, Start Lifetime: min 4, max 8 (random between two constants), Start Speed: min 0.5, max 2, Start Size: min 0.03, max 0.12, Gravity: 0.05, Max Particles: 500.
2. Emission: Rate over Time: 60. (Snow is gentler than rain — fewer, slower particles.)
3. Shape: Box, Width: 20, Depth: 20, Height: 0. Position Y: 8. Emit from the Volume (not just the Surface).
4. Velocity over Lifetime: X: curve oscillating between -0.5 and 0.5 (drift left/right). Y: -0.5 constant (gentle fall).
5. Noise Module: Strength: 0.3, Frequency: 0.5, Scroll Speed: 0.1. This makes flakes drift organically.
6. Rotation over Lifetime: Angular Velocity: random between -30 and 30. Flakes spin slowly.
7. Size over Lifetime: Stays roughly constant (use a flat curve, slight fade at end).
8. Color over Lifetime: Start rgba(255,255,255,0.9), End rgba(255,255,255,0). Fades gently.
9. Renderer: Material with a soft white circle sprite. Mode: Billboard.

For surfaces that accumulate snow over time, use a URP Decal Projector:

1. Add → 3D Object → Decal Projector to the scene.
2. Create a Decal material: Shader Graph → URP Decal. Set Base Map to a white noise snow texture.
3. In C#, animate the Decal Projector's fadeFactor from 0→1 over 10 seconds to show snow building up.

Realistic fire is three stacked particle systems, each representing a different part of the flame:

1. Main: Lifetime: 0.5–0.8, Speed: 2–4, Size: 0.3–0.6, Max: 50. Simulation Space: World.
2. Emission: Rate: 80.
3. Shape: Cone, Angle: 10, Radius: 0.1. Tight upward stream.
4. Velocity over Lifetime: Y: 1.5 (rises fast). Add slight X wobble: sin curve ±0.3.
5. Color over Lifetime: #ffffff → #fffba0 → #ffaa00 → #ff4400 → transparent. White hot → yellow → orange → fades.
6. Size over Lifetime: Ramp up from 0 → 1 → 0 (grows then shrinks).
7. Noise: Strength: 0.4, Frequency: 2. Makes flame flicker organically.
8. Renderer: Additive material, billboard, Sorting Layer: VFX.

1. Main: Lifetime: 3–5, Speed: 0.5–1, Start Size: 0.4–0.8, Max: 30. Gravity: -0.1 (floats upward).
2. Shape: Cone, Angle: 30, Radius: 0.15. Wider spread than core.
3. Color over Lifetime: rgba(80,80,80,0) → rgba(80,80,80,0.5) → rgba(0,0,0,0). Appears mid-life, fades out.
4. Size over Lifetime: 0.5 → 2.5. Smoke expands as it rises.
5. Velocity over Lifetime: Y: 0.8. Noise Strength: 1.2, Frequency: 0.3. Very turbulent.
6. Renderer: Alpha Blend material (not additive — smoke is opaque, not glowing). Sort in front of environment, behind characters.

1. Small, bright orange-white dots. Main: Lifetime: 1.5–3, Speed: 2–5, Size: 0.04, Max: 50.
2. Emission: Burst mode — spawn 2–4 every 0.2 seconds.
3. Velocity over Lifetime: Y: 0.5–2, X: random ±1. Embers fly upward and sideways.
4. Rotation over Lifetime: ±180 deg/sec — they spin.
5. Color: white-orange → transparent. Additive blend.
6. Lights module: Enable → Ratio: 0.3. 30% of embers emit a real point light! Max Lights: 4. Intensity: 0.5, Range: 0.5. This creates real flickering light from embers.

1. Main: Lifetime: 0.8, Speed: 4, Start Size: 0.08, Gravity: 2, Max: 20.
2. Emission: Burst — 1 particle every 0.5 seconds (drip drip drip).
3. Shape: Point (single emission point).
4. Velocity: Y: -5 (falls down), no X deviation for clean drip.
5. Color: rgba(100,180,255,0.9) → transparent. Size over Lifetime: constant then rapid shrink at end (splat).
6. Sub Emitters → Collision: tiny splash burst (5 particles in cone, upward, size 0.04, lifetime 0.3).

1. Main: Lifetime: 2–4, Speed: 0.5–1.5, Start Size: 0.05–0.2 (random), Gravity: -0.5 (negative = floats up), Max: 80.
2. Emission: Rate: 15.
3. Shape: Box (represents underwater floor area). Width/Depth: 5, Height: 0.
4. Velocity over Lifetime: Y: 1. Slight X wobble (sin oscillation ±0.2).
5. Color: rgba(150,220,255,0.6) → rgba(200,240,255,0.1). Semi-transparent, fades at top.
6. Size over Lifetime: small → grows slightly → pops (shrinks to 0 at end).
7. Renderer: Material with a circle sprite, set to Transparent blend (not additive — bubbles aren't glowing).

1. Main: Lifetime: 1–2, Speed: 8–12, Gravity: 2, Start Size: 0.1–0.15, Max: 200.
2. Emission: Rate: 150.
3. Shape: Cone, Angle: 5–15 (tight stream), Radius: 0.02.
4. Velocity over Lifetime: Limit over Lifetime: 0.5 (drag — slows particles naturally like water).
5. Collision Module: Enable → Type: World. Dampen: 0.2, Bounce: 0.1. Particles collide with the ground/pool surface.
6. Sub Emitters → Collision: splash burst.

Real game oceans combine three systems:

1. Create a Shader Graph: URP Lit. Set Surface: Transparent.
2. In Vertex stage: add a Position node (object space). Feed the Y into a Sine node driven by Time × waveSpeed + X × waveFrequency. Output to Vertex Position Y. This makes the mesh ripple.
3. For depth color: sample screen-space depth, blend between shallow color (light cyan) and deep color (dark blue) based on depth value.
4. Add Normal Map from a tiling water normal texture, scrolling over time (two UV sets scrolling in opposite directions for complex ripple).
5. Set Smoothness: 0.95. Specular: high. This gives the glossy water look.

1. Foam: Large, white, soft-edged circle sprites. Lifetime: 2–4, Speed: 0, Size: 0.5–1.5. Shape: Edge along shoreline or wave crest. Alpha blend, not additive. Slow fade-in and fade-out.
2. Spray/Mist: Tiny white dots. Lifetime: 0.5–1, Speed: 1–3 (upward + outward from wave). Additive blend. Size: 0.03–0.08. Noise Strength: 1. Creates fine water mist that catches light beautifully.

1. Main: Lifetime: 0.6, Speed: 0, Start Size: 0.4–0.8, Max: 100. Simulation Space: World (critical — trail stays behind in world space as fireball moves).
2. Emission: Rate: 60.
3. Shape: Sphere, Radius: 0.1. Emits in all directions from the fireball center.
4. Velocity over Lifetime: Orbital mode — slight spiral for swirling fire trail.
5. Color over Lifetime: white → yellow → orange → red → transparent.
6. Size over Lifetime: 1 → 0. Shrinks as the trail ages (particles get smaller as they fall behind).
7. Noise: Strength: 0.8, Frequency: 3. Organic swirling motion.

1. Shape: Sphere, Radius: 0.3. Emits in all directions.
2. Emission: Burst — Count: 60, Time: 0. One massive simultaneous burst.
3. Main: Lifetime: 0.6–1.2, Speed: 5–15 (fast outward), Size: 0.3–0.8, Gravity: 0.5.
4. Color: white → orange → dark red → transparent (fast fade).
5. Add a separate Shockwave: a single disc particle, starts small, expands quickly, flat, additive white. Size over Lifetime: 0 → 3 over 0.3 seconds.
6. Add Debris sub-system: dark gray chunks, gravity 2, bounce collision, slow rotation. Stays on the ground after explosion.

1. Main: Lifetime: 1–2, Speed: 0.5–2, Start Size: 0.05–0.15, Max: 150.
2. Emission: Rate: 40. Also add 3 Bursts spaced 0.5s apart, Count: 8.
3. Shape: Sphere, Radius: 0.5. Particles spawn in a sphere around the caster.
4. Velocity over Lifetime: Orbital — X: 2, Y: 2. Particles orbit the center like electrons around an atom.
5. Color: random from gradient: purple, cyan, white, gold. Use "Random Between Two Colors" mode for magical variety.
6. Noise: Strength: 0.5, Frequency: 1.5. Subtle shimmer movement.
7. Trails Module: Enable → Lifetime: 0.3, Width: 0.02. Each sparkle leaves a short glowing trail.
8. Renderer: Star or cross sprite, Additive blend.

1. Main: Lifetime: 2, Speed: 1–3, Gravity: 0, Max: 300.
2. Shape: Circle, Radius: 2, Emit from Edge. Particles start at the outer edge.
3. Velocity over Lifetime: Orbital — spin particles. Also add Linear Y: slight pull toward center.
4. Color: outer starts dark, inner goes bright cyan/purple. Over Lifetime: dark purple → bright cyan → white.
5. Size over Lifetime: starts large, shrinks to 0 as they reach center (sucked in).
6. Rotation over Lifetime: 180 deg/sec. Particles spin as they spiral inward.
7. Add a second system with larger, slower particles (ring wisps) for layered depth.

A beam is a LineRenderer for the core, plus particle systems for charge-up and impact.

public class MagicBeam : MonoBehaviour
{
    public LineRenderer  beam;
    public Transform     target;
    public ParticleSystem impactVFX;
    public float         widthPulse = 0.05f;

    void Update()
    {
        // Draw beam from caster to target
        beam.SetPosition(0, transform.position);
        beam.SetPosition(1, target.position);

        // Pulse the width for energy feel
        float w = widthPulse + Mathf.Sin(Time.time * 20f) * 0.01f;
        beam.startWidth = w;
        beam.endWidth   = w * 0.5f;

        // Move impact VFX to beam endpoint
        impactVFX.transform.position = target.position;
    }
}

Set the LineRenderer material to Additive + a beam texture (white gradient from center to edge). Add a blue/purple point light to the target impact VFX.

1. Create a flat quad at Y=0.01 (just above ground). Material: Additive, with a magic circle rune texture. Animate rotation via script.
2. Add a particle system on the circle edge (Shape: Circle, Radius: 1.5, Emit from Edge). Slow-rising magical wisps.
3. Add rising rune sprites (Texture Sheet Animation module, multiple rune frames, random start frame). Particles float up and fade.

Glow is not a particle effect — it's a post-processing effect called Bloom. Here's how the pipeline works:

1. Objects use HDR (High Dynamic Range) colors — values above 1.0 in the color picker. Normal colors max at 1.0; HDR goes to 3.0, 5.0, 10.0+.
2. URP renders the scene normally.
3. Bloom post-process reads all pixels brighter than a threshold and bleeds their light outward — creating the glow halo.
4. Result: anything emitting HDR light glows. Regular colored objects don't.

1. Project Settings → Graphics → Scriptable Render Pipeline Settings → your URP asset. Ensure HDR: On and Post Processing: On.
2. In Scene: Add → Volume → Global Volume. Add a new Profile.
3. Add Override → Bloom. Set Threshold: 1.0 (glow anything above this), Intensity: 0.5–1.5, Scatter: 0.7.
4. Also add Color Adjustments (slight saturation +10) and Vignette for atmosphere.
5. On Camera: ensure Post Processing: ✅.

1. Main: Lifetime: 4–8, Speed: 0.2–0.8, Size: 0.06–0.1, Max: 30, Simulation Space: World.
2. Shape: Box covering scene area.
3. Velocity over Lifetime: Random between (-1,-0.5,-1) and (1,0.5,1). Gentle drifting.
4. Noise: Strength: 0.5, Frequency: 0.3, Scroll Speed: 0.1. Organic flight pattern.
5. Color over Lifetime: starts transparent, peaks at HDR yellow-green (R:0.6, G:1.0, B:0.2, A:1.0, Intensity: 2.5), fades out. Pulsing blink effect.
6. Lights Module: Ratio: 0.5. Half of fireflies emit a real point light (range 0.8, intensity 0.6, color warm green).

The Lights module in a Particle System lets each particle emit a real-time Unity Light. Used carefully, this creates incredible interactive lighting from effects.

1. Create the flame particle system (see Fire module). Layer: Core, Mid, Embers.
2. On the Embers system → Lights Module → assign a warm orange Point Light prefab. Ratio: 0.2. Max: 3.
3. On a parent GameObject, attach FireLightFlicker.cs. Perlin noise drives intensity fluctuation.
4. Result: 2–3 dynamic lights from embers, plus the base flicker, creates convincingly real torch lighting.

public class LightningBolt : MonoBehaviour
{
    public LineRenderer lr;
    public Transform    start, end;
    public int          segments    = 12;
    public float        jaggedness  = 0.4f;
    public float        refreshRate = 0.03f;
    private float       timer;

    void Update()
    {
        timer -= Time.deltaTime;
        if (timer > 0) return;
        timer = refreshRate;
        GenerateBolt(start.position, end.position);
    }

    void GenerateBolt(Vector3 a, Vector3 b)
    {
        lr.positionCount = segments;
        for (int i = 0; i < segments; i++)
        {
            float   t    = (float)i / (segments - 1);
            Vector3 mid  = Vector3.Lerp(a, b, t);
            Vector3 perp = Vector3.Cross((b - a).normalized, Vector3.forward);
            mid += perp * Random.Range(-jaggedness, jaggedness);
            mid += Vector3.up * Random.Range(-jaggedness, jaggedness);
            lr.SetPosition(i, mid);
        }
    }
}

Set the LineRenderer material to Additive with a bright blue-white gradient. Set Width: 0.02. The bolt regenerates every 30ms to create the electric flicker.

1. Main: Lifetime: 0.2–0.5, Speed: 3–8, Start Size: 0.03–0.06, Gravity: 1, Max: 80.
2. Emission: Rate: 0. Bursts only — 10–20 sparks every 0.05 seconds.
3. Shape: Point or tiny Sphere (radius 0.05).
4. Velocity: Random outward in all directions. Speed: 5–12.
5. Color: white → blue-white → transparent. Very fast fade.
6. Rotation: 360 deg/sec random. Sparks tumble.
7. Renderer: Stretched Billboard, Speed Scale: 0.8. Sparks leave bright streaks.