GS_Audio

1 - Audio Manager

The Audio Manager is the master audio controller for every GS_Play project. It extends GS_ManagerComponent and participates in the standard two-stage initialization managed by the Game Manager. On startup it initializes the MiniAudio engine, creates the named mixing bus graph, and coordinates score track playback.

Like all GS_Play managers, the Audio Manager responds to standby mode automatically — muting or pausing audio output when the game enters a blocking operation such as a stage change.

For usage guides and setup examples, see The Basics: GS_Audio.

Contents

• How It Works
• Inspector Properties
• API Reference
  • Audio Event Graph
  • Mixing
  • Score
  • Notifications
• See Also

How It Works

Engine Lifecycle

When the Audio Manager activates, it initializes a MiniAudio engine instance and builds the mixing bus graph from its configured bus list.

Mixing Bus Routing

All audio output flows through named mixing buses. Each bus is a GS_MixingBus node in the MiniAudio graph with its own volume level and optional effects chain. The Audio Manager owns the top-level routing and exposes volume control per bus through the request bus.

Audio Event Graph Pooling

The Audio Manager maintains a template cache and instance pool for Audio Event Graphs. When a graph is played:

• First request for a path loads and caches the GraphDocumentAsset
• A GraphInstance is created from the cached asset
• On release, idle instances are pooled for reuse (default pool size: 8)
• Each instance is fully independent — variables, phase, and state do not bleed between instances

Score Playback

The Audio Manager coordinates playback of ScoreArrangementTrack assets — multi-layer musical scores with configurable tempo, time signature, and layer selection.

Inspector Properties

API Reference

GS_AudioManagerComponent

Audio Event Graph

Instanced, visual-graph-based sound events with full lifecycle control, variable injection, and 3D spatialization.

Playback Control

Lifecycle

Variable Control

Set graph variables at runtime to drive filter parameters, routing, and source selection.

Setting a variable marks dependent nodes dirty and re-evaluates only the affected portion of the graph on the next tick.

3D Spatialization

Usage Pattern

// Fire-and-forget
AudioManagerRequestBus::Broadcast(&AudioManagerRequests::PlayAudioGraph,
    "Assets/Audio/Footstep_Stone.audiograph");

// Manual control with variable injection
AZ::u32 instanceId = 0;
AudioManagerRequestBus::BroadcastResult(instanceId,
    &AudioManagerRequests::AcquireAudioGraph,
    "Assets/Audio/Ambience_Forest.audiograph");

AudioManagerRequestBus::Broadcast(&AudioManagerRequests::SetAudioGraphLooping, instanceId, true);
AudioManagerRequestBus::Broadcast(&AudioManagerRequests::SetAudioGraphEntity, instanceId, entityId);
AudioManagerRequestBus::Broadcast(&AudioManagerRequests::FireAudioGraph, instanceId);

// Later: set a variable to mute underwater
AudioManagerRequestBus::Broadcast(&AudioManagerRequests::SetAudioGraphVariable,
    instanceId, "underwater", 0.8f);

// Stop when done
AudioManagerRequestBus::Broadcast(&AudioManagerRequests::StopAudioGraph, instanceId);
AudioManagerRequestBus::Broadcast(&AudioManagerRequests::ReleaseAudioGraph, instanceId);

Mixing

Score

Notification Bus: AudioManagerNotificationBus

Events broadcast by the Audio Manager. Multiple handler bus — any number of components can subscribe.

See Also

• Audio Event Graph — Visual graph editor for sound events
• Mixing & Effects — Mixing buses and effects chains
• Score Arrangement — Multi-layer music scoring
• Manager Base Class — The base class pattern for all managers

Get GS_Audio

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

2 - Audio Event Graph

The Audio Event Graph is an FMOD-style visual editor for authoring complex sound events. Each .audiograph file defines one sound event as a node graph — sources, filters, effects, and routing all connected visually. At runtime, the graph maps directly to a miniaudio processing pipeline.

The Audio Event Graph uses the gs_graphcanvas framework with a DataFlowGraph topology. Nodes evaluate in topological order with dirty-propagation — only nodes affected by a change are re-evaluated.

Contents

• Opening the Editor
• How It Works
• Node Catalog
• Phase Lifecycle
• Using Variables
• Extending with Custom Nodes
• Runtime API
• See Also

Opening the Editor

Open the Audio Event Graph editor from the O3DE Editor menu: GS Tools > Audio Event Graph Editor.

Each graph is a standalone .audiograph file — use File > New to create one, or File > Open to load an existing graph. Multiple graphs can be open simultaneously in separate tabs.

How It Works

Audio Event Graphs use a data-flow model. Connections carry AudioRoute values — handles that represent a point in the miniaudio processing chain. The signal flows left to right:

1. Entry nodes gate which phase is active (Start, Loop, or Finish)
2. Source nodes create sound instances and output an AudioRoute
3. Filter and effect nodes process the audio and pass it along
4. Routing nodes (If/Switch) direct the signal based on conditions or variables
5. The Output node wires the final AudioRoute to a mixing bus

Variables can be set from gameplay code at any time, causing affected nodes to re-evaluate without restarting the entire graph.

Node Catalog

Entry Nodes (Phase Gates)

Entry nodes output a gate signal. Downstream nodes only produce audio when their entry gate is active.

Source Nodes

Filter Nodes

All filter nodes take an audio_in input and produce an audio_out output. Filter parameters (cutoff frequency, Q factor, gain) are configurable per-node or bindable to variables.

Effect Nodes

Routing Nodes

The built-in gs_graphcanvas IfNode and SwitchNode work with AudioRoute values. Use them for conditional audio paths based on game state variables (e.g., play different sounds based on surface type or weather).

Terminal Node

Every graph needs exactly one Output node.

Phase Lifecycle

Audio Event Graphs support a three-phase lifecycle for structured sound playback:

1. Start — Initial playback. The Aud_StartNode gate is active. One-shot intro sounds play here.
2. Loop — Repeating section. The Aud_LoopNode gate is active. Ambient loops and sustained sounds live here.
3. Finish — Outro/tail. The Aud_FinishNode gate is active. Fade-outs and release tails play here.

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

Using Variables

Variables let gameplay code control sound behavior at runtime. Common uses:

• Filter parameters — Bind a filter’s cutoff frequency to a variable, then adjust it from code (e.g., underwater muffling)
• Routing conditions — Use a variable as the condition for an If/Switch node to select different sound paths
• Source selection — Gate different source nodes based on game state

Declare variables in the Variable Panel, then either bind them to input slots (right-click > Convert to Reference) or use Get/Set variable nodes.

At runtime, set variables via the Audio Manager API:

AudioManagerRequestBus::Broadcast(&AudioManagerRequests::SetAudioGraphVariable, instanceId, "underwater", 0.8f);

Setting a variable marks dependent nodes dirty and re-evaluates only the affected portion of the graph.

Extending with Custom Nodes

To add a custom audio node:

1. Create a class inheriting from BaseNode and IDataFlowNode
2. Register it with GS_AUTO_REGISTER_NODE_FOR(MyAudioNode, "audiograph")
3. Implement Process(GraphExecutionContext& context)
4. Follow the empty any pattern for inactive outputs:

void MyAudioNode::Process(GraphExecutionContext& context)
{
    auto inputAny = context.GetInputValueAny(this, "audio_in");
    if (inputAny.empty())
    {
        context.SetOutputValueAny(this, "audio_out", AZStd::any{});  // CRITICAL: truly empty
        return;
    }
    // Process audio...
    context.SetOutputValue(this, "audio_out", outputRoute);
}

The empty any pattern ensures that inactive paths don’t mask valid audio from other connections in multi-input slots.

For full details on node creation, see gs_graphcanvas Nodes.

Runtime API

Audio Event Graphs are played through the Audio Manager component. Key methods:

See the Audio Manager documentation for the full API reference.

See Also

• gs_graphcanvas Framework — The underlying framework
• Audio Manager — Runtime audio management and playback API
• Audio Events — Simple event-based sound playback (non-graph)
• Mixing & Effects — Mixing buses and effects chains

3 - Mixing & Effects

GS_Audio provides a named mixing bus system built on custom MiniAudio nodes. Each GS_MixingBus is a node in the audio graph with its own volume level and an optional chain of audio filters. Buses are configured in the Audio Manager Inspector and can be controlled at runtime through the mixing request bus.

The effects system includes 9 built-in filter types covering frequency shaping, equalization, delay, and reverb. Environmental influence effects allow game world volumes (rooms, weather zones) to push effects onto buses with priority-based stacking.

For usage guides and setup examples, see The Basics: GS_Audio.

Contents

• GS_MixingBus
• API Reference
• Audio Filters
• Data Structures
• See Also

GS_MixingBus

Custom MiniAudio node for mixing and effects processing.

API Reference

Request Bus: GS_MixingRequestBus

Mixer control commands. Singleton bus – Single address, single handler.

Audio Filters

All 9 built-in filter types. Each filter is configured as part of an effects chain applied to a mixing bus.

Data Structures

BusEffectsPair

Maps a bus name to an effects chain configuration. Used in the Audio Manager’s Inspector to define per-bus effects at design time.

AudioBusEffects

A collection of audio filter configurations that form an effects chain on a mixing bus.

AudioBusInfluenceEffects

Environmental effects with priority-based stacking. Game world volumes (rooms, weather zones, underwater areas) push influence effects onto mixing buses. Higher priority influences override lower ones.

See Also

For conceptual overviews and usage guides:

• GS_Audio Overview – Top-level audio gem documentation
• The Basics: GS_Audio – Scripting-level usage guide

For component references:

• Audio Manager – Master controller that owns the mixing bus graph

For related resources:

• Audio Events – Events route their output through mixing buses

Get GS_Audio

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

4 - Score Arrangement

The Score Arrangement system provides multi-layer dynamic music for GS_Play projects. A ScoreArrangementTrack asset defines a musical score with configurable tempo, time signature, fade behavior, and multiple layers that can be enabled or disabled at runtime. This allows game music to adapt to gameplay state – adding or removing instrumental layers, changing intensity, or crossfading between sections.

Score tracks are loaded and controlled through the Audio Manager request bus.

For usage guides and setup examples, see The Basics: GS_Audio.

Contents

• Data Model
• See Also

Data Model

ScoreArrangementTrack

A multi-layer musical score asset. Each track defines the musical structure and contains one or more layers that play simultaneously.

ScoreLayer

A single musical layer within a score arrangement. Each layer represents one track of audio (e.g. drums, bass, melody) that can be independently enabled or disabled.

TimeSignatures (Enum)

Supported musical time signatures for score arrangement tracks.

See Also

For conceptual overviews and usage guides:

• GS_Audio Overview – Top-level audio gem documentation
• The Basics: GS_Audio – Scripting-level usage guide

For component references:

• Audio Manager – Controls score playback via the request bus

Get GS_Audio

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

5 - Klatt Voice Synthesis

The Klatt Voice Synthesis system provides custom text-to-speech for GS_Play projects using Klatt formant synthesis with full 3D spatial audio. It uses SoLoud internally for speech generation and MiniAudio for spatial positioning.

The system has two layers:

• KlattVoiceSystemComponent – A singleton that manages the shared SoLoud engine instance and tracks the 3D audio listener position.
• KlattVoiceComponent – A per-entity component that generates speech, queues segments, applies voice profiles, and emits spatialized audio from the entity’s position.

Voice characteristics are defined through KlattVoiceProfile assets containing frequency, speed, waveform, formant, and phoneme mapping configuration. Phoneme maps convert input text to ARPABET phonemes for the Klatt synthesizer, with support for custom pronunciation overrides.

For usage guides and setup examples, see The Basics: GS_Audio.

Contents

• Components
• API Reference
• Data Types
• Enumerations
• KTT Voice Tags
• Combined Example
• See Also

Components

KlattVoiceSystemComponent

Singleton component that manages the shared SoLoud engine and 3D listener tracking.

KlattVoiceComponent

Per-entity voice component with spatial audio, phoneme mapping, and segment queue.

API Reference

Request Bus: KlattVoiceSystemRequestBus

System-level voice management. Singleton bus – Single address, single handler.

Request Bus: KlattVoiceRequestBus

Per-entity voice synthesis controls. Entity-addressed bus – Single handler per entity ID.

Notification Bus: KlattVoiceNotificationBus

Events broadcast by voice components. Multiple handler bus – any number of components can subscribe.

Data Types

KlattVoiceParams

Core voice synthesis parameters controlling the Klatt formant synthesizer output.

KlattVoiceProfile

A voice profile asset combining synthesis parameters with a phoneme mapping.

KlattVoicePreset

A preset configuration for quick voice setup.

KlattSpatialConfig

3D spatial audio configuration for voice positioning.

KlattPhonemeMap

Phoneme mapping asset for text-to-ARPABET conversion with custom overrides.

PhonemeOverride

A custom pronunciation rule that overrides the base phoneme map for a specific word or pattern.

Enumerations

KlattWaveform

Glottal waveform types available for the Klatt synthesizer.

BasePhonemeMap

Available base phoneme dictionaries for text-to-ARPABET conversion.

KTT Voice Tags

KTT (Klatt Text Tags) are inline commands embedded in strings passed to KlattVoiceComponent::SpeakText. They are parsed by KlattCommandParser::Parse and stripped from the spoken text before synthesis begins — they are never heard.

Format: <ktt attr1=value1 attr2=value2>

Multiple attributes can be combined in a single tag. Attribute names are case-insensitive. String values may optionally be wrapped in quotes. An empty value (e.g. speed=) resets that parameter to the voice profile default.

speed=X

Override the speech speed multiplier from this point forward.

Normal speech <ktt speed=2.0> fast bit <ktt speed=> back to default.

decl=X / declination=X

Pitch declination — how much pitch falls over the course of the utterance. Both decl and declination are accepted.

Rising <ktt decl=0.0> steady <ktt decl=0.8> falling voice.

waveform="TYPE"

Change the glottal waveform used by the synthesizer, setting the overall character of the voice.

<ktt waveform="noise"> whispered section <ktt waveform="saw"> normal voice.

vowel=X

First formant (F1) frequency multiplier. Shifts the quality of synthesised vowel sounds.

<ktt vowel=1.4> different vowel colour here.

accent=X

Second formant (F2) frequency multiplier. Shifts accent or dialect colouration.

<ktt accent=0.8> shifted accent here.

pitch=X

F0 pitch variance amount. Controls how much pitch varies during synthesis.

<ktt pitch=2.0> very expressive speech <ktt pitch=0.1> flat monotone.

pause=X

Insert a pause of X seconds at this position in the voice playback. Value is required — there is no default.

Hello.<ktt pause=0.8> How are you?

Combined Example

Dialogue string using typewriter text commands and KTT voice tags together:

[b]Warning:[/b] [color=#FF0000]do not[/color] proceed.[pause=1]
<ktt waveform="square" pitch=1.8>This is a mechanical override.<ktt pause=0.5><ktt waveform="saw" pitch=1.0>
[speed=3]Resuming normal protocol.[/speed]

See Also

For conceptual overviews and usage guides:

• GS_Audio Overview – Top-level audio gem documentation
• The Basics: GS_Audio – Scripting-level usage guide

For component references:

• Audio Manager – Manager lifecycle that the voice system participates in

Get GS_Audio

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

6 - Third Party Implementations

This section will contain integration guides for connecting third-party audio middleware and tools with the GS_Audio system.

For usage guides and setup examples, see The Basics: GS_Audio.

Get GS_Audio

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