Math Delay Amplitude Calculation

Computes, for each virtual sound object and each loudspeaker, the delay and amplitude that drive a Wave-Field-Synthesis-style spatialisation: how long the signal must be delayed on each speaker so the wavefronts re-form at the object's position, and how loud each speaker should play it.

The module is fed with two 3D point clouds:

• the objects — virtual sound sources (one per index, X / Y / Z arrays),
• the speakers — physical loudspeaker positions (same layout).

For every active object × speaker pair, it computes:

• the delay (in samples) needed to align the wavefront at the object's position, scaled by stage size / sound speed,
• the amplitude, derived from the per-speaker distance to the object, the per-object width (how localised the source is — narrow = nearest speakers, wide = all speakers contribute), and a normalisation that keeps the energy constant.

It also handles a direct-out routing override (per-object × per-speaker switch matrix), a "Céline Dion" mode that broadcasts each object on every speaker regardless of position, and a central zone behaviour that softly attenuates objects sitting near the centre of the loudspeaker rig.

The calculation is spread over time (~50 ms per full pass): only objects whose position has changed since the previous pass are reprocessed, unless always process is enabled.

Coordinate convention — inputs are in normalised 0…1 coordinates; positions are internally remapped to -1…+1 for the central-zone geometry. Distances are converted to samples using delay = distance × stage_size_m / sound_speed_m·s⁻¹.

Settings

on

Enables the delay and amplitudes calculation.

X-object

Per-object X positions (data array, normalised 0…1).

Y-object

Per-object Y positions.

Z-object

Per-object Z positions. Ignored when ignore z is ON.

on objects

Per-object integer array. 0 mutes the object (amplitude = 0, delay = 0); 1 enables it. Default 1.

num objects max

Hard cap on the number of objects processed, regardless of the actual array length. Defaults to MAX_AUDIO_CHANNELS. Use this to limit CPU when the object arrays are oversized.

X-speakers

Per-speaker X positions.

Y-speakers

Per-speaker Y positions.

Z-speakers

Per-speaker Z positions. Ignored when ignore z is ON.

num speakers max

Hard cap on the number of speakers processed. Defaults to MAX_AUDIO_CHANNELS.

ignore z

When ON, the calculation is done in 2D and the Z arrays are not read.

calculation mode

Combo box:

• amplitude + delay (0, default) — both outputs are produced.
• amplitude only (1) — delays and min delays are left empty.
• delay only (2) — amplitudes is left empty.

delay mode objects

Per-object integer array. Selects how the delay is computed for each object:

• 0 — minimum delay: the closest speaker plays without delay, the others are delayed by their extra distance. This is the standard Delay/Amplitude behaviour.
• 1 — full delay: every speaker is delayed by its absolute distance to the object. Equivalent mode for delay-based imaging.
• 2 — no delay: all speakers play with the same delay (delay objects only). Useful when delay should be driven externally.

width objects

Per-object source width, range 0 – 2. Default 1.0. Lower values concentrate the energy on the closest speakers (focused source); higher values spread it over more speakers (diffuse source). Internally mapped through a log curve, so the response stays musical across the full range.

delay objects

Per-object delay offset, in milliseconds, added on top of the computed delays. Range −1000 – +1000.

gain objects

Per-object gain, multiplied into every speaker amplitude for that object. Default 1.0, no limit.

direct out on objects

Per-object integer array. When 1, the calculation is bypassed for that object: the speakers receive a direct copy controlled by direct out speakers objects.

direct out speakers objects

Per-(object, speaker) integer mask (flat-packed: nb_objects × nb_speakers). Only consulted when direct out on objects is 1 for the object. 1 routes the object's signal to that speaker with the per-object delay objects delay and gain objects gain; 0 mutes the pair.

stage size

Physical size of the stage / rig in metres, range 1 – 200. Combined with sound speed it converts normalised distances into a delay in milliseconds: delay = distance_normalised × stage_size × 1000 / sound_speed.

sound speed

Speed of sound used for the delay conversion, range 325 – 400. Default 343.5.

center zone radius coeff

Fraction (0…1) of the radius of the smallest sphere enclosing the loudspeakers. Defines the size of the central zone: objects sitting inside that sphere are progressively attenuated on speakers that are on the opposite side of the rig (object · speaker < 0). Default 0.15.

center zone radius out

Read-back of the effective central-zone radius (center zone radius coeff × enclosing-sphere radius). 0 when the rig isn't enclosing enough speakers to form a central sphere.

delays

Flat array of length nb_objects × nb_speakers, indexed [object × nb_speakers + speaker]. Per-pair delay in milliseconds (clamped to ≥ 0). Empty in amplitude only mode.

amplitudes

Flat array of length nb_objects × nb_speakers, same indexing. Per-pair amplitude, normalised so that the per-object energy sum stays at gain objects × on objects. Empty in delay only mode.

min delays

Per-object array of length nb_objects. In minimum delay mode this is the delay applied to the closest speaker (i.e. stage_size × QdistMin); in full delay / no delay modes it is 0. Empty in amplitude only mode.

always process

When ON, every object is recomputed on every block, regardless of whether its position has changed. When OFF (default), the module only reprocesses objects that moved since the last pass, and spreads the work over ~50 ms — cheaper for large object counts on static scenes.

See also

• Adamson
• Panel Patching Matrix
• Distance Attenuation
• Device ASIO Driver
• Object3D Arc Quad
• Object3D Ray Tracing And Directivity
• Math Delay Amplitude Calculation