Tutorial on DAD 424 Sound Design for Games

Simplifying Sound Playback in Unity with FMOD’s PlayOneShot Command

Mon, 13 Oct 2025 00:00:00 +0000

Introduction

In game audio, efficiency matters. When designing sound interactions in Unity using FMOD, there are many cases where you only need a sound to play once—like when a player picks up an item or activates a switch. Writing full event-handling code for each instance can quickly become cumbersome.

That’s where FMOD’s PlayOneShot command comes in. This function provides a fast, elegant way to trigger short, non-looping sound effects in your game world without manually managing event instances. In this guide, we’ll walk through how to use PlayOneShot and PlayOneShotAttached, explain how Unity’s trigger system ties in, and unpack key technical concepts like Vectors, Colliders, and Layers.

What Is PlayOneShot?

FMOD’s PlayOneShot command allows you to play an FMOD event anywhere in your game with a single line of code. When the command is called, it automatically plays the event and then cleans up after itself when the sound finishes—no need to store or release the event manually.

This makes it ideal for simple, one-off sound effects such as button clicks, weapon pickups, or door openings.

For instance, if we want to trigger a short sound effect when a player picks up their melee weapon, PlayOneShot lets us do it with minimal setup.

Setting Up the Event in FMOD

Create a new 3D Action event called Staff Collect and add your audio file (for example, Switch Activated 01).
Assign the event to your Master Bank.
Organize it neatly under SFX → Interactables.
Save your project and build your banks.

Once you’ve done that, switch back to Unity to implement the sound event.

Action Events are perfect for short, non-looping sounds that play once and then stop. They are typically used for sound effects triggered by player actions or environmental events.

Using Triggers in Unity

A Trigger in Unity is an invisible area that detects when objects (like your player) enter or leave it. Triggers are built using colliders with the Is Trigger box checked. When something passes through, Unity can perform specific actions—such as playing a sound.

For our weapon pickup example:

The StaffTakeTrigger object in your scene will act as the trigger.
It already has a Sphere Collider attached with Is Trigger enabled.
When the player enters this area, Unity can detect the interaction and execute our FMOD command.

We’ll connect this trigger to our FMOD event using a custom script.

Writing the Trigger Script

Go to your FMOD Scripts folder and create a new C# script called F_StaffCollectTrigger attach it to the StaffTakeTrigger object.

Delete the default Start and Update functions, as we won’t need them for this simple interaction.

Inside the script, we’ll use the OnTriggerEnter function. This Unity event function runs automatically when another object enters the trigger’s collider.

using UnityEngine;

public class F_StaffCollectTrigger : MonoBehaviour
{
 void OnTriggerEnter()
 {
 FMODUnity.RuntimeManager.PlayOneShot("event:/SFX/Interactables/StaffCollect", transform.position);
 }
}

onTriggerExit is another useful function that runs when an object leaves the trigger area. You can use it for sounds that should play when the player exits, like a door closing. onTriggerStay runs continuously while an object remains within the trigger.

This is all it takes to trigger the Staff Collect sound effect when the player enters the area.

However, we can improve this setup by specifying where in 3D space the sound should be played.

Understanding Vectors in Unity

To position sounds accurately, we need to work with Vectors—data types that store coordinates and direction.

Vector2 holds x and y coordinates (useful for 2D games).
Vector3 holds x, y, and z coordinates (used in 3D games).

In Unity, almost every object’s position, rotation, and scale are stored as Vector3 values. To access the current position of your object, you can reference its Transform component.

Here, transform.position retrieves the Vector3 position of the object this script is attached to (the trigger). This is shorthand for GetComponent<Transform>().position.

If you want to play the sound at a different location but related to the trigger, you can create a new Vector3:

Vector3 pos = transform.position + Vector3.up * 1.5f;
FMODUnity.RuntimeManager.PlayOneShot("event:/SFX/Interactables/StaffCollect", pos);

This example plays the sound 1.5 units above the trigger’s position.

Layers and Collision Setup

For the trigger to work correctly, Unity needs to detect when the player enters the trigger area. This requires proper setup of Layers and Colliders.

The object acting as the trigger must have a collider with Is Trigger checked.
The player object must either:
- Have a Rigidbody component, or
- Be on a layer compatible with the trigger’s layer.

You can manage these interactions in Unity’s Layer Collision Matrix under Edit → Project Settings → Physics. Ensure that the Player layer can interact with the Environment layer (or whichever layer your trigger belongs to).

Tags and Layers help organize objects in your scene and control how they interact. Tags are used for identifying objects, while Layers are used for collision detection and rendering.

Here you can see the Layer Collision Matrix in Unity, which defines how different layers interact with each other. See that the Player layer can collide with the Environment layer, allowing our trigger to detect when the player enters.

Using PlayOneShotAttached

While PlayOneShot requires a position vector, FMOD also offers a variant called PlayOneShotAttached. This version automatically plays an event at the location of a specific game object.

Here’s how to use it:

void OnTriggerEnter()
{
 FMODUnity.RuntimeManager.PlayOneShotAttached("event:/SFX/Interactables/StaffCollect", gameObject);
}

The gameObject reference points to the object this script is attached to—in this case, StaffTakeTrigger. This makes it an elegant alternative when you want to link the sound directly to an object’s position.

If you want to attach the sound to another object in the scene, you can define a public GameObject variable in your script and assign it through the Unity Inspector:

public GameObject Obj;

void OnTriggerEnter()
{
 FMODUnity.RuntimeManager.PlayOneShotAttached("event:/SFX/Interactables/StaffCollect", Obj);
}

This approach provides flexibility for triggering sounds from different points in your game world.

Limitations and Next Steps

While PlayOneShot and PlayOneShotAttached are great for quick, lightweight sound triggers, they come with a limitation: you can’t manipulate FMOD parameters after triggering them.

For cases where you need to control parameters dynamically (for instance, changing pitch or volume in response to player movement), you’ll need to use full event instances instead.

We’ll explore this in the next module: Interacting with FMOD Parameters—where you’ll learn how to adjust event behavior in real time for adaptive sound design.

Conclusion

The PlayOneShot and PlayOneShotAttached commands streamline the process of triggering short, non-looping sounds in Unity. Combined with Unity’s trigger system and a solid understanding of Vectors and Layers, they allow you to quickly prototype interactive sound behaviors.

Attaching Audio to Animations with FMOD and Unity

Mon, 01 Jan 0001 00:00:00 +0000

Introduction

This post walks through a practical pipeline for triggering FMOD sound events from Unity Animation Events so your character’s footsteps, landings, and swishes line up precisely with what’s on screen. We’ll build a reusable C# function that can be called from any Animation Event and, later, accept the FMOD event path as a parameter—setting us up to drive parameters (like surface material) in a follow-up lesson.

What You’ll Build

An FMOD event for a footstep, with a Material parameter that selects between multiple surface types.
A Unity C# function that:
- Creates and attaches an FMOD event instance to the player at runtime,
- Starts the event,
- Releases the instance,
- Accepts a string parameter for the FMOD event path (so you can reuse it across many animations).
Animation Events in Unity that call your C# function exactly when each foot hits the ground.

FMOD Setup: A Single Footstep Event, Many Materials

Create a 3D event named Ellen_Run in the SFX/Ellen folder that plays one footstep per trigger.

Add a user parameter named Material and set it to Hold (so the footstep that already triggered won’t switch mid-play if the parameter changes). Add four values representing different surface types:

Earth
Stone
Puddle
Grass

Set the parameter to Hold during playback to allow the current footstep to complete even if the player moves to a different surface.

Add a Multi Instrument (right-click, then Add Multi Instrument) for each material value and add the appropriate footstep samples for that surface. Enable Shuffle in the Multi Instrument settings to randomize footstep playback.

Now, when you select different values for the Material parameter, you’ll hear footsteps on different surfaces.

Save your project and build your banks before switching back to Unity.

Unity Project Setup

Create a script named F_Player and add it to your player (Ellen) GameObject. This script will own all player-related SFX behaviors.

The Reusable One-Shot Function

We’ll implement a “play one-shot with control” pattern: create an instance, attach it to the player, start it, and release it—while still allowing parameter control if we need it later.

Here’s a simple implementation using a new PlayRunEvent function. We use a public function so that Unity Animation Events can call it directly. For now we hardcode the event path; in the next section we’ll update the function to accept a string parameter so different animations can play different events.

 public void PlayRunEvent()
 {
 EventInstance run = RuntimeManager.CreateInstance("event:/SFX/Ellen/Ellen_Run");
 RuntimeManager.AttachInstanceToGameObject(run, gameObject, GetComponent<Rigidbody>());
 run.start();
 run.release();
 }

Why this approach instead of RuntimeManager.PlayOneShot(...)?

It gives you full control over parameters (e.g., Material) per trigger.
It’s easy to reuse: different animations can pass different event paths into the same function.

Hooking Up Unity Animation Events

Animation Events in Unity let an animation call your function at a specific frame. For footsteps, add an event exactly when each foot contacts the ground.

Locate Ellen’s run animations in the Project window:
- 3DGameKit/Art/Animations/AnimationClips/Characters/Ellen/
- Expand the Ellen Run Forward FBX to see its clips (forward, diagonal, etc.).
Preview the clip in the Inspector. If you see “No model is available for preview,” drag the Ellen model into the preview window from Art/Models/Characters/Ellen.
Find the Ellen_Run_Forward clip and click it to open the Animation tab. Click Edit to unlock it for modification.
Open the Events tab on the animation.
Scrub the timeline to the exact frame the foot contacts the ground.
Click Add Event. In the Function field, enter PlayRunEvent.
Add a second event for the other foot.
Click Apply to save the clip modifications.
Play the scene and run forward; you should hear a footstep on each contact.

Important: The script containing the target function must live on the same GameObject that plays the animation via an Animator. Otherwise, the Animation Event won’t be able to find your function.

Add the Event Path Parameter

Now that the events are triggering, let’s pass the FMOD event path as a string parameter so we can reuse this function for other animations (like landing or attacking) later.

Edit your F_Player script to update PlayRunEvent to accept a string parameter for the event path, as shown below.

 public void PlayRunEvent(string eventPath)
 {
 EventInstance run = RuntimeManager.CreateInstance(eventPath);
 RuntimeManager.AttachInstanceToGameObject(run, gameObject, GetComponent<Rigidbody>());
 run.start();
 run.release();
 }

In your Animation Events, update each event to pass the event path string: event:/SFX/Ellen/Ellen_Run (or whatever your event path is).

Understanding C# Parameters

We defined PlayRunEvent(string eventPath) so each animation can pass its own FMOD event path. This is a value parameter: the Animation Event provides a string, Unity passes it into your function at call time, and you use that to create the event instance.

This pattern scales nicely:

Walk clip → event:/SFX/Ellen/Ellen_Walk
Land clip → event:/SFX/Ellen/Ellen_Land
Attack clip → event:/SFX/Ellen/Ellen_Slash

You keep one function and let animations decide which event to play.

Common Pitfalls

The function name in Animation Events must match exactly, including case.
The script with PlayRunEvent must be on the animated GameObject (the same one with the Animator).
Don’t forget to click Apply after editing Animation Events; missed applies are a classic time sink.
Always call release() after start(); this defers cleanup until playback ends.
If your footstep feels off by a few frames, adjust the event position slightly in the animation timeline—what looks like “contact” in the mesh may need a tiny lead or lag to feel right in-game.

Helpful Links

More complete version with error checking and parameterization:

using UnityEngine;
using FMODUnity; // FMOD Unity integration
using FMOD.Studio; // FMOD Studio API

// by including these namespaces, we can use FMOD types directly

public class F_Player : MonoBehaviour
{
 // Optional: cache components you’ll likely need
 private Rigidbody _rb;

 void Awake()
 {
 _rb = GetComponent<Rigidbody>();
 }

 // Called by Unity Animation Events. Pass an FMOD event path, e.g. "event:/SFX/Ellen/Ellen_Run"
 public void PlayRunEvent(string eventPath)
 {
 if (string.IsNullOrEmpty(eventPath))
 {
 Debug.LogWarning("PlayRunEvent called without a valid FMOD event path.");
 return;
 }

 EventInstance run = RuntimeManager.CreateInstance(eventPath);

 // Attach to this GameObject so the sound follows the player and 3D attenuation works as expected
 RuntimeManager.AttachInstanceToGameObject(run, gameObject, _rb);

 run.start();
 run.release(); // Safe: schedules the instance for cleanup after playback finishes
 }
}