GS_Audio

1 - Audio Manager

Base — ships in GS_Audio.

The Audio Manager is the one component the audio system needs. It starts the engine, holds your volume channels, loads your event libraries, and carries the listener that every positioned sound is measured against.

It is a GS manager, so it plugs into the Game Manager’s startup like the rest — or runs on its own if your project does not have one.

For component properties and the full API, see the Framework API reference.

Contents

• Setting It Up
• Using Audio Without a Game Manager
• What It Manages
• Setting the Listener
• Quick Reference
• Glossary
• See Also

Setting It Up

1. Create an entity and add the GS_AudioManagerComponent.
2. Configure your volume channels — a named list such as Music, SFX, Voice, Ambience.
3. Assign your event libraries.
4. Turn the entity into a prefab, set the wrapper entity to Editor Only, and save.
5. Add the prefab to the Game Manager’s Startup Managers list.

This is the same prefab pattern every GS manager uses — see The Basics: GS_Managers if you have not set one up before.

Using Audio Without a Game Manager

If audio is the only GS feature your project uses, you do not need the manager stack at all.

Add the Audio Manager to your level, tick Headless on it, and press play. It starts itself, and everything on these pages works exactly as documented. No Game Manager, no startup sequence, no other managers.

This is the intended path for dropping GS_Audio into a project that is not otherwise built on GS_Play.

What It Manages

Setting the Listener

There is no listener component. The manager holds the listener and you point it at an entity.

For first person, point it at your camera or player and you are finished. For third person, split it — distance measured from your character, direction from your camera. See Spatial Audio for why that combination is the one you want.

If you never set a listener, the manager uses its own entity and warns. Audio will work, but it will be positioned from wherever your manager prefab happens to be.

Quick Reference

Glossary

See Also

For the full API:

• Framework API: Audio Manager

For related systems:

• The Basics: Audio Events — what the libraries hold
• The Basics: Mixing & Effects — the channels it owns
• The Basics: Spatial Audio — what the listener feeds
• The Basics: GS_Managers — the manager pattern

Get GS_Audio

GS_Audio — Explore this gem on the product page and add it to your project.

2 - Audio Events

Base — ships in GS_Audio.

An audio event is a named sound your game can fire. You author events in an event library asset, assign the library to the Audio Manager, and then play sounds by name from anywhere — script, C++ or a trigger volume.

Everything that makes a sound behave well in a game — variation, distance falloff, a cap on how many can play at once, following a moving object — is configured on the event, not at the call site. Firing one is always just a name.

For component properties and the extension guide, see the Framework API reference.

Contents

• Creating an Event Library
• Choosing an Event Type
• Making Sounds Vary
• Distance and Concurrency
• Firing Events
• Quick Reference
• Glossary
• See Also

Creating an Event Library

1. In the Asset Browser, create a new Audio Event Library (.aev) asset.
2. Add an event to it and pick a type from the dropdown.
3. Give it an Event Name — this is what you fire by.
4. Set its Mixing Channel so it routes to the right volume channel.
5. Assign the library to your Audio Manager’s library list.

Libraries can also be added and removed while the game is running, which is how you would stream in a level’s sound set.

Choosing an Event Type

Noise and Sfxr events need no audio files at all. They generate their sound at runtime, which makes them useful early in a project when the audio pass has not happened yet.

Making Sounds Vary

Both Pool and Sfxr events hold a pool, and pick from it at random on every fire.

This is the single highest-value thing to know about the event system. A footstep event with one clip sounds mechanical after three steps. The same event with five recorded variants sounds like walking — and the code firing it does not change at all.

For Sfxr events the pool is even cheaper to fill: generate a sound at sfxr.me, press mutate a few times, and import each result as a profile. Five mutated explosions in one pool means the explosion never repeats identically.

A pool of one is perfectly valid. It is just a sound that does not vary.

Distance and Concurrency

The last two matter more than they look. A collision sound fired from a physics callback can trigger dozens of times in a few frames; the concurrency limit and repeat hold are what keep that from turning into noise, without any logic on your side.

Firing Events

Three calls on AudioManagerRequestBus, all resolving the event by name:

PlayEventOnEntity keeps tracking the entity as it moves, so it is the right choice for anything attached to a character, vehicle or projectile.

Quick Reference

Glossary

See Also

For the full API and the extension guide:

• Framework API: Audio Events

For related systems:

• The Basics: Audio Manager — loads your libraries
• The Basics: SFXR Profiles — what Sfxr events play
• The Basics: Mixing & Effects — where an event’s channel routes

Get GS_Audio

GS_Audio — Explore this gem on the product page and add it to your project.

3 - SFXR Profiles

Base — ships in GS_Audio.

SFXR profiles are sound effects made entirely of numbers. No recording, no audio files, no disk space worth mentioning — a coin pickup, a laser shot or a jump blip described as a parameter set.

They are the fastest way to get real sound into a project, and 27 of them ship with the gem, so a new project has working effects before it has any audio of its own.

For the parameter reference, see the Framework API reference.

Contents

• Making a Sound
• Using Profiles
• Building a Variation Pool
• What Ships With the Gem
• Glossary
• See Also

Making a Sound

The intended workflow runs through the browser, because that is where the instant preview is.

1. Open sfxr.me.
2. Pick a generator — Pickup, Laser, Explosion, Powerup, Hurt, Jump, Blip — and press it until you like what you hear. Or press Mutate on a sound you already like.
3. Press Serialize and copy the JSON it gives you.
4. In O3DE, create a new SFXR Profile (.sfxrprofile) asset.
5. Open its Import from sfxr.me group and paste the JSON into the field.
6. The parameters populate. Save.

You can also edit the 24 parameters by hand on the asset afterwards — the import is a starting point, not a lock.

Using Profiles

A profile is played through an Sfxr audio event:

1. Add an event to your event library and set its type to Sfxr.
2. Add one or more profiles to the event’s profile list.
3. Fire the event by name like any other sound.

Audio Pro users can also drop an Sfxr node into an Audio Event Graph and feed it profiles the same way.

Building a Variation Pool

An Sfxr event holds a list of profiles and picks one at random every time it fires.

This is where the browser workflow pays off. Make an explosion you like, press Mutate four times, and import all five results. Drop them into one event and your explosion never sounds the same twice — with no logic anywhere in your game.

An event with one profile is fine, and an event with an empty list is simply silent.

What Ships With the Gem

27 profiles in the gem’s Assets/SFXR Profiles/ folder:

• 7 classic presets — Coin, Laser, Explosion, Powerup, Hurt, Jump, Blip.
• 20 named custom profiles.

Use them directly, or open one and mutate it into something of your own.

Glossary

See Also

For the parameter reference:

• Framework API: SFXR Profiles

For related systems:

• The Basics: Audio Events — how profiles get played

Get GS_Audio

GS_Audio — Explore this gem on the product page and add it to your project.

4 - Mixing & Effects

Base — ships in GS_Audio.

Mixing has two jobs, and they are worth keeping separate in your head.

Volume channels group sounds by what kind of sound they are — voice, music, environment, combat — so a player can turn one down without touching the others. This is what your options menu drives.

Effect chains process the signal — filters, EQ, delay, reverb, and character effects like chorus and bit-crushing. You build a chain on a component, name it, and point sounds at that name.

All 22 effects are available in the free gem. Audio Pro authors the same processors on a visual canvas instead.

For component properties and the full effect reference, see the Framework API reference.

Contents

• Volume Channels
• Building an Effect Chain
• The Effects
• Environmental Influence Zones
• Quick Reference
• Glossary
• See Also

Volume Channels

Channels are configured on the Audio Manager as a named list. Each audio event names the channel it routes to.

Set them up the way your options menu will present them — a Voice channel, a Music channel, an SFX channel — and wiring the sliders becomes trivial, because the options system can drive channel levels directly.

Channels are independent of position. A footstep, a spell and a line of dialogue are all spatialized the same way, and all three route to different channels.

Building an Effect Chain

1. Add a Mix Effect component to an entity.
2. Give it a Name — this is what sounds and other chains will target.
3. Add effects to its list. They run top to bottom.
4. Set its Output Target — another chain’s name, or a volume channel.

Then point sounds at it by setting an event’s Mixing Channel to your chain’s name. Channels and chains share one namespace, so a sound does not care which kind of thing it is aimed at.

Three things that make this easier than it sounds:

• Order does not matter. If a chain points at something that does not exist yet, the connection waits and completes when it appears. You never have to think about activation order.
• You can add chains at runtime. Sounds already playing through that channel pick up the new routing.
• One entity can hold several chains. Give each its own name and point one at another to compose them.

You can put a chain on the emitting entity to colour just that object’s sound, or use shared global chains for project-wide treatments. Both work, and most projects use both.

The Effects

Environmental Influence Zones

A world entity can push effects onto channels while the player is inside it — walk into a cave and everything gains reverb, walk out and it lifts.

Zones stack by priority, so overlapping zones resolve predictably rather than by whichever fired last, and each zone’s contribution is tracked against the entity that applied it so removing it is unambiguous.

Quick Reference

Glossary

See Also

For the full API and the effect reference:

• Framework API: Mixing & Effects
• Framework API: Mix Effects

For related systems:

• The Basics: Audio Manager — owns the channel list
• The Basics: Audio Events — how a sound picks its channel
• The Basics: Spatial Audio — positioning, which is separate from mixing

Get GS_Audio

GS_Audio — Explore this gem on the product page and add it to your project.

5 - Spatial Audio

Base — ships in GS_Audio.

Spatial audio is handled for you. Fire a sound at a position or on an entity and it is placed in the world: direction, distance falloff, and HRTF binaural processing so it sounds like it is coming from somewhere rather than from inside your head.

There is nothing to add to a sound to make this happen, and nothing to add to a chain. The only thing you configure is the listener — where the player is hearing from.

For settings and behaviour detail, see the Framework API reference.

Contents

• Setting the Listener
• Third-Person: Splitting the Listener
• Distance Falloff
• What This Does Not Do
• Quick Reference
• Glossary
• See Also

Setting the Listener

There is no listener component to add. The Audio Manager carries the listener, and you point it at an entity.

For a first-person game, that is the whole setup — point it at the camera or the player and you are done.

If you set nothing, the manager falls back to its own entity and warns you. That fallback exists so the system is never silently broken, but it is not where you want your listener.

Third-Person: Splitting the Listener

In third person the camera and the character are in different places, and “where is the player hearing from” has two different right answers.

• How close a sound is should be measured from the character. Proximity is about your body.
• Which direction a sound is in should be measured from the camera. Left and right are about where you are looking.

So set them separately:

This is the recommended third-person setup, and the difference is immediately audible — sounds sit where you expect instead of drifting with the camera boom.

For first person, use the single-target call and let both follow one entity.

Distance Falloff

Each audio event sets its own Distance Min / Max:

• Inside min, the sound plays at full volume.
• Between min and max, it fades.
• At max it is genuinely silent — not faintly audible forever.

That last point is deliberate. Physically accurate falloff never quite reaches zero, which leaves distant sounds quietly cluttering the mix. Max distance here means what it says.

Reverb behaves slightly differently: it stays constant until three quarters of the way out, then eases off. A room sounds like the same room wherever you stand in it, while the dry sound still gets quieter as you walk away.

What This Does Not Do

Worth knowing before you evaluate the result:

• Nothing is blocked by geometry. A sound behind a wall is quieter because it is further away, not because the wall is there. Occlusion needs Audio Pro.
• Up, down, in front and behind are subtle. Left and right are clear and reliable. Elevation and front/back are inherently weak cues with a generic HRTF — that is the technique, not a bug.

Quick Reference

Glossary

See Also

For settings and behaviour detail:

• Framework API: Spatialization

For related systems:

• The Basics: Audio Manager — where the listener lives
• The Basics: Audio Events — per-sound distance settings

Get GS_Audio

GS_Audio — Explore this gem on the product page and add it to your project.

6 - Audio Pro

GS_AudioPro is the premium audio gem. It sits on top of GS_Audio — everything in the free gem keeps working exactly as it did, and Pro adds four things of its own.

Contents

• Adding Pro to a Project
• Where Each Feature Lives
• Features
• See Also

Adding Pro to a Project

1. Enable the GS_AudioPro gem alongside GS_Audio.
2. Open your Audio Manager prefab and use the Pro Audio Manager component in place of the base one.
3. Assign your graph libraries and score tracks on it, and save.

The Pro manager does everything the base one does — volume channels, event libraries, listener, project settings are all still there, with Pro’s geometry settings added alongside them.

You cannot run both managers at once. A project uses the base manager or the Pro one.

Where Each Feature Lives

Pro’s features each have their own bus, separate from the Audio Manager’s. Playing sounds, volume and mixing stay exactly where they are on AudioManagerRequestBus.

Features

Audio Event Graph

Author a sound as a graph. Drop in sources, filters and effects, wire them together, and route the result — with a Start / Loop / Finish lifecycle and variables your game can drive while the sound is playing.

Audio Event Graph

Score Arrangement

Multi-layer music. One arrangement holds several layers with a shared tempo and time signature, and you bring them in and out as the game changes — add percussion for combat, drop it when it ends.

Score Arrangement

Klatt Voice

Speech generated from parameters rather than recordings. Give every character a distinct voice without a recording session, and use inline tags to change pitch or speed partway through a line.

Klatt Voice

Geometric Acoustics

Mark up your level with acoustic volumes and materials, and sounds start being genuinely blocked by what is between them and the player — with reverb that comes from the room they are standing in.

Geometric Acoustics

See Also

For the free gem this builds on:

• The Basics: GS_Audio

For the full API:

• Framework API: Audio Pro

Get GS_Audio

GS_Audio — Explore this gem on the product page and add it to your project.

6.1 - Audio Event Graph

The Audio Event Graph is a visual node-based editor for authoring complex sound events. Instead of a single clip pool, you connect sources, filters, effects, and routing nodes into a graph that evaluates as a data-flow pipeline. Each .audiograph file is one sound event. At runtime, the graph maps directly to a live audio processing chain.

For component properties and C++ extension, see the Framework API reference.

Contents

• How It Works
• Phase Lifecycle
• Nodes
• Using Variables
• Playing at Runtime
• Quick Reference
• Glossary
• See Also

How It Works

Nodes in an Audio Event Graph evaluate left to right in topological order. Connections carry AudioRoute values — handles to a point in the audio processing chain. The signal flows through:

1. An Entry node gates which phase is active
2. Source nodes create and output audio
3. Filter and effect nodes process the signal
4. Routing nodes (If/Switch) direct the signal based on variables
5. The Output node wires everything to a mixing bus

Only nodes affected by a change re-evaluate — the rest are skipped. This makes variable-driven sound modification cheap even for complex graphs.

Phase Lifecycle

Every Audio Event Graph supports up to three phases:

Phases transition automatically: Start fires once, Loop repeats while looping is enabled, Finish plays when FinishAudioGraph() is called. Not all phases are required — a simple one-shot only needs Start.

Entry nodes share routing freely. A source wired to both Start and Loop phases produces sound in both.

Nodes

Source Nodes

Both support volume, pitch, delay, looping, and 3D spatialization.

Filter Nodes

LowPass, HighPass, BandPass, Notch, PeakingEQ, LowShelf, HighShelf — all take audio_in and output audio_out. Parameters (cutoff, Q, gain) can be set per-node or bound to graph variables.

Effect Nodes

Routing Nodes

IfNode and SwitchNode route AudioRoute values based on conditions or a selector variable. Use these for conditional audio paths — different sounds based on surface type, weather, or character state.

Output Node

Aud_OutputNode wires the final signal to a named mixing bus. Every graph needs exactly one Output node.

Using Variables

Declare variables in the Variable Panel. Bind them to filter parameter slots (right-click > Convert to Reference) or use If/Switch nodes to route based on them.

At runtime, setting a variable re-evaluates only the nodes that depend on it — the rest of the graph is untouched.

Common patterns:

Variables are set from gameplay code via the Audio Manager:

SetAudioGraphVariable(instanceId, "underwater", 0.8)
SetAudioGraphVariableBool(instanceId, "isSprinting", true)

Playing at Runtime

All Audio Event Graph playback goes through the Audio Manager.

Fire-and-Forget

For one-shot sounds with no runtime modification needed:

PlayAudioGraph("Assets/Audio/Explosion.audiograph")

Manual Control

For sounds that loop, need variable updates, or need explicit stopping:

1. AcquireAudioGraph(assetPath) — get an instance ID
2. SetAudioGraphLooping(id, true) — if it loops
3. SetAudioGraphEntity(id, entityId) — for 3D tracking
4. FireAudioGraph(id) — start playback
5. SetAudioGraphVariable(id, name, value) — update variables any time
6. StopAudioGraph(id) or FinishAudioGraph(id) — stop cleanly
7. ReleaseAudioGraph(id) — return the instance to the pool

Quick Reference

Glossary

For full definitions, see the Glossary.

See Also

• Framework API: Audio Event Graph — Full node catalog and extension guide
• The Basics: Audio Manager — Runtime playback API
• The Basics: Audio Events — Simpler fire-and-forget sound playback
• The Basics: Mixing — Mixing buses that graphs route through

Get GS_Audio

GS_Audio — Explore this gem on the product page and add it to your project.

6.2 - Geometric Acoustics

The free gem places sounds by direction and distance — a sound behind a wall is quieter because it is further away, not because the wall is there.

Geometric acoustics makes the wall matter. Mark up your level and sounds get occluded by what is between them and the player, and pick up reverb from the room the player is actually standing in.

For settings and behaviour detail, see the Framework API reference.

Contents

• Setting It Up
• Marking Up a Level
• Choosing Materials
• Tuning Occlusion
• Tuning Reverb
• What It Does Not Do
• See Also

Setting It Up

Geometric acoustics is off until you turn it on.

1. Select your Pro Audio Manager.
2. Tick Geometry Enabled.
3. Leave Occlusion and Reflections on unless you specifically want one without the other.

Nothing happens yet — the simulation has no geometry to work with until you mark some up.

Marking Up a Level

You do not hand the system your level meshes. You mark up the parts that matter acoustically — walls, floors, doorways, the big surfaces that shape a room.

Two components do it:

A practical starting point: block out the room a player will spend the most time in, tag its walls and floor, and listen. You will hear the difference immediately, and you can decide from there how much of the rest of the level is worth marking up.

Choosing Materials

Every piece of geometry carries a material preset. Fifteen ship, in three useful groups:

The soft-barrier group is worth knowing about. A curtain across a doorway does not silence what is behind it, it dulls it — the effect people usually fake with a low-pass filter. Here you get it by picking the right material.

If none of the presets fit, Custom exposes all seven coefficients directly.

Tuning Occlusion

Two modes:

• Raycast — one ray. A sound is occluded or it is not. Cheap.
• Volumetric — samples a sphere around the source, so sound leaks partially around edges. Costs more.

If occlusion sounds like a switch flicking as the player walks past a doorframe, use Volumetric. That partial-occlusion behaviour at edges is exactly what it exists for. Occlusion Radius controls how wide the sampled sphere is.

Tuning Reverb

Reverb comes from the geometry around the player, and updates as they move.

Two behaviours that are deliberate, so you do not go hunting for a bug:

• It eases between rooms. Walking through a doorway blends the reverb rather than snapping it. Reflection Smooth Time controls how long that takes — set it to 0 if you want an instant change.
• It does not get quieter as you walk away from a sound. The room sounds like the same room wherever you stand in it, while the dry sound still falls off with distance. That is correct, and it is what makes a large space feel large.

What It Does Not Do

• Reverb cannot tell your room from the one next door. It is computed around the player, so a sound sealed in an adjacent room still feeds the same reverb.
• An occluded sound still feeds the reverb. Occlusion muffles the direct sound; it does not stop the source exciting the room.
• It only knows about geometry you marked up. Render meshes and physics colliders are not consulted.
• There is no baking. Everything is computed at runtime.

See Also

For settings and behaviour detail:

• Framework API: Geometric Acoustics

For related systems:

• The Basics: Spatial Audio — the base layer this builds on
• The Basics: Mixing & Effects — the manual reverb this replaces
• The Basics: Audio Pro — the rest of the premium tier

Get GS_Audio

GS_Audio — Explore this gem on the product page and add it to your project.

6.3 - Score Arrangement

Score Arrangement Tracks are multi-layer music assets for dynamic, adaptive game music. Each arrangement defines a time signature, tempo, fade behavior, and a set of independently controllable Score Layers. This enables music that responds to gameplay — adding percussion during combat, muting melody during dialogue, or transitioning between intensity levels.

For asset structure and playback API, see the Framework API reference.

Contents

• How It Works
• Supported Time Signatures
• Glossary
• See Also

How It Works

A Score Arrangement Track is a data asset containing:

Each Score Layer is an independent audio stream within the arrangement. Layers can be enabled or disabled at runtime, creating dynamic music that evolves based on game state.

Supported Time Signatures

4/4, 4/2, 12/8, 2/2, 2/4, 6/8, 3/4, 3/2, 9/8

Glossary

For full definitions, see the Glossary.

See Also

For the full API, component properties, and C++ extension guide:

• Framework API: GS_Audio

For related systems:

• The Basics: Audio Manager

Get GS_Audio

GS_Audio — Explore this gem on the product page and add it to your project.

6.4 - Klatt Voice Synthesis

GS_Play includes a built-in text-to-speech system based on Klatt formant synthesis. The KlattVoiceComponent converts text to speech in real time with configurable voice parameters. Voices are positioned in 3D space and attenuate with distance, making synthesized speech feel like it comes from the character speaking.

For component properties, voice parameter details, and the phoneme mapping system, see the Framework API reference.

Contents

• How It Works
• Voice Configuration
• KTT Tags
• Phoneme Maps
• 3D Spatial Audio
• Quick Reference
• Glossary
• See Also

How It Works

1. Configure a voice using a KlattVoiceProfile — set frequency, speed, waveform, formants, and pitch variance.
2. Assign a KlattPhonemeMap — maps text characters to ARPABET phonemes for pronunciation.
3. Speak text from ScriptCanvas or C++ — the system converts text to phonemes and synthesizes audio in real time.
4. Position in 3D — the voice component uses KlattSpatialConfig for 3D audio positioning relative to the entity.

Voice Configuration

KTT Tags

KTT (Klatt Text Tags) allow inline parameter changes within speech text for expressive delivery:

"Hello <speed=0.5>world</speed>, how are <pitch=1.2>you</pitch>?"

The KlattCommandParser processes these tags during speech synthesis, enabling mid-sentence changes to speed, pitch, and other voice parameters.

For the complete tag reference — all attributes, value ranges, and reset behavior — see the Framework API: KTT Voice Tags.

Phoneme Maps

Two base phoneme maps are available:

Custom phoneme overrides allow project-specific word pronunciations (character names, fantasy terms) without modifying the base map.

3D Spatial Audio

The KlattSpatialConfig controls how synthesized speech is positioned in 3D:

• Voices attenuate with distance from the listener.
• The KlattVoiceSystemComponent tracks the listener position and updates all active voices.
• Multiple characters can speak simultaneously with correct spatial positioning.

Quick Reference

Glossary

For full definitions, see the Glossary.

See Also

For the full API, component properties, and C++ extension guide:

• Framework API: GS_Audio

For related systems:

• The Basics: Audio Manager

Get GS_Audio

GS_Audio — Explore this gem on the product page and add it to your project.