Unity Game Engine Series Part 7: Audio & Visual Effects

1. Audio System Fundamentals

1.1 AudioSource & AudioListener

Unity's audio system is built on two foundational components:

using UnityEngine;

public class SoundEffectPlayer : MonoBehaviour
{
    [Header("Audio Sources")]
    [SerializeField] private AudioSource sfxSource;
    [SerializeField] private AudioSource musicSource;

    [Header("Sound Effects")]
    [SerializeField] private AudioClip[] footstepClips;
    [SerializeField] private AudioClip jumpClip;
    [SerializeField] private AudioClip landClip;
    [SerializeField] private AudioClip[] impactClips;

    // Play a random footstep sound (variation prevents repetition fatigue)
    public void PlayFootstep()
    {
        if (footstepClips.Length == 0) return;
        AudioClip clip = footstepClips[Random.Range(0, footstepClips.Length)];

        // PlayOneShot allows overlapping sounds (multiple footsteps)
        // Unlike Play(), it doesn't interrupt the current clip
        sfxSource.PlayOneShot(clip, Random.Range(0.8f, 1.0f));
    }

    public void PlayJump()
    {
        sfxSource.PlayOneShot(jumpClip, 0.9f);
    }

    public void PlayLand(float impactForce)
    {
        // Volume scales with impact force
        float volume = Mathf.Clamp(impactForce / 20f, 0.3f, 1.0f);
        sfxSource.PlayOneShot(landClip, volume);
    }

    // Play a one-shot sound at a world position (for explosions, pickups, etc.)
    public static void PlayAtPoint(AudioClip clip, Vector3 position, float volume = 1f)
    {
        // Creates a temporary GameObject, plays the clip, then destroys itself
        AudioSource.PlayClipAtPoint(clip, position, volume);
    }
}

1.2 Spatial Audio & 3D Sound

The Spatial Blend slider on AudioSource controls the mix between 2D (constant volume, no panning) and 3D (volume and panning based on distance/direction from the AudioListener):

using UnityEngine;

public class SpatialAudioSetup : MonoBehaviour
{
    [SerializeField] private AudioSource environmentalSource;

    private void Start()
    {
        // Configure 3D spatial audio
        environmentalSource.spatialBlend = 1.0f;  // Fully 3D

        // Rolloff determines how volume decreases with distance
        environmentalSource.rolloffMode = AudioRolloffMode.Custom;
        environmentalSource.minDistance = 1f;    // Full volume within 1 unit
        environmentalSource.maxDistance = 50f;   // Inaudible beyond 50 units

        // Spread controls stereo width of 3D sound
        // 0 = point source (mono), 360 = full surround
        environmentalSource.spread = 60f;

        // Doppler effect (pitch shift as source moves past listener)
        environmentalSource.dopplerLevel = 0.5f; // Subtle Doppler
    }
}

// Audio Reverb Zones — automatic reverb based on player location
public class ReverbZoneSetup : MonoBehaviour
{
    // Place this on a trigger collider in a cave, hallway, etc.
    // Unity's AudioReverbZone component applies reverb presets:
    // Cave, Hallway, Bathroom, Arena, Forest, etc.

    [SerializeField] private AudioReverbZone reverbZone;

    public void SetCaveReverb()
    {
        reverbZone.reverbPreset = AudioReverbPreset.Cave;
        reverbZone.minDistance = 5f;
        reverbZone.maxDistance = 30f;
    }

    public void SetOutdoorReverb()
    {
        reverbZone.reverbPreset = AudioReverbPreset.Forest;
        reverbZone.minDistance = 10f;
        reverbZone.maxDistance = 100f;
    }
}

1.3 AudioMixer & Routing

The AudioMixer is a professional mixing console for your game's audio. It provides groups, effects, snapshots, and volume control — essential for settings menus (separate music/SFX/voice sliders) and dynamic audio adjustments:

using UnityEngine;
using UnityEngine.Audio;

public class AudioMixerController : MonoBehaviour
{
    [SerializeField] private AudioMixer masterMixer;

    // Exposed parameters in the mixer (right-click parameter -> Expose)
    private const string MASTER_VOL = "MasterVolume";
    private const string MUSIC_VOL = "MusicVolume";
    private const string SFX_VOL = "SFXVolume";
    private const string VOICE_VOL = "VoiceVolume";

    // Convert linear slider (0-1) to logarithmic decibels
    // AudioMixer uses dB: -80 (silence) to 0 (full volume)
    public void SetMasterVolume(float linearValue)
    {
        float dB = LinearToDecibel(linearValue);
        masterMixer.SetFloat(MASTER_VOL, dB);
        PlayerPrefs.SetFloat("MasterVol", linearValue);
    }

    public void SetMusicVolume(float linearValue)
    {
        masterMixer.SetFloat(MUSIC_VOL, LinearToDecibel(linearValue));
        PlayerPrefs.SetFloat("MusicVol", linearValue);
    }

    public void SetSFXVolume(float linearValue)
    {
        masterMixer.SetFloat(SFX_VOL, LinearToDecibel(linearValue));
        PlayerPrefs.SetFloat("SFXVol", linearValue);
    }

    private float LinearToDecibel(float linear)
    {
        // Logarithmic conversion: human hearing perceives volume logarithmically
        return linear > 0.0001f ? 20f * Mathf.Log10(linear) : -80f;
    }

    private void Start()
    {
        // Load saved volumes
        SetMasterVolume(PlayerPrefs.GetFloat("MasterVol", 1f));
        SetMusicVolume(PlayerPrefs.GetFloat("MusicVol", 0.75f));
        SetSFXVolume(PlayerPrefs.GetFloat("SFXVol", 1f));
    }

    // Mixer Snapshots — preset configurations for different game states
    [SerializeField] private AudioMixerSnapshot normalSnapshot;
    [SerializeField] private AudioMixerSnapshot pausedSnapshot;     // Music ducked, SFX muted
    [SerializeField] private AudioMixerSnapshot underwaterSnapshot; // Low-pass filter on everything

    public void TransitionToSnapshot(AudioMixerSnapshot snapshot, float transitionTime = 0.5f)
    {
        snapshot.TransitionTo(transitionTime);
    }

    public void OnGamePaused()
    {
        TransitionToSnapshot(pausedSnapshot, 0.3f);
    }

    public void OnGameResumed()
    {
        TransitionToSnapshot(normalSnapshot, 0.3f);
    }
}

2. Sound Design Integration

2.1 Trigger-Based Sound System

using UnityEngine;
using System.Collections.Generic;

// Centralized SFX manager with object pooling for audio sources
public class SFXManager : MonoBehaviour
{
    public static SFXManager Instance { get; private set; }

    [SerializeField] private int poolSize = 20;
    private Queue<AudioSource> audioPool = new Queue<AudioSource>();

    private void Awake()
    {
        if (Instance != null) { Destroy(gameObject); return; }
        Instance = this;
        DontDestroyOnLoad(gameObject);
        InitializePool();
    }

    private void InitializePool()
    {
        for (int i = 0; i < poolSize; i++)
        {
            GameObject obj = new GameObject($"SFX_Source_{i}");
            obj.transform.SetParent(transform);
            AudioSource source = obj.AddComponent<AudioSource>();
            source.playOnAwake = false;
            obj.SetActive(false);
            audioPool.Enqueue(source);
        }
    }

    public void PlaySFX(AudioClip clip, Vector3 position, float volume = 1f,
                         float pitch = 1f, float spatialBlend = 1f)
    {
        if (clip == null) return;

        AudioSource source = GetPooledSource();
        source.transform.position = position;
        source.clip = clip;
        source.volume = volume;
        source.pitch = pitch + Random.Range(-0.05f, 0.05f); // Slight variation
        source.spatialBlend = spatialBlend;
        source.gameObject.SetActive(true);
        source.Play();

        // Return to pool after clip finishes
        StartCoroutine(ReturnAfterPlay(source, clip.length / pitch));
    }

    private AudioSource GetPooledSource()
    {
        if (audioPool.Count > 0) return audioPool.Dequeue();

        // Expand pool if needed
        GameObject obj = new GameObject("SFX_Source_Extra");
        obj.transform.SetParent(transform);
        AudioSource source = obj.AddComponent<AudioSource>();
        source.playOnAwake = false;
        return source;
    }

    private System.Collections.IEnumerator ReturnAfterPlay(AudioSource source, float delay)
    {
        yield return new WaitForSeconds(delay + 0.1f);
        source.gameObject.SetActive(false);
        audioPool.Enqueue(source);
    }
}

2.2 Background Music & Cross-Fading

using UnityEngine;
using System.Collections;

public class MusicManager : MonoBehaviour
{
    public static MusicManager Instance { get; private set; }

    [SerializeField] private AudioSource musicSourceA;
    [SerializeField] private AudioSource musicSourceB;
    [SerializeField] private float crossFadeDuration = 2f;

    private bool isPlayingA = true;
    private Coroutine crossFadeCoroutine;

    private void Awake()
    {
        if (Instance != null) { Destroy(gameObject); return; }
        Instance = this;
        DontDestroyOnLoad(gameObject);
    }

    public void PlayMusic(AudioClip newTrack, bool loop = true)
    {
        if (crossFadeCoroutine != null)
            StopCoroutine(crossFadeCoroutine);

        crossFadeCoroutine = StartCoroutine(CrossFade(newTrack, loop));
    }

    private IEnumerator CrossFade(AudioClip newTrack, bool loop)
    {
        AudioSource fadeOut = isPlayingA ? musicSourceA : musicSourceB;
        AudioSource fadeIn = isPlayingA ? musicSourceB : musicSourceA;

        fadeIn.clip = newTrack;
        fadeIn.loop = loop;
        fadeIn.volume = 0f;
        fadeIn.Play();

        float timer = 0f;
        float startVolume = fadeOut.volume;

        while (timer < crossFadeDuration)
        {
            timer += Time.unscaledDeltaTime; // unscaled so it works when paused
            float t = timer / crossFadeDuration;

            fadeOut.volume = Mathf.Lerp(startVolume, 0f, t);
            fadeIn.volume = Mathf.Lerp(0f, 1f, t);

            yield return null;
        }

        fadeOut.Stop();
        fadeOut.volume = 0f;
        fadeIn.volume = 1f;
        isPlayingA = !isPlayingA;
    }
}

2.3 Adaptive Audio

Adaptive audio dynamically changes the music based on gameplay — combat intensity, exploration pace, danger level. This technique is used extensively in AAA games:

using UnityEngine;
using UnityEngine.Audio;

public class AdaptiveMusicSystem : MonoBehaviour
{
    [Header("Music Layers")]
    [SerializeField] private AudioSource baseLayer;       // Ambient/exploration
    [SerializeField] private AudioSource tensionLayer;    // Strings, building tension
    [SerializeField] private AudioSource combatLayer;     // Percussion, intense
    [SerializeField] private AudioSource bossLayer;       // Full orchestra

    [Header("Intensity Settings")]
    [SerializeField] private float intensityLerpSpeed = 2f;

    private float currentIntensity = 0f; // 0 = calm, 1 = max combat

    public void SetIntensity(float targetIntensity)
    {
        currentIntensity = Mathf.Clamp01(targetIntensity);
    }

    private void Update()
    {
        // Smoothly blend layer volumes based on intensity
        baseLayer.volume = Mathf.Lerp(baseLayer.volume,
            currentIntensity < 0.3f ? 1f : Mathf.Lerp(1f, 0.3f, (currentIntensity - 0.3f) / 0.7f),
            intensityLerpSpeed * Time.deltaTime);

        tensionLayer.volume = Mathf.Lerp(tensionLayer.volume,
            Mathf.Clamp01((currentIntensity - 0.2f) * 2f),
            intensityLerpSpeed * Time.deltaTime);

        combatLayer.volume = Mathf.Lerp(combatLayer.volume,
            Mathf.Clamp01((currentIntensity - 0.5f) * 2f),
            intensityLerpSpeed * Time.deltaTime);

        bossLayer.volume = Mathf.Lerp(bossLayer.volume,
            Mathf.Clamp01((currentIntensity - 0.8f) * 5f),
            intensityLerpSpeed * Time.deltaTime);
    }

    // Example integration with combat system
    public void OnEnemyDetected() { SetIntensity(0.4f); }
    public void OnCombatStarted() { SetIntensity(0.7f); }
    public void OnBossEncounter() { SetIntensity(1.0f); }
    public void OnCombatEnded()   { SetIntensity(0f); }
}

3. Particle Systems

Unity's Particle System (codenamed "Shuriken") is a CPU-based particle effects engine that handles most real-time visual effects in games — fire, smoke, sparks, magic, rain, dust, explosions, and more.

3.1 Core Modules

3.2 Common Effects Recipes

using UnityEngine;

public class ParticleEffectsLibrary : MonoBehaviour
{
    [Header("Effect Prefabs")]
    [SerializeField] private ParticleSystem fireEffect;
    [SerializeField] private ParticleSystem smokeEffect;
    [SerializeField] private ParticleSystem sparkEffect;
    [SerializeField] private ParticleSystem magicBurstEffect;

    // Configure a fire effect from code
    public void SetupFireEffect(ParticleSystem ps)
    {
        var main = ps.main;
        main.startLifetime = new ParticleSystem.MinMaxCurve(0.5f, 1.5f);
        main.startSpeed = new ParticleSystem.MinMaxCurve(1f, 3f);
        main.startSize = new ParticleSystem.MinMaxCurve(0.3f, 0.8f);
        main.gravityModifier = -0.2f; // Negative = floats up
        main.simulationSpace = ParticleSystemSimulationSpace.World;

        var emission = ps.emission;
        emission.rateOverTime = 50;

        var shape = ps.shape;
        shape.shapeType = ParticleSystemShapeType.Cone;
        shape.angle = 15f;
        shape.radius = 0.3f;

        // Color gradient: bright yellow -> orange -> dark red -> transparent
        var colorOverLifetime = ps.colorOverLifetime;
        colorOverLifetime.enabled = true;
        Gradient grad = new Gradient();
        grad.SetKeys(
            new GradientColorKey[] {
                new GradientColorKey(new Color(1f, 0.9f, 0.3f), 0f),
                new GradientColorKey(new Color(1f, 0.5f, 0.1f), 0.4f),
                new GradientColorKey(new Color(0.8f, 0.1f, 0f), 0.8f)
            },
            new GradientAlphaKey[] {
                new GradientAlphaKey(1f, 0f),
                new GradientAlphaKey(0.8f, 0.5f),
                new GradientAlphaKey(0f, 1f)
            }
        );
        colorOverLifetime.color = new ParticleSystem.MinMaxGradient(grad);

        // Size: starts medium, grows slightly, then shrinks
        var sizeOverLifetime = ps.sizeOverLifetime;
        sizeOverLifetime.enabled = true;
        sizeOverLifetime.size = new ParticleSystem.MinMaxCurve(1f,
            new AnimationCurve(
                new Keyframe(0f, 0.5f),
                new Keyframe(0.3f, 1f),
                new Keyframe(1f, 0.2f)
            )
        );
    }

    // Play an effect at a position and auto-destroy
    public void PlayEffectAtPosition(ParticleSystem prefab, Vector3 position,
                                      Quaternion rotation = default)
    {
        if (rotation == default) rotation = Quaternion.identity;
        ParticleSystem instance = Instantiate(prefab, position, rotation);
        var main = instance.main;
        main.stopAction = ParticleSystemStopAction.Destroy;
        instance.Play();
    }
}

3.3 Sub-Emitters & Trails

using UnityEngine;

public class FireworkEffect : MonoBehaviour
{
    [SerializeField] private ParticleSystem rocketParticle;
    [SerializeField] private ParticleSystem burstParticle;
    [SerializeField] private ParticleSystem sparkTrailParticle;

    // Sub-emitters are typically configured in the Inspector, but here's the concept:
    // 1. Rocket launches upward (main emitter, short lifetime)
    // 2. On DEATH of rocket particle -> burst emitter spawns (explosion of color)
    // 3. Each burst particle has TRAILS enabled (sparkler streaks)
    // 4. On DEATH of burst particles -> tiny spark sub-emitter (final shimmer)

    public void LaunchFirework(Vector3 position)
    {
        ParticleSystem instance = Instantiate(rocketParticle, position, Quaternion.identity);
        instance.Play();

        // The sub-emitter chain handles the rest automatically
        Destroy(instance.gameObject, 5f); // Cleanup
    }
}

4. Visual Effects Graph

The VFX Graph is Unity's GPU-based particle system — capable of simulating millions of particles in real time using compute shaders. While the classic Particle System runs on the CPU (good for hundreds to thousands of particles), VFX Graph leverages the massive parallelism of modern GPUs.

4.1 GPU Compute Architecture

4.2 Spawn/Initialize/Update/Output Contexts

VFX Graph organizes particle logic into four contexts — each represented as a block in the visual editor:

using UnityEngine;
using UnityEngine.VFX;

public class VFXGraphController : MonoBehaviour
{
    [SerializeField] private VisualEffect vfxEffect;

    // VFX Graph uses "Property Binders" or scripted properties
    // to communicate with C# code

    public void SetIntensity(float intensity)
    {
        // Set exposed properties by name
        vfxEffect.SetFloat("Intensity", intensity);
    }

    public void SetSpawnPosition(Vector3 position)
    {
        vfxEffect.SetVector3("SpawnPosition", position);
    }

    public void SetColor(Color color)
    {
        vfxEffect.SetVector4("ParticleColor",
            new Vector4(color.r, color.g, color.b, color.a));
    }

    public void TriggerBurst(int count)
    {
        // Send an event to the VFX Graph (triggers Spawn context)
        VFXEventAttribute eventAttr = vfxEffect.CreateVFXEventAttribute();
        eventAttr.SetFloat("BurstCount", count);
        vfxEffect.SendEvent("OnBurst", eventAttr);
    }

    // Common VFX Graph patterns:
    // 1. Spawn Context: how many particles per second/burst
    // 2. Initialize Context: set starting position, velocity, lifetime, size, color
    // 3. Update Context: apply forces, noise, collision, age-based changes
    // 4. Output Context: render as quads, meshes, trails, or custom geometry
}

// Example: Galaxy simulation with 1 million stars
// VFX Graph approach:
// Spawn: 1,000,000 particles at once (GPU handles this easily)
// Initialize: Position along spiral arm using noise + math nodes
// Update: Orbital velocity around center, slight random perturbation
// Output: Render as point sprites with size/color based on distance from center

5. Post-Processing

Post-processing applies image effects to the camera's rendered output — similar to Instagram filters but for games. These effects are what give modern games their cinematic, polished look. In URP/HDRP, post-processing is integrated via the Volume system.

5.1 Volume System

using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal; // URP namespace

public class PostProcessingController : MonoBehaviour
{
    [SerializeField] private Volume globalVolume;
    [SerializeField] private Volume damageVolume;  // Local volume for damage flash

    private Vignette vignette;
    private ColorAdjustments colorAdjustments;
    private ChromaticAberration chromaticAberration;
    private Bloom bloom;

    private void Start()
    {
        // Get references to override components
        globalVolume.profile.TryGet(out vignette);
        globalVolume.profile.TryGet(out colorAdjustments);
        globalVolume.profile.TryGet(out chromaticAberration);
        globalVolume.profile.TryGet(out bloom);
    }

    // Damage flash: red vignette + desaturation + chromatic aberration
    public void OnPlayerDamaged(float damagePercent)
    {
        StartCoroutine(DamageFlashRoutine(damagePercent));
    }

    private System.Collections.IEnumerator DamageFlashRoutine(float intensity)
    {
        float duration = 0.3f;
        float timer = 0f;

        // Flash on
        vignette.intensity.Override(Mathf.Lerp(0.3f, 0.6f, intensity));
        vignette.color.Override(Color.red);
        colorAdjustments.saturation.Override(-50f * intensity);
        chromaticAberration.intensity.Override(0.8f * intensity);

        while (timer < duration)
        {
            timer += Time.deltaTime;
            float t = timer / duration;

            // Fade back to normal
            vignette.intensity.Override(Mathf.Lerp(0.6f * intensity, 0.3f, t));
            colorAdjustments.saturation.Override(Mathf.Lerp(-50f * intensity, 0f, t));
            chromaticAberration.intensity.Override(Mathf.Lerp(0.8f * intensity, 0f, t));

            yield return null;
        }

        // Reset to defaults
        vignette.intensity.Override(0.3f);
        vignette.color.Override(Color.black);
        colorAdjustments.saturation.Override(0f);
        chromaticAberration.intensity.Override(0f);
    }
}

5.2 Key Effects Deep Dive

6. History & Evolution

Exercises & Self-Assessment

Conclusion & Next Steps

You now have a comprehensive understanding of Unity's audio and visual effects systems. Here are the key takeaways from Part 7:

• AudioSource & AudioListener form the foundation — configure spatial blend for 2D/3D, rolloff curves for distance attenuation, and Doppler for moving sources
• AudioMixer provides professional mixing — route audio through groups (Music/SFX/Voice/Ambient), use snapshots for state transitions, and convert linear sliders to decibels
• Adaptive audio uses layered music tracks with intensity-driven blending to match gameplay mood without jarring transitions
• Particle Systems (Shuriken) handle most gameplay effects — master emission, shape, velocity, color/size over lifetime, sub-emitters, and trails
• VFX Graph enables GPU-powered million-particle simulations — use for environmental spectacles and massive effects that would overwhelm the CPU
• Post-processing via the Volume system adds cinematic quality — bloom, color grading, ambient occlusion, and vignette are the most impactful effects
• Audio pooling prevents garbage collection spikes — pre-instantiate AudioSources and recycle them for frequent SFX