Node reference

Every node in Audity, grouped by its folder in the creation menu. For each node: In and Out list its ports with signal kind (Audio / Float / Trigger); Settings are its inspector fields. Unconnected Float inputs fall back to their inline field value.

Many Float nodes have a dynamic width: their pins adopt the width of whatever you wire in (scalar, Vector 2/3/4), so the same node handles a single number or a position. Where width is fixed it is called out.

Sources

Nodes that produce audio.

Wave Player

Plays Samples. The workhorse source.

In: Play (Trigger), Stop (Trigger), Pitch (Float), Gain (Float); Sample Set source (binding).
Out: out (Audio), On Finished (Trigger).
Settings: Sample Set (inline) or Sample Set asset; Voice Mode (Poly = overlapping voices, Cut = a new Play cuts the previous); Max Voices (voice cap, oldest is stolen past it); Pitch (semitones); Gain (dB).

The hosting AudioSource’s own Pitch applies to the source’s output the same way it does for any Unity content - author per-voice musical offsets on the Pitch pin, and treat the AudioSource’s Pitch as the whole-source knob it is everywhere else in Unity.

The selection policy (which Sample plays when the Set holds several) lives on the Sample Set. See Samples and sample sets.

Noise

A noise generator. Mono; for stereo noise, Join two Noise nodes with different seeds - they render uncorrelated streams.

In: Gain (Float).
Out: out (Audio, mono).
Settings: Color; Gain (dB); Seed.

Four colours, darkest to brightest:

Colour	Tilt	Reach for it when
Brown	-6 dB/oct	Rumble, distant thunder, engine bed. The dark end.
Pink	-3 dB/oct	Wind, rain, general beds. Even energy per octave.
White	flat	Hiss, static, the raw ingredient for a filtered layer.
Blue	+3 dB/oct	Air, fizz, sparkle over the top of something darker.

Brown has a much higher crest factor than the others, so at the same Gain it measures quieter while peaking just as high. That is the spectrum, not a bug: turn it up rather than expecting it to match White by ear at 0 dB.

Impulse

Sparse random clicks at a density. One control takes it from an occasional tick through gravel underfoot to hiss, because impulses at a high enough density are noise. Use it as grain texture on its own, or as the exciter in front of a filter or delay for anything struck.

In: Density (Float, impulses per second), Variation (Float, 0..1), Gain (Float).
Out: out (Audio, mono).
Settings: the same values inline, plus Seed.

Variation is the difference between crackle and rain. At 0 every impulse is full scale, which reads as an even bed. Raise it and most impulses become quiet while a few stay loud, and those outliers are what the ear hears as discrete crackles.

Density is a pin, not just a setting, and that is the point: envelope it and a burst of discharge sputters out, or drive it from speed and a scrape thins as the movement slows.

Oscillator

A sine, saw, square or triangle oscillator - the starting point for a subtractive patch. Mono, like every generator; widen late with Pan, Mono → Stereo, or Join.

In: Frequency (Float, Hz), Pulse Width (Float, 0.01..0.99), Gain (Float, dB), Sync (Trigger, resets phase).
Out: out (Audio, mono).
Settings: Shape (Saw, Square, Triangle, Sine); Frequency (default 440); Pulse Width (0.5 is a square; the other shapes ignore it); Phase Offset (degrees, for out-of-phase pairs); Gain (dB, default -18).

The three edged shapes are corrected at every discontinuity (PolyBLEP), so a swept or high oscillator does not smear the top octave with foldback the way a naive shape does. Sine is the pure, cheap case and needs no correction.

Gain defaults to -18 dB because a full-scale oscillator is far hotter than typical game audio; raise it deliberately rather than trimming everything else down. Wire the pin for tremolo or fades without a separate Gain node.

Mix

Mixer

Sums 2 to 8 audio inputs with per-input gain.

In: In 0..N (Audio), Gain 0..N (Float).
Out: out (Audio).
Settings: Input Count (2 to 8); per-input gains (dB).

Gain

Scales audio in decibels.

In: in (Audio), Gain (Float).
Out: out (Audio).
Settings: Gain (dB).

VCA

Audio times a control value: a linear VCA. Use it for envelopes, tremolo and ducking. Differs from Gain only in units (Mod is linear, Gain is dB).

In: in (Audio), Mod (Float, default 1).
Out: out (Audio).

Crossfade

Blends between two audio inputs.

In: a (Audio), b (Audio), Fade (Float; 0 = A only, 1 = B only).
Out: out (Audio).
Settings: Curve (Equal Power for uncorrelated sources, Linear for correlated layers of one recording).

Pan

Positions a mono source on a fixed speaker layout with constant-power pairwise gains (LFE stays silent).

In: in (Audio, mono), Azimuth (Float degrees; 0 = ahead, + = right, +/-180 = behind).
Out: out (Audio, width follows the layout).
Settings: Layout (Stereo, Quad, Surround 5.0, 5.1, 7.1).

Wire a Listener Info Azimuth into the Azimuth input to track the listener.

Layer Mixer

Vertical music layering in one node: a Mixer whose per-input gains follow authored curves of a shared Blend, so one game value fades a stack of stems in and out. See Musical timing.

In: In 0..N (Audio, one per stem), Blend (Float, 0..1).
Out: out (Audio).
Settings: Input Count (2 to 8); a per-input Curve of gain over Blend (each curve’s key range is that input’s window); Smoothing (seconds for Blend to sweep its full range, so a stepped value glides); inline Blend.

Fan one trigger into every stem’s Wave Player with the same launch quantize so the stems stay phase-locked; this node is only the remix.

Stereo Width

Narrows or widens the stereo image without changing what is common to both channels - the part of the sound that is the sound stays put, only the part that differs moves.

In: in (Audio), Width (Float; 0 = mono, 1 = unchanged, 2 = twice as wide).
Out: out (Audio, same width as the input).
Settings: Width.

Mid/side: Width scales the difference between the front pair and leaves their sum alone, so collapsing to mono loses no level. On a mono input the node passes through (there is no image to widen), and on a surround bed only the front pair moves - centre and LFE are placement, not image.

Effects

Every effect is an ordinary audio-domain node: the graph is the insert chain. All effect parameters are Float pins, so anything - a Parameter In, an ADSR, a Listener Info Distance - can drive them. For effects beyond this set, write a custom DSP node; the Bitcrusher in the Custom Nodes sample (Package Manager ▸ Audity ▸ Samples) is a worked example.

Filter

A multi-mode filter.

In: in (Audio), Cutoff (Float, Hz, default 22000), Resonance (Float, 0..1).
Out: out (Audio).
Settings: Type (Lowpass one-pole, Lowpass resonant, Highpass resonant, Bandpass); Cutoff; Resonance.

Delay

A feedback delay line.

In: in (Audio), Time (Float, seconds), Feedback (Float, 0..0.99), Mix (Float, 0 = dry, 1 = wet).
Out: out (Audio).
Settings: Max Time (seconds - sizes the delay line’s memory; Time clamps to it).

Time changes glide tape-style (a moving read head) instead of clicking.

Reverb

An algorithmic room (Freeverb topology), decorrelated per channel.

In: in (Audio), Size (Float, 0..1 - decay length), Damping (Float, 0..1 - high-frequency decay), Mix (Float, 0 = dry, 1 = wet).
Out: out (Audio).

The tail rings out after the input stops.

Compressor

A downward compressor with an optional sidechain detector.

In: in (Audio), Sidechain (Audio, optional - unwired, the main input drives the detector), Threshold (dB), Ratio, Attack (s), Release (s), Makeup (dB).
Out: out (Audio), Gain Reduction (Float, dB, ≤ 0).

Ducking is ordinary wiring: route the music through the Compressor, wire the dialogue bus into Sidechain - or wire Gain Reduction into any Gain to duck something the compressor never touches.

Limiter

A brickwall: instant attack, released ceiling.

In: in (Audio), Ceiling (dB), Release (s).
Out: out (Audio).

Parametric EQ

One EQ band; chain several in series for a multi-band curve.

In: in (Audio), Frequency (Hz), Gain (dB), Q.
Out: out (Audio).
Settings: Band (Peak, Low Shelf, High Shelf).

Shaper

Waveshaping distortion.

In: in (Audio), Drive, Mix (0 = dry, 1 = shaped), Input Gain (dB, pre-drive trim), Output Gain (dB, post-mix trim).
Out: out (Audio).
Settings: Shape (Tanh saturation, Hard Clip, Fold).

Chorus

Two slowly swept copies of the input, summed with the dry signal: thickening without the metallic ring of a flanger. On a multi-channel input each channel sweeps at its own offset, so the result widens as well as thickens.

In: in (Audio), Rate (Float, Hz), Depth (Float, 0..1), Mix (Float, 0 = dry, 1 = wet).
Out: out (Audio).

Depth 0 leaves a fixed 12 ms delay - useful on its own as a doubling.

Flanger

One very short swept delay fed back into itself: the moving comb.

In: in (Audio), Rate (Float, Hz), Depth (Float, 0..1), Feedback (Float, -0.95..0.95), Mix (Float).
Out: out (Audio).

Mix 0.5 is the deepest comb - at 1 there is no dry signal for the delayed copy to cancel against. Negative feedback gives the hollow variant.

Phaser

Six swept allpass stages summed with the dry signal, so the moving phase cancellation reads as travelling notches. No delay line, so it costs no pool memory.

In: in (Audio), Rate (Float, Hz), Depth (Float, 0..1), Feedback (Float, -0.95..0.95 - resonance around the notches), Mix (Float).
Out: out (Audio).

Comb Filter

A delay line tuned in Hz instead of seconds, fed back on itself: pitched resonance. Ring an impact through it for metal, pipe or body tone; sweep Frequency and the pitch glides with it.

In: in (Audio), Frequency (Float, 20..5000 Hz - the delay is one period of it), Feedback (Float, -0.99..0.99), Mix (Float).
Out: out (Audio).

Negative feedback gives the hollow odd-harmonic comb, an octave below what the same tuning gives with positive feedback.

Ring Modulator

The input multiplied by a carrier, sample for sample: inharmonic sidebands, nothing left at the original frequency. Robots, force fields, damaged machinery.

In: in (Audio), Carrier (Audio, optional), Frequency (Float, Hz - the internal carrier, ignored while Carrier is wired), Mix (Float).
Out: out (Audio).

Wire an Oscillator or a second source into Carrier for a harsher product than the internal sine gives.

Noise Gate

Shuts below Threshold and opens above it. Hold keeps the gate open after the input drops, so a decaying source does not chatter across the line.

In: in (Audio), Threshold (dB), Attack (s), Hold (s), Release (s), Floor (dB - the level a closed gate attenuates to).
Out: out (Audio), Open (Float, 0..1 - how open the gate is).
Settings: the same values inline.

The detector is near-instant in both directions, so Hold is the only thing keeping the gate open once the input drops - lengthen it, not Release, if a sustained sound is being chopped up. Open is a Float wire like any other: use it to trigger, duck or fade something the gate never touches.

Transient Shaper

Sharpens or softens a sound’s attack and its tail, with no threshold to set. Snap for a footstep, bloom for an explosion, tightness for a room that is too live.

In: in (Audio), Attack (Float, -1..1), Sustain (Float, -1..1).
Out: out (Audio), Gain (Float, dB applied at the end of the block).
Settings: Attack; Sustain.

Two envelope followers watch the same signal at different speeds, and the node acts where they disagree: a fast one outruns a slow one at an onset, a slow one outlasts a fast one through a decay. Because it reads change rather than level, it works the same on a quiet hit as a loud one - unlike a Compressor, there is nothing to re-tune when the source gets louder. Both controls are at 0 by default, which is a true bypass.

Pitch Shifter

Retunes a signal without changing how long it lasts.

In: in (Audio), Semitones (Float, -24..24), Mix (Float, 0 = dry, 1 = wet).
Out: out (Audio).
Settings: Semitones; Mix.

Time-domain (a delay line read faster or slower than it is written, with two read heads crossfaded so the wrap never clicks), so it costs the same every block and shifts anything the graph can route into it - a bus, a sub-graph, a live source - not only a sample. Large shifts smear, because the window is real time being repeated or skipped; a few semitones is where it sounds like a tuning change rather than an effect.

To retune a sample specifically, the Wave Player’s own Pitch pin is cheaper and cleaner - it resamples, so the sound gets shorter or longer, which for a one-shot is usually what you wanted anyway. Reach for this node when the length has to stay put, or when the source is not a sample.

At 0 semitones (within a twentieth of a semitone) the wet path fades to the dry signal over about 50 ms, so the node is a true bypass there rather than the comb filter two fixed read heads would otherwise make. A Semitones value that sweeps through zero fades rather than steps, and the delay line keeps filling throughout, so the shifter is ready the moment the value leaves the band.

Crossover

Splits a signal into a Low and a High band at one frequency, so the two halves can be treated differently and mixed back together.

In: in (Audio), Frequency (Float, Hz).
Out: Low (Audio), High (Audio) - both the input’s channel width.
Settings: Frequency.

A Linkwitz-Riley pair at 24 dB per octave: the two bands sum back to a flat response with no notch at the split and no polarity trick, so a split and rejoin with nothing in between leaves the level alone at every frequency. Saturate the bottom of an engine without fizzing the top, or delay the top of a crash without smearing the hit. Cascade two for three bands.

Channels

Nodes that rearrange audio channels. Audity never collapses channels on a wire by itself; these nodes are the only place it happens.

Split

Deinterleaves an N-channel input into N mono outputs.

In: in (Audio, N channels).
Out: out 0..N-1 (Audio, mono each).
Settings: Channel Count (2 to 8; must match the wiring).

Join

Interleaves N mono inputs into one N-channel output.

In: in 0..N-1 (Audio, mono).
Out: out (Audio, N channels).
Settings: Channel Count (2 to 8; must match the wiring).

Take Channel

Extracts one channel as mono.

In: in (Audio, any width), Channel (Float, index).
Out: out (Audio, mono).

Swap

Swaps left and right of a stereo signal.

In: in (Audio, stereo). Out: out (Audio, stereo).

Mono -> Stereo

Explicit upmix (duplicates the channel).

In: in (Audio, mono). Out: out (Audio, stereo).

Stereo -> Mono

The only downmix node; its single setting chooses the policy.

In: in (Audio, stereo). Out: out (Audio, mono).
Settings: Mode (Equal Power = (L+R) x 0.7071, Average = x 0.5, Sum = unscaled).

Modulation

ADSR

An attack/decay/sustain/release envelope on a Float wire.

In: Trigger (Trigger, starts attack), Release (Trigger), Attack (Float), Decay (Float), Sustain (Float), Release Time (Float).
Out: out (Float).
Settings: Attack (s, 0.01), Decay (s, 0.1), Sustain (0..1, 0.7), Release (s, 0.2).

Drive a VCA or Gain with the output to shape a voice.

LFO

A low-frequency oscillator on a Float wire.

In: Frequency (Float, default 1), Depth (Float, default 1), Offset (Float).
Out: out (Float).
Settings: Shape; Frequency (Hz); Depth; Offset; Seed.

The LFO offers six shapes. The four cycling ones - Sine, Triangle, Saw, Square - repeat exactly, which is often what gives a modulated sound away as synthetic. The other two do not:

Shape	What it does
Random	Steps to a new random value each cycle and holds it flat. Sample-and-hold wobble, machinery, flicker.
Drift	Wanders smoothly between random values. Swap it in for a Sine anywhere something should feel alive rather than clocked.

Frequency still means rate for both: how often a new value is drawn. Seed decorrelates them, so two Drift LFOs on the same graph wander independently instead of in lockstep. The cycling shapes ignore Seed.

Envelope Follower

An audio signal’s level as a Float, so anything in the graph can be driven by how loud something else is - a filter that opens with the engine, a layer that fades in behind gunfire.

In: in (Audio, any width), Attack (Float, s), Release (Float, s).
Out: out (Float, linear), dB (Float, floored at -120).
Settings: Detector (Peak or RMS); Attack; Release.

Peak reads transients; RMS reads perceived loudness and averages over at least 20 ms, so it is the steadier one to modulate with. For ducking one signal by another specifically, the Compressor’s Sidechain input and Gain Reduction output are the more direct route.

To read the level from game code, wire it into a Parameter Out node naming a member whose Direction is Out, then poll source.TryGetFloat("Level", out var level). See Reading a graph from code - the value is a snapshot about a frame old, so keep sample-accurate reactions inside the graph.

Spectrum Analyzer

Splits a signal into a bank of bands and reports each band’s level, so a graph - or the game - can be driven by where the energy is rather than only by how much of it there is. Bass for a rumble, high mids for a hit.

In: in (Audio, any width), Low (Float, Hz), High (Float, Hz), Attack (Float, s), Release (Float, s).
Out: Bands (Float, one lane per band).
Settings: Band Count (2-8); Detector (Peak or RMS); Scale (Linear or Decibels); Low; High; Attack; Release.

Bands are spaced geometrically between Low and High and each sits at the centre of its own slice, so changing the band count changes the resolution without moving the edges. Analysis is mono - a spectrum is a question about the signal, not about where it sits in the field - and averaging rather than summing the channels keeps a reading independent of the input’s width.

The output is one wire carrying every band, not one pin per band. Wire it straight into a Parameter Out naming a Float member whose Array Length matches the band count and whose Direction is Out, and the whole bank becomes readable from code in one call:

readonly float[] m_Bands = new float[8];

void Update()
{
    int count = m_Source.GetFloats("Bands", m_Bands);
    rumble.amplitude = count > 0 ? m_Bands[0] : 0f;
}

For a single band inside the graph, tap the wire with an Index node rather than round-tripping through the blackboard.

This is a filter bank, not an FFT, and deliberately so: an FFT would owe a window’s worth of latency and would move whenever the audio block size did, which the engine cannot promise. A bank of state-variable filters is sample-by-sample, costs the same every block, and answers the question a game actually asks just as well.

Sample & Hold

Latches In when a trigger arrives and holds it until the next one - the way to turn something continuous into something stepped.

In: in (Float, any width), Trigger (Trigger).
Out: out (Float, the held value).

A slow LFO through this on a Trigger Repeat clock is a stepped sequence; a Random Value latched per footstep is one pitch per step; a Spectrum Analyzer band latched on the beat is a value that only moves when the music does. Before the first trigger ever arrives Out simply follows In, so leaving Trigger unwired is a pass-through rather than a silent zero.

Math

Componentwise arithmetic and shaping on Float wires. All of these carry vectors as easily as scalars.

Math

A single node with a selectable operation; its pins change to match the op.

In: A (Float), plus B / In Min + In Max / T depending on the op.
Out: out (Float, width adopts the inputs).
Settings: Op, and inline operands.

Operations: Add, Subtract, Multiply, Divide, Clamp, Min, Max, Power, Modulo (A mod B, 0 when B is 0), Abs, Negate, One Minus (1 - A), Floor, Ceil, Round, dB -> Linear, Linear -> dB, Semitones -> Ratio, and Lerp (A -> B by T). Range remapping is a separate node (Remap), and width-changing vector operations are Vector Math.

Remap

Maps an input range to an output range.

In: in, In Min, In Max, Out Min, Out Max (all Float, dynamic width).
Out: out (Float).
Settings: In Min/Max, Out Min/Max; Clamp (default on).

Curve

Shapes a value through an animation curve (baked to a lookup table).

In: in (Float). Out: out (Float).
Settings: Curve (AnimationCurve, default ease in/out).

Slew

Rate-limits a value so it cannot change faster than the given rise/fall. Good for smoothing a jumpy game value before it drives audio.

In: in (Float, dynamic width), Rise (Float, default 10; 0 or less = unlimited), Fall (Float, default 10).
Out: out (Float).
Settings: Rise (per second), Fall (per second).

Rise and Fall are speeds, not durations: a lower number is a slower, longer glide. To think in time, divide the value’s range by the seconds you want - a 0..1 parameter that should take 2 seconds wants a rate of 0.5, and the default 10 crosses it in a barely audible 0.1 seconds. Slew primes to the first value it sees, so a voice born at distance 30 starts there instead of sweeping in.

Values

Constants and per-trigger values.

Constant

A single Float value. The node header shows the value.

Out: out (Float). Settings: Value.

Constant (Vector)

A Vector 2/3/4 constant.

Out: out (Float, chosen width). Settings: Width (2 to 4); Value.

Constant (Bool)

Outputs 0 or 1. Out: out (Float). Settings: Value (toggle).

Constant (Enum)

Outputs an enum ordinal; the header shows the label.

Out: out (Float). Settings: Enum Type (a C# enum tagged [AudityEnum]); Value.

Random Value

A random number redrawn on each Roll trigger, held between rolls.

In: Roll (Trigger), Min (Float), Max (Float, default 1).
Out: out (Float).
Settings: Min, Max.

Logic

Compare

Compares two values; outputs a boolean and edge triggers.

In: a (Float), b (Float).
Out: Result (Float, 0/1), On True (Trigger, fires when the test becomes true), On False (Trigger).
Settings: Op (Greater, GreaterEqual, Less, LessEqual, Equal, NotEqual); Tolerance (band for Equal/NotEqual).

Index Switch

Selects one of several values by index. The Float sibling of Switch Route.

In: In 0..N (Float), Index (Float).
Out: out (Float) = In[round(Index)], clamped.
Settings: Input Count (2 to 8); per-input default values.

Gate

Passes triggers only while the Open value is high.

In: in (Trigger), Open (Float, default 1).
Out: out (Trigger; passes while Open is at least 0.5).

Triggers

Event routing and timing. These wire the “when” of a sound.

On Play

Fires once when the instance starts. Placed automatically in a new Sound Graph.

Out: out (Trigger).

Trigger In

The placed form of a blackboard Trigger member: add the trigger to the blackboard, drag its chip onto the canvas, and fire it by name from code (Trigger("name")). Not in the creation menu - the member is the authoring surface, like every interface node.

Out: out (Trigger). Settings: Parameter Name (clear it to receive the anonymous Trigger() API instead).

Switch Route

Routes each incoming trigger to one output by index.

In: in (Trigger), Value (Float).
Out: out 0..N (Trigger) = out[round(Value)], clamped.
Settings: Output Count (2 to 8); Value.

Quantize

Holds each incoming trigger until the next musical grid boundary, so an in-graph chain or follow-action lands on the beat exactly like an external Trigger(name, AudityQuantize.NextBar) call. See Musical timing.

In: in (Trigger).
Out: out (Trigger, released on the boundary).
Settings: Boundary (Immediate = pass through, Next Beat, Next Bar, Next Phrase).

Random Route

Routes each trigger to a random output.

In: in (Trigger).
Out: out 0..N (Trigger), Index (Float, last chosen).
Settings: Output Count (2 to 8); per-output weights; Avoid Repeat (avoid the last N picks); Shuffle.

Trigger Repeat

Fires repeatedly at a period while running.

In: Start (Trigger), Stop (Trigger), Period (Float, default 0.5).
Out: out (Trigger, every Period seconds).

Trigger Delay

Delays each trigger.

In: in (Trigger), Delay (Float, default 0.5).
Out: out (Trigger, Delay seconds later).
Settings: Delay; Follow Delay.

By default a trigger’s due time is fixed the moment it arrives, so changing Delay only affects triggers that arrive afterwards. Turn Follow Delay on and a trigger that is still waiting moves with the value instead - shortening Delay below the time already waited fires it at once rather than never.

Sequence Step

Steps through outputs one at a time. Advance with Next, rewind with Reset.

In: Next (Trigger), Reset (Trigger).
Out: out 0..N (Trigger), Index (Float, current step).
Settings: Step Count (2 to 8); End Behavior (Stop or Loop past the last step).

Trigger Any

Fires when any input fires (an OR).

In: In 0..N (Trigger). Out: out (Trigger).
Settings: Input Count (2 to 8).

Trigger Probability

Passes each trigger with a probability.

In: in (Trigger), Probability (Float, 0..1, default 0.5).
Out: out (Trigger).

Trigger Rate Limit

Thins a trigger stream to at most one per interval (the first always passes). Good against footstep or impact spam.

In: in (Trigger), Interval (Float, default 0.1).
Out: out (Trigger).

State Route

The stateful sibling of Switch Route, and the core of a horizontal music state machine: it watches a State value and fires per-state transition triggers as the game moves between sections. Entrances fire immediately (the destination player’s launch quantize aligns them); exits hold to the leaving state’s grid. See Musical timing.

In: State (Float; the target state is round(State), clamped to the rows).
Out: per state - Enter / Exit (within a group) and Arrive / Depart (crossing a group boundary); one pin per transition rule; plus Current and Next (Float, the committed and pending state rows).
Settings: States - a list of rows, each with a name (its ports’ label), an exit grid (the boundary it cuts on when left), an optional per-state tempo (BPM / Beats Per Bar; 0 = leave the grid unchanged), and an optional group tag (rows sharing a tag form one territory). Rules - a sparse transition table, each rule matching a from/to state name, group tag, or Any, with its own commit boundary and an optional bridge (chain the destination from the rule’s own content).

Wire each Enter/Arrive to a section’s Wave Player Play and each Exit/Depart to its Stop; wire a Sample-driven stinger to a rule pin for per-transition content.

Vector

Operations on Vector 2/3/4 Float wires. Componentwise arithmetic is on the Math node; these change width or interpret vectors geometrically.

Combine XYZ

Builds a vector from scalar components.

In: X, Y, Z, W (Float, up to the chosen width).
Out: out (Float, Vector 2/3/4).
Settings: Width (2 to 4); inline X/Y/Z/W.

Separate XYZ

Splits a vector into scalar components (lanes past the input width read 0).

In: in (Float, any width).
Out: X, Y, Z, W (Float scalars).

Index

Picks one lane out of a wide value - the tap for a bundle wire such as a Spectrum Analyzer’s bands. Separate XYZ names its four lanes x/y/z/w; this one indexes them, so it keeps working past four.

In: in (Float, any width), Index (Float).
Out: out (Float scalar).
Settings: Index.

An index past the end holds at the last lane rather than wrapping, so a live value driving it settles at the top of the bundle instead of jumping back to the bottom. A scalar wire splats, so every index reads the same value.

Vector Math

A selectable geometric operation.

In: in, or a + b, depending on the op.
Out: out (Float; width depends on the op).
Settings: Op.

Operations: Length, Distance, Dot Product, Cross Product (Vector 3), Normalize. Length, Distance and Dot Product output a scalar; Normalize keeps the input width; Cross Product is Vector 3.

Spatial

Listener-relative audio. Covered in full on Spatial audio.

Listener Info

Engine-fed values describing the listener relative to this emitter.

Out: Distance, Direction (Vector 3), Listener Position (Vector 3), Emitter Position (Vector 3), Azimuth, Elevation, Relative Speed (all Float).

Doppler

Turns closing speed into a pitch shift.

In: Speed (Float, world units/s; + = approaching), Scale (Float, default 1; 0 disables).
Out: Ratio (Float, pitch multiplier), Semitones (Float; wire into a Wave Player’s Pitch).
Settings: Speed; Scale; Speed Of Sound (default 343).

Structure

Sub Graph

Places a Sub Graph asset as a node. Its pins are exactly the child’s interface members. See The graph editor.

Settings: Graph (a Sub Graph asset); pinned bindings.

Output

The graph’s speaker. Every Sound Graph needs one; without it the graph is silent.

In: in (Audio, the master mix), Stop (Trigger, stops this instance with a release fade), Gain (Float, dB - the instance’s master level, without leaving the graph for the AudioSource volume).
Settings: Release Fade (seconds, default 0.05); Layout (Mono, Stereo, Quad, 5.0, 5.1, 7.1; Mono in a new graph); Gain (dB, -3 in a new graph).

Stop and Gain act on the playing instance, so they apply only when the graph plays as its own sound; nested as a subgraph, its Output is a pass-through and the parent owns the level.

Each Sound Graph renders to its own AudioSource; there is no cross-graph audio bus or send in the graph model. To share one effect across many instances - a single reverb for forty footsteps - route those AudioSources through a Unity Audio Mixer group and put the effect there, or place the effect inside each graph. A native bus/send layer is a planned addition, not part of this release.

Interface nodes

These are not in the creation menu. They appear when you add a member to the Interface panel and drop it on the canvas.

Parameter In - reads a value member (Float/Bool/Int/Enum/Time) into the Float domain. Settings: Parameter Name, Element Index (for array members).
Parameter Out - writes a Float into an Out value member (passthrough).
Trigger Out - writes a trigger into an Out Trigger member.
Sample Set - reads a Sample Set member as a wireable source for a Wave Player or Sub Graph.
Audio In / Audio Out - carry an audio bus across a Sub Graph boundary.

Previous
The graph editor Next
Samples and sample sets