Audio on DAD 424 Sound Design for Games

Controlling FMOD Busses with Unity Sliders (Part 2)

Wed, 12 Jun 2024 00:00:00 +0000

In this tutorial, we will cover how to control the volume of your FMOD buses (like Music and SFX) using Unity sliders, and more importantly, how to make sure those sliders remember their positions when your player changes scenes.

Part 1: Setting the Volume

The Code

In your Bus Control script, create a new public function. Let’s call it VolumeLevel. This function needs to accept a float parameter, which will represent the data coming from the slider.

Inside the function, we use the FMOD API command .setVolume().

public void VolumeLevel(float newSliderValue)
{
 // 'Bus' is the variable where you stored your FMOD Bus path earlier
 Bus.setVolume(newSliderValue);
}

Understanding FMOD Volume Floats

It is important to understand how FMOD interprets these numbers. FMOD faders use a logarithmic scale (decibels), but the API uses a linear float scale between 0 and 1.

1.0f: This equals the volume the fader was set to when you built your banks in FMOD. (If your fader was at 0dB, 1.0 = 0dB. If it was at -10dB, 1.0 = -10dB).
0.0f: This equals -infinity dB (silence).
0.5f: This is roughly -28dB (depending on the curve), effectively half the “fader distance” between the start point and silence.

Part 2: Connecting the UI Slider

Now that the logic exists, we need to hook it up to the Unity UI.

Select your Slider object in the Unity Hierarchy.
Find the Slider component in the Inspector.
Look for the “On Value Changed (Single)” event box at the bottom.
Click the (+) icon to add a listener.
Drag the GameObject containing your Bus Control script into the “Object” slot.
In the function dropdown, look for your script name and select VolumeLevel.

Crucial Step: When selecting the function, you will see it listed twice: once under “Dynamic float” and once under “Static Parameters.”

Select the Dynamic Float version. This ensures the function receives the actual current value of the slider as the player moves it.

Part 3: The “Scene Reset” Problem

If you play your game now, the sliders will work. However, you will notice a bug if you switch scenes.

Let’s say the player lowers the volume to 50%. When they walk through a portal to Level 2, the scene reloads. FMOD is smart—it remembers the volume is at 50%. However, the UI Slider is just a dumb object; it reloads from the prefab and resets visually to its default position (usually 100% or 0.9).

Now you have a slider showing 100% volume, but the audio is playing at 50%. We need to sync them up when the scene starts.

Part 4: syncing Sliders with `.getVolume()`

To fix this, we need to tell the slider where the bus volume is actually located the moment the script starts. We do this using the .getVolume() command.

The Challenge with `.getVolume()`

This command is slightly unique because it outputs two distinct values. It requires two out variables:

Volume: The value set by the setVolume command (User input).
Final Volume: The value calculated after combining user input with FMOD modulators or automation.

We only care about the first one (User input).

The Solution

First, update your script to include the UI namespace, or Unity won’t recognize what a “Slider” is.

using UnityEngine;
using UnityEngine.UI; // Don't forget this!

Next, inside your class, create a reference to the Slider and variables to hold the volume data.

private Slider slider;
private float busVolume;
private float finalBusVolume;

Finally, in your Start() function, grab the slider component and sync it to the FMOD bus:

void Start()
{
 // 1. Get the slider component attached to this object
 slider = GetComponent<Slider>();

 // 2. Get the current volume from the FMOD Bus
 // We pass in our two float variables to catch the data
 Bus.getVolume(out busVolume, out finalBusVolume);

 // 3. Update the slider visual to match the FMOD bus volume
 slider.value = busVolume;
}

Summary

By using setVolume dynamically and getVolume on initialization, you create a seamless experience for the player.

On Start: The script checks FMOD to see what the volume should be and updates the slider visual.
During Gameplay: The slider updates the FMOD bus using the Dynamic Float event.
On Scene Change: Even though the UI destroys and reloads, the Start function runs again, grabs the persistent FMOD volume, and snaps the slider back to the correct position.

Now your audio settings menu is robust and persistent across your entire game!

Creating Audio Zones and Dynamic Mixing with Snapshots

Wed, 12 Jun 2024 00:00:00 +0000

In our previous tutorial, we mastered Playback States to control when sounds play. Now, we’re going to control how they sound based on the game environment.

Have you ever noticed how audio changes when a character walks into a cave (reverb kicks in) or when they are low on health (the sound gets muffled and bass-heavy)? In FMOD, these dynamic mixing changes are handled by Snapshots.

In this guide, we will cover:

What Snapshots are and how to create them.
Creating a Reverb Zone using Triggers.
Handling signal routing (so your UI clicks don’t echo!).
Creating a “Low Health” filter using Parameters.

What is a Snapshot?

Think of a Snapshot as a “preset” for your FMOD Mixer. When active, a Snapshot can change the volume of buses, toggle effects on and off, or change effect parameters.

There are two main types:

Overriding: Forces values to a specific state (good for absolute changes).
Blending: Adds changes on top of existing values (good for layering).

For this tutorial, we will focus on Overriding snapshots to create distinct audio zones.

Part 1: The Reverb Zone (Trigger-Based)

Let’s create a system where entering a tunnel applies reverb to our sound effects.

Step 1: FMOD Setup

Go to the Mixer window in FMOD.
Create a Return Bus for Reverb if you haven’t already, and add a Reverb effect to it.
Go to the Snapshots tab and create a new Overriding Snapshot named “Reverb Zone 1”.
Deselect your snapshot for the time being.
Select the SFX Bus and add a Send to the Reverb Return Bus. Set the send level to around -6dB (adjust to taste).
Scoping: When you select the snapshot, your mixer faders will turn into yellow outlines. This means they are “scoped out” (unaffected).
1. Select the snapshot again. Mixer controls will appear with yellow outlines, meaning they are currently scoped out.
2. Click the reverb send level on the SFX Bus so it becomes fully yellow, indicating it is scoped in and will be driven by the snapshot.
When you select the snapshot, the reverb send will be set to the value defined in the snapshot.
Modulation: To make the reverb fade in smoothly, right-click the Snapshot’s Intensity dial (in the deck area) and add an AHDSR Modulator. This ensures the reverb doesn’t snap on/off instantly.

Step 2: The Unity Script

Open Level 2 in Unity. This scene has more tunnels that we can use for testing reverb.

In Unity, Snapshots are treated almost exactly like Events. We create an instance, play it, and stop it.

Create a cube object with Create > 3D Object > Cube. Scale it to form a tunnel entrance and set its position so the player can walk through it. Make sure to set the cube’s collider to Is Trigger. Call it Reverb Zone. Also make sure the layer is set to Environment.

We’ll leave the Mesh Renderer on so you can see the zone in the scene, but in a real game, you would likely turn this off.

Create a script called F_ReverbZone and attach it to the Reverb Zone object.

using UnityEngine;
using FMODUnity;
using FMOD.Studio;

public class ReverbZone : MonoBehaviour
{
 private EventInstance reverbSnapshot;

 void Start()
 {
 // Create the instance just like a normal event
 // Note: The path starts with "snapshot:/"
 reverbSnapshot = RuntimeManager.CreateInstance("snapshot:/Reverb Zone");
 }

 void OnTriggerEnter(Collider other)
 {
 if (other.CompareTag("Player"))
 {
 reverbSnapshot.start();
 }
 }

 void OnTriggerExit(Collider other)
 {
 if (other.CompareTag("Player"))
 {
 // Allow the AHDSR to fade it out naturally
 reverbSnapshot.stop(STOP_MODE.ALLOWFADEOUT);
 }
 }

 void OnDestroy()
 {
 reverbSnapshot.release();
 }
}

Step 3: Fixing the Signal Path (The UI Echo Problem)

If you test the game now, entering the zone will reverb everything sent to the SFX bus—including your UI menu clicks! That’s not what we want. We need to split the signal.

In the FMOD Mixer:

Delete the send that goes from the SFX bus to the Reverb bus.
Create two new Group Buses under your main SFX bus: call them In-Game and UI.
Route your footsteps, attacks, and environmental sounds into In-Game.
Route your menu sounds into UI.
Place the Reverb Send on the In-Game bus only.

Now, your UI remains crisp and dry, while the game world echoes around you.

Part 2: The Distance-Based Zone (Automation)

Sometimes you don’t want a hard trigger; you want the effect to get stronger as you get closer to a specific object.

FMOD Setup

Create a new snapshot (e.g., “Reverb Zone 2”).
Instead of an AHDSR on the Intensity dial, right-click and Add Automation.
Select the built-in Distance parameter.
Draw a curve:
- At 5 meters, Intensity = 100%
- At 10 meters, Intensity = 0%

Unity Script

Since this relies on distance, we must tell FMOD where the snapshot is located in 3D space.

Create an Empty GameObject called Reverb Zone 2 and position at (-1, -3, 28.5). Create a new script and attach to the gameObject:

void Start()
{
 reverbSnapshot = RuntimeManager.CreateInstance("snapshot:/Reverb Zone 2");
 reverbSnapshot.start(); // Start immediately

 // Attach the instance to this object so FMOD knows its location
 RuntimeManager.AttachInstanceToGameObject(reverbSnapshot, transform, GetComponent<Rigidbody>());
}

void OnDestroy()
{
 reverbSnapshot.stop(STOP_MODE.IMMEDIATE);
 reverbSnapshot.release();
}

Part 3: The “Low Health” Filter (Parameter Control)

A common game mechanic is muffling audio when the player is dying. We can achieve this by controlling a Snapshot via a script parameter.

Step 1: FMOD Setup

Add a 3-EQ Effect to your In-Game bus.
Create a Snapshot called “Low Health”.
Scope in the High and Mid bands of the EQ and turn them all the way down (leaving only low frequencies).
Right-click the Snapshot’s Intensity dial and select Expose as Parameter.
Set the range of the parameter from 1 to 5.
Invert the curve:
- When Parameter = 5 (Full Health), Intensity = 0% (No filter).
- When Parameter = 1 (Low Health), Intensity = 100% (Fully muffled).

Step 2: Linking Health to Audio

In your Player Controller script, you need to update the snapshot whenever health changes.

FMOD.Studio.EventInstance healthFilter;

void Start()
{
 healthFilter = RuntimeManager.CreateInstance("snapshot:/Low Health");
 healthFilter.start();
 healthFilter.release(); // Release immediately so it cleans up when stopped
}

// Call this function whenever the player takes damage or heals
public void SetHealthSnapshot() {
 healthFilter.setParameterByName("Intensity", m_Damageable.currentHitPoints); // currentHealth should be between 1 and 5
}
void OnDestroy()
{
 healthFilter.stop(STOP_MODE.IMMEDIATE);
}

By hooking the UpdateAudioHealth function into your existing damage logic (using Unity Events or direct method calls), your audio will dynamically react to the player’s survival status.

Summary

Snapshots are powerful tools that move beyond simple “Play/Stop” commands. By treating them as Event Instances in code, you can:

Trigger reverb zones using Colliders.
Automate audio changes based on 3D Distance.
Drive mix changes using gameplay variables like Player Health.

With these tools, you’ve now covered the core pillars of FMOD implementation: Events, Parameters, Playback States, and Snapshots.

How to Use Playback States to Control Audio Flow

Wed, 12 Jun 2024 00:00:00 +0000

When implementing dynamic audio in Unity using FMOD, you often need to know exactly what an audio event is doing at any given moment. Is it playing? Is it stopping? Has it already stopped?

This is where Playback States come in.

In this tutorial, we will explore what FMOD Playback States are, how to access them in your C# scripts, and how to use them to fix a common audio bug: the “stuttering” sound effect on UI sliders.

What is a Playback State?

A Playback State is a tool from FMOD’s API that allows us to check the status of an Event Instance. It returns the current status of the audio as an Enumerator (Enum).

The five main states returned by the API are:

PLAYING
STARTING
STOPPING
STOPPED
SUSTAINING

By accessing these states, we can write logic that prevents sounds from overlapping or triggering incorrectly.

Part 1: Setting Up the Variable

To use Playback States, you first need to define a variable to store the state information. Open the MusicPlayer script.

Inside your class, declare a variable of type FMOD.Studio.PLAYBACK_STATE:

private FMOD.Studio.PLAYBACK_STATE musicPlayState;

Note: You can omit FMOD.Studio if you are already using that namespace at the top of your script.

Part 2: Retrieving the State

To see what your audio is doing, you need to use the .getPlaybackState() command. This command queries the event instance and outputs the result into the variable we just created.

If you want to track the state in real-time, place this logic in your Update() function:

void Update()
{
 // Assuming '_musicInst' is your FMOD Event Instance
 _musicInst.getPlaybackState(out musicPlayState);

 // Debug to the console to see the state change
 Debug.Log(musicPlayState);
}

How it works:

While Playing: The console will log PLAYING.
Entering a Portal/Stopping: If you trigger a stop command, it switches to STOPPING.
Finished: Once the audio fades out completely, it switches to STOPPED.

Important: getPlaybackState only checks the state on the specific frame it is called. If you only put this in Start(), it will likely only ever say STARTING because it never updates again.

Part 3: A Practical Example (The UI Slider Fix)

One of the most useful applications for Playback States is preventing audio spam.

Imagine you have a volume slider in your Settings menu. You want a sound effect to play when the user moves the slider so they can hear the volume level. However, if you simply tell the sound to Start() every time the slider value changes, the sound will restart every single frame the mouse moves. This creates a messy “machine gun” stuttering effect.

We can use Playback States to ensure the sound only starts if it isn’t already playing.

Step 1: The Setup

In FMOD: Create a 2D Event (e.g., LevelTest) in a “UI” folder.
1. Add some test sounds into a Multi Instrument.
2. Ensure the event is sent to the SFX bus.
In Unity: Open your F_BusControl script.

Step 2: Modify the Script

// ... Your existing using statements ...

public class F_BusControl_class : MonoBehaviour
{
 // .. . Your existing variables ...
 EventInstance levelTestEvent;

 // Start is called once before the first execution of Update after the MonoBehaviour is created
 void Start()
 {
 // ... Your existing bus setup code ...

 // only assign the event if its actually an SFX
 if(busPath == "SFX")
 {
 levelTestEvent = RuntimeManager.CreateInstance("event:/SFX/UI/LevelTest");
 } else
 {
 levelTestEvent.release();
 }
 }

 public void VolumeLevel(float newSliderValue)
 {
 bus.setVolume(newSliderValue);
 levelTestEvent.start();
 }
}

You can hear that the sound stutters when you drag the slider quickly. We need to fix it by telling it to only start if th sound is not already playing.

We can use playback states to fix this issue:

// ... Your existing using statements ...

public class F_BusControl_class : MonoBehaviour
{
 // .. . Your existing variables ...
 EventInstance levelTestEvent;
 PLAYBACK_STATE pbState;

 // Start is called once before the first execution of Update after the MonoBehaviour is created
 void Start()
 {
 // ... Your existing bus setup code ...

 // only assign the event if its actually an SFX
 if(busPath == "SFX")
 {
 levelTestEvent = RuntimeManager.CreateInstance("event:/SFX/UI/LevelTest");
 } else
 {
 levelTestEvent.release();
 }
 }

 public void VolumeLevel(float newSliderValue)
 {
 bus.setVolume(newSliderValue);
 if(busPath == "SFX")
 {
 // Check the playback state before starting the event
 levelTestEvent.getPlaybackState(out pbState);

 if (pbState != PLAYBACK_STATE.PLAYING)
 {
 levelTestEvent.start();
 }
 }
 }
}

Now, when you drag the slider, the sound will play once. It will only play again after the previous instance has finished, resulting in a smooth, non-stuttering audio experience.

Summary

By using Playback States, you gain precise control over when your audio triggers. You are no longer just telling FMOD to “Play”; you are asking FMOD “Are you busy?” and acting accordingly.

This simple check is essential for creating polished UI sounds, managing dynamic music transitions, and ensuring your game’s audio sounds professional and clean.

Audio on DAD 424 Sound Design for Games

Controlling FMOD Busses with Unity Sliders (Part 2)

Part 1: Setting the Volume

The Code

Understanding FMOD Volume Floats

Part 2: Connecting the UI Slider

Part 3: The “Scene Reset” Problem

Part 4: syncing Sliders with .getVolume()

The Challenge with .getVolume()

The Solution

Summary

Creating Audio Zones and Dynamic Mixing with Snapshots

What is a Snapshot?

Part 1: The Reverb Zone (Trigger-Based)

Step 1: FMOD Setup

Step 2: The Unity Script

Step 3: Fixing the Signal Path (The UI Echo Problem)

Part 2: The Distance-Based Zone (Automation)

FMOD Setup

Unity Script

Part 3: The “Low Health” Filter (Parameter Control)

Step 1: FMOD Setup

Step 2: Linking Health to Audio

Summary

How to Use Playback States to Control Audio Flow

What is a Playback State?

Part 1: Setting Up the Variable

Part 2: Retrieving the State

Part 3: A Practical Example (The UI Slider Fix)

Step 1: The Setup

Step 2: Modify the Script

Summary

Part 4: syncing Sliders with `.getVolume()`

The Challenge with `.getVolume()`