if (emitter.AmbientFilter != null)
{
    var gainLF = emitter.AmbientFilter.GainLF;
    var gainHF = emitter.AmbientFilter.GainHF;
}

if (emitter.ambientFilter != null)
{
    var gainLF = emitter.ambientFilter.gainLF;
    var gainHF = emitter.ambientFilter.gainHF;
}

VALowPassFilter* ambientFilter = vaEmitterGetAmbientFilter(emitter);

if (ambientFilter != NULL)
{
    float gainLF = ambientFilter->gainLF;
    float gainHF = ambientFilter->gainHF;
}

using vaudio;

public class Demo
{
    World world;
    PrismPrimitive prism;
    Emitter listener;
    Emitter enemy;

    public Demo()
    {
        // Create a raytracing world
        world = new World()
        {
            WorldSize = new Vector(100),
            RenderingEnabled = true,
            OnReverbUpdated = OnReverbUpdated,
        };

        // Create a rectangular prism
        prism = new PrismPrimitive()
        {
            // Set its material
            material = MaterialType.Concrete,
            
            // Set its size
            size = new Vector(20, 120, 20),
            
            // Rotate and position it
            transform = Matrix.CreateRotationY(MathF.PI / 4) *
                        Matrix.CreateTranslation(50, 50, 50)
        };

        world.AddPrimitive(prism);

        // Create a listener emitter with all ray types enabled
        listener = new Emitter()
        {
            Name = "Listener",
            Position = new Vector(10, 50, 10),
            
            ReverbRayCount = 128,
            ReverbBounceCount = 64,
            ReverbEnergyCap = 128 * 64 * 0.05,
            MaxEchogramTime = 5000,
            EchogramGranularity = 50,
            
            OcclusionRayCount = 512,
            OcclusionBounceCount = 8,
            PermeationRayCount = 128,
            PermeationBounceCount = 3,
            
            AmbientOcclusionRayCount = 512,
            AmbientOcclusionBounceCount = 8,
            AmbientPermeationRayCount = 128,
            AmbientPermeationBounceCount = 4
        };
        
        world.AddEmitter(listener);
        
        // Create an enemy emitter
        enemy = new Emitter()
        {
            Name = "Enemy",
            Position = new Vector(90, 50, 10)
        };
        
        enemy.OnRaytracedByAnotherEmitter = (Emitter other) =>
        {
            var filter = other.GetTargetFilter(enemy);
            
            // PSEUDOCODE
            // Godot.PlaySound(SoundType.EnemySpawn, enemy.position, filter);       
        }
        
        world.AddEmitter(enemy);
        
        // Tell the listener to cast occlusion and permeation rays towards the enemy
        listener.AddTarget(enemy);
    }
    
    void OnReverbUpdated()
    {
        // Access the listener's reverb stats
        var returnedPercent = listener.ProcessedReverb.ReturningPercent;
        var decayTime = listener.EAX.DecayTime;
        
        // Access ambient stats
        var outsidePercent = listener.OutsidePercent;
        var ambientGainLF = listener.AmbientFilter.GainLF;
        
    }

    Stopwatch watch = Stopwatch.StartNew();

    public void Update()
    {
        // Rotate and position the prism in real time
        var rotation = watch.ElapsedMilliseconds / 1000.0f;

        prism.transform = Matrix.CreateRotationY(rotation) *
                          Matrix.CreateTranslation(50, 50, 50);
        
        // Perform raytracing on background threads
        world.Update();
    }
}

import { dotnet } from './_framework/dotnet.js';
import { wrapVA, MaterialType } from './vaudio-wrapper.js';

// Set this to the number of threads you'll use
const YOUR_THREAD_COUNT = 4;

// The .NET runtime needs 6 threads. Without this, the browser may freeze
const DOTNET_THREAD_COUNT = 6;

// Initialise the .NET runtime
const { getAssemblyExports, getConfig } = await dotnet
    .withDiagnosticTracing(false)
    .withConfig({
        jsThreadBlockingMode: "DangerousAllowBlockingWait", // Without this all calls to WASM are async
        pthreadPoolInitialSize: YOUR_THREAD_COUNT + DOTNET_THREAD_COUNT,
        pthreadPoolUnusedSize: 0,
    })
    .create();

const config = getConfig();
const exports = await getAssemblyExports(config.mainAssemblyName);

// Wrap all Web Assembly calls into JS objects with get/setters for ease of use
const va = wrapVA(exports.VAudioExports);

// Create a raytracing world
const world = va.World_Create();
world.worldSize = { x: 100, y: 100, z: 100 };
world.maximumConcurrencyLevel = YOUR_THREAD_COUNT;

world.onReverbUpdated = () =>
{
    // Access the listener's reverb stats
    const returnedPercent = listener.processedReverb.returningPercent;
    const decayTime = listener.eax.decayTime;
    
    // Access ambient stats
    const outsidePercent = listener.outsidePercent;
    const ambientGainLF = listener.ambientFilter.gainLF;
};


// Create a rectangular prism
const prism = va.PrismPrimitive_Create();

prism.material = MaterialType.Concrete;
prism.size = { x: 20, y: 120, z: 20 };
prism.transform = va.Matrix.Multiply(
    va.Matrix.CreateRotationY(Math.PI / 4),
    va.Matrix.CreateTranslation(50, 50, 50)
);

world.addPrimitive(prism);
   
// Create a listener emitter with all ray types enabled
const listener = va.Emitter_Create();
listener.name = "Listener";
listener.setPosition(10, 50, 10);

listener.reverbRayCount = 128;
listener.reverbBounceCount = 64;
listener.reverbEnergyCap = 128 * 64 * 0.05;
listener.maxEchogramTime = 5000;
listener.echogramGranularity = 50;

listener.occlusionRayCount = 512;
listener.occlusionBounceCount = 8;
listener.permeationRayCount = 128;
listener.permeationBounceCount = 3;
    
listener.ambientOcclusionRayCount = 512;
listener.ambientOcclusionBounceCount = 8;
listener.ambientPermeationRayCount = 128;
listener.ambientPermeationBounceCount = 4;
        
world.addEmitter(listener);
        
// Create an enemy emitter
const enemy = va.Emitter_Create();
enemy.name = "Enemy";
enemy.setPosition(90, 50, 10);

enemy.onRaytracedByAnotherEmitter = (other) => {
    const filter = other.getTargetFilter(enemy);
    
    // PSEUDOCODE
    // Godot.PlaySound(SoundType.EnemySpawn, enemy.position, filter);       
}

world.addEmitter(enemy);

// Tell the listener to cast occlusion and permeation rays towards the enemy
listener.addTarget(enemy);

// Update loop
const start = performance.now();

function update()
{
    const elapsed = performance.now() - start;

    // Rotate and position the prism in real time
    var rotation = elapsed / 1000.0;
    
    prism.transform = va.Matrix.Multiply(
        va.Matrix.CreateRotationY(rotation),
        va.Matrix.CreateTranslation(50, 50, 50)
    );
    
    // Perform raytracing on background threads
    world.update();
    
    requestAnimationFrame(update);
}

requestAnimationFrame(update);

#include <stdio.h>
#include <math.h>

#include "vaudio.h"

#ifdef _WIN32
    #include <windows.h>
    #define sleep_ms(ms) Sleep(ms)
#else
    #include <time.h>
    #define sleep_ms(ms) do { struct timespec ts = { (ms)/1000, ((ms)%1000)*1000000 }; nanosleep(&ts, NULL); } while(0)
#endif

VAWorld* world;
VAEmitter* listener;

void on_reverb_updated(void)
{
    // Access processed properties
    VAProcessedReverb* processed = vaEmitterGetProcessedReverb(listener);
    float returningPercent = processed->returningPercent;
        
    // Access precalculated EAX properties
    VAEAXReverb* eax = vaEmitterGetEAX(listener);
    float decayTime = eax->decayTime;    
    
    // Access ambient stats
    float outsidePercent = vaEmitterGetOutsidePercent(listener);
    
    VALowPassFilter* ambientFilter = vaEmitterGetAmbientFilter(listener);
    float ambientGainLF = ambientFilter->gainLF;
    float ambientGainHF = ambientFilter->gainHF;
}

void on_raytraced_by_another_emitter(VAEmitter* source, VAEmitter* target)
{
    VALowPassFilter* filter = vaEmitterGetTargetFilter(source, target);

    printf("Emitter raytraced by another. GainLF: %f. GainHF: %f\n", filter->gainLF, filter->gainHF);
    
    // PSEUDOCODE
    // UE.PlaySound(soundType, position, filter);
}

int main(void)
{
    // Create a raytracing world
    VAWorld* world = vaWorldCreate();
    vaWorldSetWorldSize(world, vaVectorCreate(100.0f, 100.0f, 100.0f));

    // Create a rectangular prism
    VAPrismPrimitive* prism = vaPrismPrimitiveCreate();
    
    vaPrismPrimitiveSetMaterial(prism, VAMaterialConcrete);
    vaPrismPrimitiveSetSize(prism, vaVectorCreate(15.0f, 15.0f, 15.0f));
    
    VAMatrix rotation = vaMatrixCreateRotationY(M_PI / 4);
    VAMatrix translate = vaMatrixCreateTranslation(50, 50, 50);
    VAMatrix transform = vaMatrixMultiply(&rotation, &translate);
    vaPrismPrimitiveSetTransform(prism, &transform);
    
    vaWorldAddPrimitive(world, prism);

    // Create a listener emitter with all ray types enabled
    VAEmitter* listener = vaEmitterCreate();
    vaEmitterSetName(listener, "Listener");
    vaEmitterSetPosition(listener, vaVectorCreate(10.0f, 50.0f, 10.0f));
    
    vaEmitterSetReverbRayCount(listener, 128);
    vaEmitterSetReverbBounceCount(listener, 64);
    vaEmitterSetReverbEnergyCap(listener, 128 * 64 * 0.05f);
    
    vaEmitterSetOcclusionRayCount(listener, 512);
    vaEmitterSetOcclusionBounceCount(listener, 8);
    vaEmitterSetPermeationRayCount(listener, 128);
    vaEmitterSetPermeationBounceCount(listener, 3);
    
    vaEmitterSetAmbientOcclusionRayCount(listener, 512);
    vaEmitterSetAmbientOcclusionBounceCount(listener, 8);
    vaEmitterSetAmbientPermeationRayCount(listener, 128);
    vaEmitterSetAmbientPermeationBounceCount(listener, 3);

    int errorCode = vaWorldAddEmitter(world, listener);
    assert(errorCode == 0);    
    
    // Create an enemy emitter
    VAEmitter* source = vaEmitterCreate();
    vaEmitterSetName(source, "Enemy");
    vaEmitterSetPosition(source, vaVectorCreate(90.0f, 50.0f, 10.0f));
    vaEmitterSetOnRaytracedByAnotherEmitterCallback(source, on_raytraced_by_another_emitter);
    
    errorCode = vaWorldAddEmitter(world, source);
    assert(errorCode == 0);    
    
    // Tell the listener to cast occlusion and permeation rays towards the enemy
    vaEmitterAddTarget(listener, source);

    float elapsed = 0.0f;

    while (true)
    {
        // Rotate and position the prism in real time
        float angle = elapsed / 1000.0f;
                
        VAMatrix rotation = vaMatrixCreateRotationY(angle);
        translate = vaMatrixCreateTranslation(50, 50, 50);
        transform = vaMatrixMultiply(&rotation, &translate);
        vaPrismPrimitiveSetTransform(prism, &transform);
        
        // Perform raytracing on background threads
        vaWorldUpdate(world);
        
        sleep_ms(16);
        elapsed += 16.0f;
    }
    
    return 0;
}

public class CapsulePrimitive : Primitive
{
    // Length of the cylindrical body between the hemispherical caps
    public float length;

    // Radius of the capsule
    public float radius;

    // Must only contain rotation and translation components, not scale
    public Matrix transform;
}

interface CapsulePrimitive {
    // Created via: va.CapsulePrimitive_Create()

    // Length of the cylindrical body between the hemispherical caps
    get length(); set length(v);

    // Controls the amount of energy lost when rays bounce off this primitive, permeate through it, and scatter off it
    get material(); set material(v);

    // Radius of the capsule
    get radius(); set radius(v);

    // This transform must only contain rotation and translation components, not scale
    get transform(); set transform(v);
}

// Creates a new CapsulePrimitive with default values
VACapsulePrimitive* vaCapsulePrimitiveCreate(void);

// Frees all resources owned by this primitive
void vaCapsulePrimitiveFree(VACapsulePrimitive* capsule);

// Radius of the capsule cylinder and end caps.
float vaCapsulePrimitiveGetRadius(const VACapsulePrimitive* capsule);

// Length of the capsule cylinder, excluding end caps.
float vaCapsulePrimitiveGetLength(const VACapsulePrimitive* capsule);

// World transform of the capsule.
const VAMatrix* vaCapsulePrimitiveGetTransform(const VACapsulePrimitive* capsule);

// Radius of the capsule cylinder and end caps.
void vaCapsulePrimitiveSetRadius(VACapsulePrimitive* capsule, float radius);

// Length of the capsule cylinder, excluding end caps.
void vaCapsulePrimitiveSetLength(VACapsulePrimitive* capsule, float length);

// Sets the world transform. Must not contain scale components.
void vaCapsulePrimitiveSetTransform(VACapsulePrimitive* capsule, const VAMatrix* transform);

// Material assigned to this primitive.
VAMaterialType vaCapsulePrimitiveGetMaterial(const VACapsulePrimitive* capsule);

// Material assigned to this primitive. Must not be VAMaterialAir.
void vaCapsulePrimitiveSetMaterial(VACapsulePrimitive* capsule, VAMaterialType material);

public class ConePrimitive : Primitive
{
    // Height of the cone from base to apex
    public float height;

    // Radius of the cone base
    public float radius;

    // Must only contain rotation and translation components, not scale
    public Matrix transform;
}

interface ConePrimitive {
    // Created via: va.ConePrimitive_Create()

    // Height of the cone from base to apex
    get height(); set height(v);

    // Controls the amount of energy lost when rays bounce off this primitive, permeate through it, and scatter off it
    get material(); set material(v);

    // Radius of the cone base
    get radius(); set radius(v);

    // This transform must only contain rotation and translation components, not scale
    get transform(); set transform(v);
}

// Creates a new ConePrimitive with default values
VAConePrimitive* vaConePrimitiveCreate(void);

// Frees all resources owned by this primitive
void vaConePrimitiveFree(VAConePrimitive* cone);

// Radius of the cone base.
float vaConePrimitiveGetRadius(const VAConePrimitive* cone);

// Height of the cone.
float vaConePrimitiveGetHeight(const VAConePrimitive* cone);

// World transform of the cone.
const VAMatrix* vaConePrimitiveGetTransform(const VAConePrimitive* cone);

// Radius of the cone base.
void vaConePrimitiveSetRadius(VAConePrimitive* cone, float radius);

// Height of the cone.
void vaConePrimitiveSetHeight(VAConePrimitive* cone, float height);

// Sets the world transform. Must not contain scale components.
void vaConePrimitiveSetTransform(VAConePrimitive* cone, const VAMatrix* transform);

// Material assigned to this primitive.
VAMaterialType vaConePrimitiveGetMaterial(const VAConePrimitive* cone);

// Material assigned to this primitive. Must not be VAMaterialAir.
void vaConePrimitiveSetMaterial(VAConePrimitive* cone, VAMaterialType material);

public class CylinderPrimitive : Primitive
{
    // Length of the cylinder along its axis
    public float length;

    // Radius of the cylinder
    public float radius;

    // Must only contain rotation and translation components, not scale
    public Matrix transform;
}

interface CylinderPrimitive {
    // Created via: va.CylinderPrimitive_Create()

    // Length of the cylinder along its axis
    get length(); set length(v);

    // Controls the amount of energy lost when rays bounce off this primitive, permeate through it, and scatter off it
    get material(); set material(v);

    // Radius of the cylinder
    get radius(); set radius(v);

    // This transform must only contain rotation and translation components, not scale
    get transform(); set transform(v);
}

// Creates a new CylinderPrimitive with default values
VACylinderPrimitive* vaCylinderPrimitiveCreate(void);

// Frees all resources owned by this primitive
void vaCylinderPrimitiveFree(VACylinderPrimitive* cylinder);

// Radius of the cylinder.
float vaCylinderPrimitiveGetRadius(const VACylinderPrimitive* cylinder);

// Length of the cylinder along its axis.
float vaCylinderPrimitiveGetLength(const VACylinderPrimitive* cylinder);

// World transform of the cylinder.
const VAMatrix* vaCylinderPrimitiveGetTransform(const VACylinderPrimitive* cylinder);

// Radius of the cylinder.
void vaCylinderPrimitiveSetRadius(VACylinderPrimitive* cylinder, float radius);

// Length of the cylinder along its axis.
void vaCylinderPrimitiveSetLength(VACylinderPrimitive* cylinder, float length);

// Sets the world transform. Must not contain scale components.
void vaCylinderPrimitiveSetTransform(VACylinderPrimitive* cylinder, const VAMatrix* transform);

// Material assigned to this primitive.
VAMaterialType vaCylinderPrimitiveGetMaterial(const VACylinderPrimitive* cylinder);

// Material assigned to this primitive. Must not be VAMaterialAir.
void vaCylinderPrimitiveSetMaterial(VACylinderPrimitive* cylinder, VAMaterialType material);

public class DiskPrimitive : Primitive
{
    // Radius of the disk
    public float radius;

    // Must only contain rotation and translation components, not scale
    public Matrix transform;
}

interface DiskPrimitive {
    // Created via: va.DiskPrimitive_Create()

    // Controls the amount of energy lost when rays bounce off this primitive, permeate through it, and scatter off it
    get material(); set material(v);

    // Radius of the disk
    get radius(); set radius(v);

    // This transform must only contain rotation and translation components, not scale
    get transform(); set transform(v);
}

// Creates a new DiskPrimitive with default values
VADiskPrimitive* vaDiskPrimitiveCreate(void);

// Frees all resources owned by this primitive
void vaDiskPrimitiveFree(VADiskPrimitive* disk);

// Radius of the disk.
float vaDiskPrimitiveGetRadius(const VADiskPrimitive* disk);

// World transform of the disk.
const VAMatrix* vaDiskPrimitiveGetTransform(const VADiskPrimitive* disk);

// Radius of the disk.
void vaDiskPrimitiveSetRadius(VADiskPrimitive* disk, float radius);

// Sets the world transform. Must not contain scale components.
void vaDiskPrimitiveSetTransform(VADiskPrimitive* disk, const VAMatrix* transform);

// Material assigned to this primitive.
VAMaterialType vaDiskPrimitiveGetMaterial(const VADiskPrimitive* disk);

// Material assigned to this primitive. Must not be VAMaterialAir.
void vaDiskPrimitiveSetMaterial(VADiskPrimitive* disk, VAMaterialType material);

public class HalfSpherePrimitive : Primitive
{
    // Radius of the hemisphere
    public float radius;

    // Must only contain rotation and translation components, not scale
    public Matrix transform;
}

interface HalfSpherePrimitive {
    // Created via: va.HalfSpherePrimitive_Create()

    // Controls the amount of energy lost when rays bounce off this primitive, permeate through it, and scatter off it
    get material(); set material(v);

    // Radius of the hemisphere
    get radius(); set radius(v);

    // This transform must only contain rotation and translation components, not scale
    get transform(); set transform(v);
}

// Creates a new HalfSpherePrimitive with default values
VAHalfSpherePrimitive* vaHalfSpherePrimitiveCreate(void);

// Frees all resources owned by this primitive
void vaHalfSpherePrimitiveFree(VAHalfSpherePrimitive* halfSphere);

// Radius of the half-sphere.
float vaHalfSpherePrimitiveGetRadius(VAHalfSpherePrimitive* halfSphere);

// World transform of the half-sphere.
const VAMatrix* vaHalfSpherePrimitiveGetTransform(VAHalfSpherePrimitive* halfSphere);

// Radius of the half-sphere.
void vaHalfSpherePrimitiveSetRadius(VAHalfSpherePrimitive* halfSphere, float radius);

// Sets the world transform. Must not contain scale components.
void vaHalfSpherePrimitiveSetTransform(VAHalfSpherePrimitive* halfSphere, const VAMatrix* transform);

// Material assigned to this primitive.
VAMaterialType vaHalfSpherePrimitiveGetMaterial(const VAHalfSpherePrimitive* halfSphere);

// Material assigned to this primitive. Must not be VAMaterialAir.
void vaHalfSpherePrimitiveSetMaterial(VAHalfSpherePrimitive* halfSphere, VAMaterialType material);

public class PlanePrimitive : Primitive
{
    // Height of the plane
    public float height;

    // Must only contain rotation and translation components, not scale
    public Matrix transform;

    // Width of the plane
    public float width;
}

interface PlanePrimitive {
    // Created via: va.PlanePrimitive_Create()

    // Height of the plane
    get height(); set height(v);

    // Controls the amount of energy lost when rays bounce off this primitive, permeate through it, and scatter off it
    get material(); set material(v);

    // This transform must only contain rotation and translation components, not scale
    get transform(); set transform(v);

    // Width of the plane
    get width(); set width(v);
}

// Creates a new PlanePrimitive with default values
VAPlanePrimitive* vaPlanePrimitiveCreate(void);

// Frees all resources owned by this primitive
void vaPlanePrimitiveFree(VAPlanePrimitive* plane);

// Width of the plane.
float vaPlanePrimitiveGetWidth(VAPlanePrimitive* plane);

// Height of the plane.
float vaPlanePrimitiveGetHeight(VAPlanePrimitive* plane);

// World transform of the plane.
const VAMatrix* vaPlanePrimitiveGetTransform(VAPlanePrimitive* plane);

// Width of the plane.
void vaPlanePrimitiveSetWidth(VAPlanePrimitive* plane, float width);

// Height of the plane.
void vaPlanePrimitiveSetHeight(VAPlanePrimitive* plane, float height);

// Sets the world transform. Must not contain scale components.
void vaPlanePrimitiveSetTransform(VAPlanePrimitive* plane, const VAMatrix* transform);

// Material assigned to this primitive.
VAMaterialType vaPlanePrimitiveGetMaterial(const VAPlanePrimitive* plane);

// Material assigned to this primitive. Must not be VAMaterialAir.
void vaPlanePrimitiveSetMaterial(VAPlanePrimitive* plane, VAMaterialType material);

public abstract class Primitive
{
    // Determines the amount of energy lost when rays bounce off this primitive, permeate through it, and scatter off it
    public MaterialType material;
}

TODO

public class PrismPrimitive : Primitive
{
    // Dimensions of the prism along each axis
    public Vector size;

    // Must only contain rotation and translation components, not scale
    public Matrix transform;
}

interface PrismPrimitive {
    // Created via: va.PrismPrimitive_Create()

    // Controls the amount of energy lost when rays bounce off this primitive, permeate through it, and scatter off it
    get material(); set material(v);

    // Dimensions of the prism along each axis
    get size(); set size(v);

    // This transform must only contain rotation and translation components, not scale
    get transform(); set transform(v);
}

// Creates a new PrismPrimitive with default values
VAPrismPrimitive* vaPrismPrimitiveCreate(void);

// Frees all resources owned by this primitive
void vaPrismPrimitiveFree(VAPrismPrimitive* prism);

// Width, height, and depth of the prism.
VAVector vaPrismPrimitiveGetSize(const VAPrismPrimitive* prism);

// World transform of the prism.
const VAMatrix* vaPrismPrimitiveGetTransform(const VAPrismPrimitive* prism);

// Width, height, and depth of the prism.
void vaPrismPrimitiveSetSize(VAPrismPrimitive* prism, VAVector size);

// Sets the world transform. Must not contain scale components.
void vaPrismPrimitiveSetTransform(VAPrismPrimitive* prism, const VAMatrix* transform);

// Material assigned to this primitive.
VAMaterialType vaPrismPrimitiveGetMaterial(const VAPrismPrimitive* prism);

// Material assigned to this primitive. Must not be VAMaterialAir.
void vaPrismPrimitiveSetMaterial(VAPrismPrimitive* prism, VAMaterialType material);

public class RectangularConePrimitive : Primitive
{
    // Height of the cone from base to apex
    public float height;

    // Length of the rectangular base
    public float length;

    // Must only contain rotation and translation components, not scale
    public Matrix transform;

    // Width of the rectangular base
    public float width;
}

interface RectangularConePrimitive {
    // Created via: va.RectangularConePrimitive_Create()

    // Height of the cone from base to apex
    get height(); set height(v);

    // Length of the rectangular base
    get length(); set length(v);

    // Controls the amount of energy lost when rays bounce off this primitive, permeate through it, and scatter off it
    get material(); set material(v);

    // This transform must only contain rotation and translation components, not scale
    get transform(); set transform(v);

    // Width of the rectangular base
    get width(); set width(v);
}

// Creates a new RectangularConePrimitive with default values
VARectangularConePrimitive* vaRectangularConePrimitiveCreate(void);

// Frees all resources owned by this primitive
void vaRectangularConePrimitiveFree(VARectangularConePrimitive* rectCone);

// Width of the rectangular cone base.
float vaRectangularConePrimitiveGetWidth(VARectangularConePrimitive* rectCone);

// Length of the rectangular cone base.
float vaRectangularConePrimitiveGetLength(VARectangularConePrimitive* rectCone);

// Height of the rectangular cone.
float vaRectangularConePrimitiveGetHeight(VARectangularConePrimitive* rectCone);

// World transform of the rectangular cone.
const VAMatrix* vaRectangularConePrimitiveGetTransform(VARectangularConePrimitive* rectCone);

// Width of the rectangular cone base.
void vaRectangularConePrimitiveSetWidth(VARectangularConePrimitive* rectCone, float width);

// Length of the rectangular cone base.
void vaRectangularConePrimitiveSetLength(VARectangularConePrimitive* rectCone, float length);

// Height of the rectangular cone.
void vaRectangularConePrimitiveSetHeight(VARectangularConePrimitive* rectCone, float height);

// Sets the world transform. Must not contain scale components.
void vaRectangularConePrimitiveSetTransform(VARectangularConePrimitive* rectCone, const VAMatrix* transform);

// Material assigned to this primitive.
VAMaterialType vaRectangularConePrimitiveGetMaterial(const VARectangularConePrimitive* rectCone);

// Material assigned to this primitive. Must not be VAMaterialAir.
void vaRectangularConePrimitiveSetMaterial(VARectangularConePrimitive* rectCone, VAMaterialType material);

public class SpherePrimitive : Primitive
{
    // Center position of the sphere in world space
    public Vector center;

    // Radius of the sphere
    public float radius;
}

interface SpherePrimitive {
    // Created via: va.SpherePrimitive_Create()

    // Center position of the sphere in world space
    get center(); set center(v);

    // Controls the amount of energy lost when rays bounce off this primitive, permeate through it, and scatter off it
    get material(); set material(v);

    // Radius of the sphere
    get radius(); set radius(v);
}

// Creates a new SpherePrimitive with default values
VASpherePrimitive* vaSpherePrimitiveCreate(void);

// Frees all resources owned by this primitive
void vaSpherePrimitiveFree(VASpherePrimitive* sphere);

// Center of the sphere.
VAVector vaSpherePrimitiveGetCenter(VASpherePrimitive* sphere);

// Radius of the sphere.
float vaSpherePrimitiveGetRadius(VASpherePrimitive* sphere);

// Center of the sphere.
void vaSpherePrimitiveSetCenter(VASpherePrimitive* sphere, VAVector center);

// Radius of the sphere.
void vaSpherePrimitiveSetRadius(VASpherePrimitive* sphere, float radius);

// Material assigned to this primitive.
VAMaterialType vaSpherePrimitiveGetMaterial(const VASpherePrimitive* sphere);

// Material assigned to this primitive. Must not be VAMaterialAir.
void vaSpherePrimitiveSetMaterial(VASpherePrimitive* sphere, VAMaterialType material);

public class TrianglePrimitive : Primitive
{
    public Vector position0;
    public Vector position1;
    public Vector position2;
}

// Creates a new TrianglePrimitive with default values
VATrianglePrimitive* vaTrianglePrimitiveCreate(void);

// Frees all resources owned by this primitive
void vaTrianglePrimitiveFree(VATrianglePrimitive* triangle);

// First vertex position.
VAVector vaTrianglePrimitiveGetPosition0(VATrianglePrimitive* triangle);

// Second vertex position.
VAVector vaTrianglePrimitiveGetPosition1(VATrianglePrimitive* triangle);

// Third vertex position.
VAVector vaTrianglePrimitiveGetPosition2(VATrianglePrimitive* triangle);

// First vertex position.
void vaTrianglePrimitiveSetPosition0(VATrianglePrimitive* triangle, VAVector position);

// Second vertex position.
void vaTrianglePrimitiveSetPosition1(VATrianglePrimitive* triangle, VAVector position);

// Third vertex position.
void vaTrianglePrimitiveSetPosition2(VATrianglePrimitive* triangle, VAVector position);

// Material assigned to this primitive.
VAMaterialType vaTrianglePrimitiveGetMaterial(const VATrianglePrimitive* triangle);

// Material assigned to this primitive. Must not be VAMaterialAir.
void vaTrianglePrimitiveSetMaterial(VATrianglePrimitive* triangle, VAMaterialType material);

public class TriangularConePrimitive : Primitive
{
    // The height of the cone
    public float height;

    // The radius of the triangular base
    public float radius;

    // Must only contain rotation and translation components, not scale
    public Matrix transform;
}

interface TriangularConePrimitive {
    // Created via: va.TriangularConePrimitive_Create()

    // The height of the cone
    get height(); set height(v);

    // Controls the amount of energy lost when rays bounce off this primitive, permeate through it, and scatter off it
    get material(); set material(v);

    // The radius of the triangular base
    get radius(); set radius(v);

    // This transform must only contain rotation and translation components, not scale
    get transform(); set transform(v);
}

// Creates a new TriangularConePrimitive with default values
VATriangularConePrimitive* vaTriangularConePrimitiveCreate(void);

// Frees all resources owned by this primitive
void vaTriangularConePrimitiveFree(VATriangularConePrimitive* cone);

// Radius of the triangular cone base.
float vaTriangularConePrimitiveGetRadius(VATriangularConePrimitive* cone);

// Height of the triangular cone.
float vaTriangularConePrimitiveGetHeight(VATriangularConePrimitive* cone);

// World transform of the triangular cone.
const VAMatrix* vaTriangularConePrimitiveGetTransform(VATriangularConePrimitive* cone);

// Radius of the triangular cone base.
void vaTriangularConePrimitiveSetRadius(VATriangularConePrimitive* cone, float radius);

// Height of the triangular cone.
void vaTriangularConePrimitiveSetHeight(VATriangularConePrimitive* cone, float height);

// Sets the world transform. Must not contain scale components.
void vaTriangularConePrimitiveSetTransform(VATriangularConePrimitive* cone, const VAMatrix* transform);

// Material assigned to this primitive.
VAMaterialType vaTriangularConePrimitiveGetMaterial(const VATriangularConePrimitive* cone);

// Material assigned to this primitive. Must not be VAMaterialAir.
void vaTriangularConePrimitiveSetMaterial(VATriangularConePrimitive* cone, VAMaterialType material);

public class TriangularPrismPrimitive : Primitive
{
    // Length of the prism along its axis
    public float length;

    // Circumradius of the triangular cross-section
    public float radius;

    // Must only contain rotation and translation components, not scale
    public Matrix transform;
}

interface TriangularPrismPrimitive {
    // Created via: va.TriangularPrismPrimitive_Create()

    // Length of the prism along its axis
    get length(); set length(v);

    // Controls the amount of energy lost when rays bounce off this primitive, permeate through it, and scatter off it
    get material(); set material(v);

    // Circumradius of the triangular cross-section
    get radius(); set radius(v);

    // This transform must only contain rotation and translation components, not scale
    get transform(); set transform(v);
}

// Creates a new TriangularPrismPrimitive with default values
VATriangularPrismPrimitive* vaTriangularPrismPrimitiveCreate(void);

// Frees all resources owned by this primitive
void vaTriangularPrismPrimitiveFree(VATriangularPrismPrimitive* prism);

// Radius of the triangular prism cross-section.
float vaTriangularPrismPrimitiveGetRadius(VATriangularPrismPrimitive* prism);

// Length of the triangular prism along its axis.
float vaTriangularPrismPrimitiveGetLength(VATriangularPrismPrimitive* prism);

// World transform of the triangular prism.
const VAMatrix* vaTriangularPrismPrimitiveGetTransform(VATriangularPrismPrimitive* prism);

// Radius of the triangular prism cross-section.
void vaTriangularPrismPrimitiveSetRadius(VATriangularPrismPrimitive* prism, float radius);

// Length of the triangular prism along its axis.
void vaTriangularPrismPrimitiveSetLength(VATriangularPrismPrimitive* prism, float length);

// Sets the world transform. Must not contain scale components.
void vaTriangularPrismPrimitiveSetTransform(VATriangularPrismPrimitive* prism, const VAMatrix* transform);

// Material assigned to this primitive.
VAMaterialType vaTriangularPrismPrimitiveGetMaterial(const VATriangularPrismPrimitive* prism);

// Material assigned to this primitive. Must not be VAMaterialAir.
void vaTriangularPrismPrimitiveSetMaterial(VATriangularPrismPrimitive* prism, VAMaterialType material);

public class CustomEAXFormulas
{
    // Calculates the EAX density parameter based on the number of energy peaks in the early echogram
    public virtual float CalculateDensity();

    // Calculates the EAX diffusion parameter based on how smoothly energy accumulates over time
    public virtual float CalculateDiffusion();

    // Calculates the low and high frequency gain values relative to a reference energy level
    public virtual void CalculateFrequencyGains(float referenceEnergy, out float lfGain, out float hfGain);

    // Calculates the delay in seconds before late reverb begins, based on the 25% energy accumulation point
    public virtual float CalculateLateReverbDelay();

    // Calculates the gain for early reflections and late reverb by splitting the echogram at a transition point
    public virtual void CalculateReflectionsAndLateReverbGain(float earlyLateTransitionMs, float referenceEnergy, out float reflectionsGain, out float lateReverbGain);

    // Calculates the delay in seconds before the first significant reflection is detected
    public virtual float CalculateReflectionsDelay(float energyThreshold);

    // Calculates the RT60 reverberation time in seconds for a given echogram using linear regression on the decay slope
    public virtual float CalculateRT60(float[] echogram);

    // Initialises the formula calculator with echogram data from a processed reverb result
    public virtual void Initialise(ProcessedReverb processed, float totalReturningEnergyLF, float totalReturningEnergyHF, float echogramGranularity, float[] echogramLF, float[] echogramHF, float[] echogramAverage);
}

struct VACustomEAXFormulas
{
    // Virtual function pointers
    CustomEAXFormulas_InitialiseFunc initialise;
    CustomEAXFormulas_CalculateDiffusionFunc calculateDiffusion;
    CustomEAXFormulas_CalculateDensityFunc calculateDensity;
    CustomEAXFormulas_CalculateReflectionsDelayFunc calculateReflectionsDelay;
    CustomEAXFormulas_CalculateLateReverbDelayFunc calculateLateReverbDelay;
    CustomEAXFormulas_CalculateFrequencyGainsFunc calculateFrequencyGains;
    CustomEAXFormulas_CalculateReflectionsAndLateReverbGainFunc calculateReflectionsAndLateReverbGain;
    CustomEAXFormulas_CalculateRT60Func calculateRt60;
    CustomEAXFormulas_TryCalculateDecayTimeFunc tryCalculateDecayTime;

    // Data members
    float* tempDiffusionCumulative;
    int tempDiffusionCumulativeLength;

    float* echogramDb;
    int echogramDbLength;

    float binDurationMs;

    VAProcessedReverb* processed;
    float totalReturningEnergyLF;
    float totalReturningEnergyHF;
    float totalReturningEnergyAverage;
    float totalReturningEnergy;
    float* echogramLF;
    float* echogramHF;
    float* echogramAverage;
    int echogramLength;

    float maxEnergy;
};

VACustomEAXFormulas* vaCustomEaxFormulasCreate(void);

void vaCustomEaxFormulasFree(VACustomEAXFormulas* formulas);

public class EAXConstants
{
    public const float AIR_ABSORPTION_GAIN_HF_MAX = 1.0f;

    public const float AIR_ABSORPTION_GAIN_HF_MIN = 0.892f;

    public const int DECAY_HF_LIMIT_MAX = 1;

    public const int DECAY_HF_LIMIT_MIN = 0;

    public const float DECAY_HF_RATIO_MAX = 2.0f;

    public const float DECAY_HF_RATIO_MIN = 0.1f;

    public const float DECAY_LF_RATIO_MAX = 2.0f;

    public const float DECAY_LF_RATIO_MIN = 0.1f;

    public const float DECAY_TIME_MAX = 20.0f;

    public const float DECAY_TIME_MIN = 0.1f;

    public const float DENSITY_MAX = 1.0f;

    public const float DENSITY_MIN = 0.0f;

    public const float DIFFUSION_MAX = 1.0f;

    public const float DIFFUSION_MIN = 0.0f;

    public const float ECHO_DEPTH_MAX = 1.0f;

    public const float ECHO_DEPTH_MIN = 0.0f;

    public const float ECHO_TIME_MAX = 0.25f;

    public const float ECHO_TIME_MIN = 0.075f;

    public const float GAIN_HF_MAX = 1.0f;

    public const float GAIN_HF_MIN = 0.0f;

    public const float GAIN_LF_MAX = 1.0f;

    public const float GAIN_LF_MIN = 0.0f;

    public const float GAIN_MAX = 1.0f;

    public const float GAIN_MIN = 0.0f;

    public const float HF_REFERENCE_MAX = 20000f;

    public const float HF_REFERENCE_MIN = 1000f;

    public const float LATE_REVERB_DELAY_MAX = 0.1f;

    public const float LATE_REVERB_DELAY_MIN = 0.0f;

    public const float LATE_REVERB_GAIN_MAX = 10.0f;

    public const float LATE_REVERB_GAIN_MIN = 0.0f;

    public const float LF_REFERENCE_MAX = 1000f;

    public const float LF_REFERENCE_MIN = 20f;

    public const float MODULATION_DEPTH_MAX = 1.0f;

    public const float MODULATION_DEPTH_MIN = 0.0f;

    public const float MODULATION_TIME_MAX = 4.0f;

    public const float MODULATION_TIME_MIN = 0.04f;

    public const float REFLECTIONS_DELAY_MAX = 0.3f;

    public const float REFLECTIONS_DELAY_MIN = 0.0f;

    public const float REFLECTIONS_GAIN_MAX = 3.16f;

    public const float REFLECTIONS_GAIN_MIN = 0.0f;

    public const float ROOM_ROLLOFF_FACTOR_MAX = 10.0f;

    public const float ROOM_ROLLOFF_FACTOR_MIN = 0.0f;

    public static Vector LATE_REVERB_PAN_MAX = new(1);

    public static Vector LATE_REVERB_PAN_MIN = new(-1);

    public static Vector REFLECTIONS_PAN_MAX = new(1);

    public static Vector REFLECTIONS_PAN_MIN = new(-1);
}

const EAXConstants = va.EAXConstants;

class EAXConstants {
    // All values are read-only
    get AIR_ABSORPTION_GAIN_HF_MAX();
    get AIR_ABSORPTION_GAIN_HF_MIN();
    get DECAY_HF_LIMIT_MAX();
    get DECAY_HF_LIMIT_MIN();
    get DECAY_HF_RATIO_MAX();
    get DECAY_HF_RATIO_MIN();
    get DECAY_LF_RATIO_MAX();
    get DECAY_LF_RATIO_MIN();
    get DECAY_TIME_MAX();
    get DECAY_TIME_MIN();
    get DENSITY_MAX();
    get DENSITY_MIN();
    get DIFFUSION_MAX();
    get DIFFUSION_MIN();
    get ECHO_DEPTH_MAX();
    get ECHO_DEPTH_MIN();
    get ECHO_TIME_MAX();
    get ECHO_TIME_MIN();
    get GAIN_HF_MAX();
    get GAIN_HF_MIN();
    get GAIN_LF_MAX();
    get GAIN_LF_MIN();
    get GAIN_MAX();
    get GAIN_MIN();
    get HF_REFERENCE_MAX();
    get HF_REFERENCE_MIN();
    get LATE_REVERB_DELAY_MAX();
    get LATE_REVERB_DELAY_MIN();
    get LATE_REVERB_GAIN_MAX();
    get LATE_REVERB_GAIN_MIN();
    get LATE_REVERB_PAN_MAX();
    get LATE_REVERB_PAN_MIN();
    get LF_REFERENCE_MAX();
    get LF_REFERENCE_MIN();
    get MODULATION_DEPTH_MAX();
    get MODULATION_DEPTH_MIN();
    get MODULATION_TIME_MAX();
    get MODULATION_TIME_MIN();
    get REFLECTIONS_DELAY_MAX();
    get REFLECTIONS_DELAY_MIN();
    get REFLECTIONS_GAIN_MAX();
    get REFLECTIONS_GAIN_MIN();
    get REFLECTIONS_PAN_MAX();
    get REFLECTIONS_PAN_MIN();
    get ROOM_ROLLOFF_FACTOR_MAX();
    get ROOM_ROLLOFF_FACTOR_MIN();
}

public class EAXReverb
{
    // Linear gain applied per meter of distance for high-frequency air absorption (0.892–1)
    public float AirAbsorptionGainHF;

    // Whether to limit high-frequency decay time to the air absorption limit (0 or 1)
    public int DecayHFLimit;

    // Ratio of high-frequency decay time to mid-frequency decay time (0.1–2)
    public float DecayHFRatio;

    // Ratio of low-frequency decay time to mid-frequency decay time (0.1–2)
    public float DecayLFRatio;

    // Reverberation decay time at mid frequencies, in seconds (0.1–20)
    public float DecayTime;

    // Modal density of the late reverberation (0–1)
    public float Density;

    // Echo diffusion of the late reverberation (0–1)
    public float Diffusion;

    // Amplitude of the echo effect (0–1)
    public float EchoDepth;

    // Cycling time of the echo effect, in seconds (0.075–0.25)
    public float EchoTime;

    // Overall linear gain of the reverb (0–1)
    public float Gain;

    // High-frequency gain of the reverb (0–1)
    public float GainHF;

    // Low-frequency gain of the reverb (0–1)
    public float GainLF;

    // Reference frequency for high-frequency decay ratio, in Hz (1000–20000)
    public float HFReference;

    // Delay of late reverberation relative to early reflections, in seconds (0–0.1)
    public float LateReverbDelay;

    // Linear gain of late reverberation (0–10)
    public float LateReverbGain;

    // Reference frequency for low-frequency decay ratio, in Hz (20–1000)
    public float LFReference;

    // Amplitude of the modulation effect (0–1)
    public float ModulationDepth;

    // Cycling time of the modulation effect, in seconds (0.04–4)
    public float ModulationTime;

    // Delay before early reflections are heard, in seconds (0–0.3)
    public float ReflectionsDelay;

    // Linear gain of early reflections (0–3.16)
    public float ReflectionsGain;

    // The direction that both early reflections and late reverb should be heard from, relative to each emitters with HasRelativeReverb set to true
    public Dictionary<Emitter, Vector> RelativeDirections;

    // The gain for this reverb effect, relative to each emitter with HasRelativeReverb set to true
    public Dictionary<Emitter, float> RelativeGains;

    // Rolloff factor for reflected sound sources (0–10)
    public float RoomRolloffFactor;

    public override bool Equals(object obj);

    public override int GetHashCode();

    // Create an empty EAXReverb object
    public static EAXReverb CreateEmpty();
}

interface EAXReverb {

    // Linear gain applied per meter of distance for high-frequency air absorption (0.892–1)
    get airAbsorptionGainHF();

    // Whether to limit high-frequency decay time to the air absorption limit (0 or 1)
    get decayHFLimit();

    // Ratio of high-frequency decay time to mid-frequency decay time (0.1–2)
    get decayHFRatio();

    // Ratio of low-frequency decay time to mid-frequency decay time (0.1–2)
    get decayLFRatio();

    // Reverberation decay time at mid frequencies, in seconds (0.1–20)
    get decayTime();

    // Modal density of the late reverberation (0–1)
    get density();

    // Echo diffusion of the late reverberation (0–1)
    get diffusion();

    // Amplitude of the echo effect (0–1)
    get echoDepth();

    // Cycling time of the echo effect, in seconds (0.075–0.25)
    get echoTime();

    // Overall linear gain of the reverb (0–1)
    get gain();

    // High-frequency gain of the reverb (0–1)
    get gainHF();

    // Low-frequency gain of the reverb (0–1)
    get gainLF();

    // Reference frequency for high-frequency decay ratio, in Hz (1000–20000)
    get hfReference();

    // Delay of late reverberation relative to early reflections, in seconds (0–0.1)
    get lateReverbDelay();

    // Linear gain of late reverberation (0–10)
    get lateReverbGain();

    // Reference frequency for low-frequency decay ratio, in Hz (20–1000)
    get lfReference();

    // Amplitude of the modulation effect (0–1)
    get modulationDepth();

    // Cycling time of the modulation effect, in seconds (0.04–4)
    get modulationTime();

    // Delay before early reflections are heard, in seconds (0–0.3)
    get reflectionsDelay();

    // Linear gain of early reflections (0–3.16)
    get reflectionsGain();

    // Rolloff factor for reflected sound sources (0–10)
    get roomRolloffFactor();

    // Returns the reverb direction for the given emitter. Returns null if the emitter does not have hasRelativeReverb set to true
    relativeDirections(emitter);

    // Returns the effect slot gain for the given emitter. Returns -1 if the emitter does not have hasRelativeReverb set to true
    relativeGains(emitter);
}

typedef struct VAEAXReverb
{
    float outsidePercent;
    float returningPercent;
    float materialAbsorptionLF;
    float materialAbsorptionHF;
    float materialRoughness;

    List* relativeDirections;       /* Direction that reverb should be heard from, relative to each emitter with hasRelativeReverb=true. Access via vaEaxReverbGetRelativeDirection */
    List* relativeGains;            /* Gain for this reverb effect, relative to each emitter with hasRelativeReverb=true. Access via vaEaxReverbGetRelativeGain */

    float reflectionsDelay;         /* Delay before early reflections are heard, in seconds (0–0.3) */
    float density;                  /* Modal density of the late reverberation (0–1) */
    float diffusion;                /* Echo diffusion of the late reverberation (0–1) */
    float gainLF;                   /* Low-frequency gain of the reverb (0–1) */
    float gainHF;                   /* High-frequency gain of the reverb (0–1) */
    float gain;                     /* Overall linear gain of the reverb (0–1) */
    float decayTime;                /* Reverberation decay time at mid frequencies, in seconds (0.1–20) */
    float decayLFRatio;             /* Ratio of low-frequency decay time to mid-frequency decay time (0.1–2) */
    float decayHFRatio;             /* Ratio of high-frequency decay time to mid-frequency decay time (0.1–2) */
    float reflectionsGain;          /* Linear gain of early reflections (0–3.16) */
    float lateReverbGain;           /* Linear gain of late reverberation (0–10) */
    float lateReverbDelay;          /* Delay of late reverberation relative to early reflections, in seconds (0–0.1) */
    float echoTime;                 /* Cycling time of the echo effect, in seconds (0.075–0.25) */
    float echoDepth;                /* Amplitude of the echo effect (0–1) */
    float modulationTime;           /* Cycling time of the modulation effect, in seconds (0.04–4) */
    float modulationDepth;          /* Amplitude of the modulation effect (0–1) */
    float airAbsorptionGainHF;      /* Linear gain applied per meter of distance for high-frequency air absorption (0.892–1) */
    float hfReference;              /* Reference frequency for high-frequency decay ratio, in Hz (1000–20000) */
    float lfReference;              /* Reference frequency for low-frequency decay ratio, in Hz (20–1000) */
    float roomRolloffFactor;        /* Rolloff factor for reflected sound sources (0–10) */
    int decayHFLimit;               /* Whether to limit high-frequency decay time to the air absorption limit (0 or 1) */

    int isTempBackground;
} VAEAXReverb;

// Returns NULL if no entry exists for this emitter.
VAVector* vaEaxReverbGetRelativeDirection(const VAEAXReverb* eax, const VAEmitter* emitter);

// Returns NULL if no entry exists for this emitter.
float* vaEaxReverbGetRelativeGain(const VAEAXReverb* eax, const VAEmitter* emitter);

public static class EAXUtils
{
    // Finds the candidate reverb preset most similar to the target
    public static EAXReverb FindBestMatch(EAXReverb target, List<EAXReverb> candidates, out int index);

    // Computes a similarity score between two reverb presets
    public static float GetSimilarity(EAXReverb a, EAXReverb b);
}

const EAXUtils = va.EAXUtils;

class EAXUtils {
    // Returns a similarity score between two EAX reverb result objects
    static getSimilarity(a, b);

    // Returns { result, index } — result is the best-matching candidate or null
    static findBestMatch(target, candidates);
}

public class ProcessedReverb
{
    // The average absorption of all surfaces that all rays hit.
    public float MaterialAbsorption;

    // The average high-frequency absorption of all surfaces that all rays hit.
    public float MaterialAbsorptionHF;

    // The average low-frequency absorption of all surfaces that all rays hit.
    public float MaterialAbsorptionLF;

    // The average roughness/scattering of all surfaces that all rays hit.
    public float MaterialRoughness;

    // Inverse of MaterialRoughness.
    public float MaterialSmoothness;

    // The high-frequency reverberation decay time measured from the echogram.
    // Calculated using RT20, RT30, or RT60 method depending on echogram length and room size.
    // Used to calculate EAX DecayTime and DecayHFRatio.
    public float MeasuredDecayTimeHF;

    // The low-frequency reverberation decay time measured from the echogram.
    // Calculated using RT20, RT30, or RT60 method depending on echogram length and room size.
    // Used to calculate EAX DecayTime and DecayLFRatio.
    public float MeasuredDecayTimeLF;

    // The percentage of energy that escaped outside (hit the world edge).
    // Calculated as raw.OutsideTotal / (ReverbRayCount * ReverbBounceCount)
    public float OutsidePercent;

    // The percentage of energy that returned back to the emitter.
    // Calculated as raw.ReturnedTotal / (ReverbRayCount * ReverbBounceCount)
    public float ReturnedPercent;
}

interface ProcessedReverb {

    // Average absorption of all surfaces that all rays hit
    get materialAbsorption();

    // Average high-frequency absorption of all surfaces that all rays hit
    get materialAbsorptionHF();

    // Average low-frequency absorption of all surfaces that all rays hit
    get materialAbsorptionLF();

    // Average roughness/scattering of all surfaces that all rays hit
    get materialRoughness();

    // Inverse of materialRoughness
    get materialSmoothness();

    // High-frequency reverberation decay time measured from the echogram, in seconds
    get measuredDecayTimeHF();

    // Low-frequency reverberation decay time measured from the echogram, in seconds
    get measuredDecayTimeLF();

    // Percentage of energy that escaped outside the world edge
    get outsidePercent();

    // Percentage of energy that returned back to the emitter
    get returnedPercent();
}

typedef struct VAProcessedReverb
{
    // percentages
    float returningPercent;        /* Percentage of energy that returned to the emitter. Calculated as raw.returned_total / (reverb_ray_count * reverb_bounce_count) */
    float outsidePercent;          /* Percentage of energy that escaped outside. Calculated as raw.outside_total / (reverb_ray_count * reverb_bounce_count) */

    // decay times
    float measuredDecayTimeLF;   /* Low-frequency reverberation decay time from the echogram, in seconds. Calculated using RT20/RT30/RT60 method */
    float measuredDecayTimeHF;   /* High-frequency reverberation decay time from the echogram, in seconds. Calculated using RT20/RT30/RT60 method */

    // scattering
    float materialRoughness;       /* Average roughness/scattering of all surfaces hit by rays */

    // absorption
    float materialAbsorptionLF;   /* Average low-frequency absorption of all surfaces hit by rays */
    float materialAbsorptionHF;   /* Average high-frequency absorption of all surfaces hit by rays */
} VAProcessedReverb;

// Returns the average of material_absorption_lf and material_absorption_hf
float vaProcessedReverbGetMaterialAbsorption(const VAProcessedReverb* p);

public class RawReverb
{
    // The total length of all rays that returned to the listener. Use this to calculate the average returning ray length, i.e (DistanceTotal / ReverbRayCount)
    public float DistanceTotal;

    // The total number of times that a ray escaped outside (hit the world bounds). Will be in the range 0.0 to ReverbRayCount * ReverbBounceCount
    public float OutsideTotal;

    // The total number of times that a ray returned to the listener. Will be in the range 0.0 to ReverbRayCount * ReverbBounceCount
    public float ReturnedTotal;
}

interface RawReverb {

    // Total length of all rays that returned to the listener
    get distanceTotal();

    // Total number of times a ray escaped outside the world bounds (0 to reverbRayCount * reverbBounceCount)
    get outsideTotal();

    // Total number of times a ray returned to the listener (0 to reverbRayCount * reverbBounceCount)
    get returnedTotal();
}

typedef struct VARawReverb
{
    float distanceTotal;   /* Total length of all rays that returned to the listener. Divide by reverb_ray_count for average distance */
    float returnedTotal;   /* Total energy that returned to the listener (range: 0 to reverb_ray_count * reverb_bounce_count) */
    float outsideTotal;    /* Total energy that escaped outside the world bounds (range: 0 to reverb_ray_count * reverb_bounce_count) */
} VARawReverb;

public class AirAbsorptionSettings
{
    // Custom air absorption formula for high frequencies. Takes distance (meters) and returns energy loss as a percentage
    public Func<float, float> CustomFormulaHF;

    // Custom formula for low frequency sound. Takes distance (meters) and returns energy loss as a percentage
    public Func<float, float> CustomFormulaLF;

    // Relative humidity as a percentage (0–1)
    public float Humidity;

    // Atmospheric pressure in Pascals
    public float Pressure;

    // Air temperature in degrees Celsius
    public float Temperature;

    public AirAbsorptionSettings();
}

interface AirAbsorptionSettings {
    // Created via: va.AirAbsorptionSettings_Create()

    // Relative humidity as a percentage (0–1)
    get humidity(); set humidity(v);

    // Atmospheric pressure in Pascals
    get pressure(); set pressure(v);

    // Air temperature in degrees Celsius
    get temperature(); set temperature(v);
}

// Creates a new AirAbsorptionSettings with default values
VAAirAbsorptionSettings* vaAirAbsorptionCreate();

// Returns true if all settings values are within valid ranges
bool vaAirAbsorptionValidate(const VAAirAbsorptionSettings* settings);

// Setters
// Relative humidity as a percentage (0–1)
void vaAirAbsorptionSetHumidity(VAAirAbsorptionSettings* settings, float value);

// Air temperature in degrees Celsius
void vaAirAbsorptionSetTemperature(VAAirAbsorptionSettings* settings, float value);

// Atmospheric pressure in Pascals
void vaAirAbsorptionSetPressure(VAAirAbsorptionSettings* settings, float value);

// Custom formula for low frequency sound. NULL to use default
void vaAirAbsorptionSetCustomFormulaLF(VAAirAbsorptionSettings* settings, VAAirAbsorptionCustomFormula value);

// Custom formula for high frequency sound. NULL to use default
void vaAirAbsorptionSetCustomFormulaHF(VAAirAbsorptionSettings* settings, VAAirAbsorptionCustomFormula value);

// Getters
// Relative humidity as a percentage (0–1)
float vaAirAbsorptionGetHumidity(const VAAirAbsorptionSettings* settings);

// Air temperature in degrees Celsius
float vaAirAbsorptionGetTemperature(const VAAirAbsorptionSettings* settings);

// Atmospheric pressure in Pascals
float vaAirAbsorptionGetPressure(const VAAirAbsorptionSettings* settings);

// Custom LF formula. NULL means default is used
VAAirAbsorptionCustomFormula vaAirAbsorptionGetCustomFormulaLF(const VAAirAbsorptionSettings* settings);

// Custom HF formula. NULL means default is used
VAAirAbsorptionCustomFormula vaAirAbsorptionGetCustomFormulaHF(const VAAirAbsorptionSettings* settings);

// Frees all resources owned by this settings object
void vaAirAbsorptionFree(VAAirAbsorptionSettings* settings);

public class Emitter
{
    // Indicates whether this Emitter's EAX is blended to produced grouped EAX. Set this to false for listener emitters
    public bool AffectsGroupedEAX = true;

    // This object contains the LF and HF gain for ambient sounds, to be applied to a low pass filter
    public LowPassFilter AmbientFilter;

    // The custom formula for calculating the low- and high-frequency gains in for AmbientFilter. This is invoked for both low-frequency and high-frequency energy. Set to null to use the default formula.
    // Parameters: (bool lowFrequency, int ambientOcclusionRayCount, int ambientPermeationRayCount, int ambientPermeationBounceCount, float ambientOcclusionEnergy, float ambientPermeationEnergy)
    // Returns: float
    public Func<bool, int, int, int, float, float, float> AmbientGainFormula;

    // Number of bounces per ambient occlusion ray
    public int AmbientOcclusionBounceCount;

    // True if both AmbientOcclusionRayCount and AmbientOcclusionBounceCount are greater than zero
    public bool AmbientOcclusionEnabled;

    // The percentage of occlusion energy required for the emitter to be at full volume. Defaults to 15% of this emitter's AmbientOcclusionRayCount.
    public float AmbientOcclusionEnergyCap = 0.15f;

    // Number of ambient occlusion rays cast
    public int AmbientOcclusionRayCount;

    // Number of bounces per ambient permeation ray
    public int AmbientPermeationBounceCount;

    // The color of ambientPermeation rays in the debug window (dev build only)
    public Color AmbientPermeationColor = Color.Yellow.WithAlpha(0.0f);

    // True if both AmbientPermeationRayCount and AmbientPermeationBounceCount are greater than zero
    public bool AmbientPermeationEnabled;

    // The percentage of permeation energy required for the emitter to be at full volume. Defaults to 15% of this emitter's AmbientPermeationRayCount * AmbientPermeationBounceCount.
    public float AmbientPermeationEnergyCap = 0.15f;

    // Number of ambient permeation rays cast
    public int AmbientPermeationRayCount;

    // Whether this emitter casts rays. False if all ray counts and/or bounce counts are set to 0.
    public bool CastsRays;

    // Whether to clamp this emitter's position to the world bounds, to prevent it from going out of bounds
    public bool ClampPosition;

    // EAX reverb properties for the listener. Contains parameters compatible with EAX reverb effects
    public EAXReverb EAX;

    // The length (in milliseconds) of each entry in the echogram. Defaults to 50ms
    public int EchogramGranularity = 50;

    // The custom formula for calculating this emitter's low- and high-frequency gains when it is the target of another emitter. This is invoked for both low-frequency and high-frequency energy. Set to null to use the default formula.
    // Parameters: (bool lowFrequency, int occlusionRayCount, int permeationRayCount, int permeationBounceCount, float occlusionEnergy, float permeationEnergy)
    // Returns: float
    public Func<bool, int, int, int, float, float, float> GainFormula;

    // Index indicating which GroupedEAX reverb effect should be used for this emitter
    public int GroupedEAXIndex = -1;

    // Whether this emitter is used as a reference point for calculating relative reverb gain and direction
    public bool HasRelativeReverb;

    // True if this emitter hasn't cast its own rays yet.
    public bool Initialising = true;

    // A custom logging callback. Defaults to WriteLine()
    public Action<string> LogCallback;

    // A custom logging callback. Defaults to Error.WriteLine()
    public Action<string> LogErrorCallback;

    // How long (in milliseconds) the echogram records data for. Returning reverb rays after this period will be ignored. Defaults to 5000ms
    public int MaxEchogramTime = 5000;

    // The threshold below which permeation rays are cancelled to prevent unnecessary traversal. Clamped to minimum of 0
    public float MinimumPermeationEnergy = 0.01f;

    // User-defined name of this emitter
    public string Name = string.Empty;

    // Number of bounces per occlusion ray
    public int OcclusionBounceCount;

    // The color of occlusion rays in the debug window (dev build only)
    public Color OcclusionColor = Color.Green.WithAlpha(0.0f);

    // True if both OcclusionRayCount and OcclusionBounceCount are greater than zero
    public bool OcclusionEnabled;

    // The percentage of occlusion energy required for the emitter to be at full volume. Defaults to 15% of the other emitter's OcclusionRayCount.
    public float OcclusionEnergyCap = 0.15f;

    // Number of occlusion rays cast
    public int OcclusionRayCount;

    // Whether to only scatter rays around their yaw (no pitch or Y component)
    public bool OnlyScatterXZ;

    // A callback that is invoked when another emitter raytraces this emitter for the first time. The first argument is the other emitter that raytraced this emitter.
    public Action<Emitter> OnRaytracedByAnotherEmitter;

    // A callback that is invoked after this emitter casts its rays for the first time.
    public Action OnRaytracingComplete;

    // The percentage of ambient occlusion rays that reached the edge of the world. Ranges from 0.0 to 1.0
    public float OutsidePercent;

    // When defined, rays will be cast out of these positions rather than the default Position
    public Vector[] OverridePositions;

    // When defined, rays will be cast in these directions rather than the default spherical ray distribution
    public Vector[] OverrideRayDirections;

    // Number of bounces per permeation ray
    public int PermeationBounceCount;

    // The color of permeation rays in the debug window (dev build only)
    public Color PermeationColor = Color.Orange.WithAlpha(0.0f);

    // True if both PermeationRayCount and PermeationBounceCount are greater than zero
    public bool PermeationEnabled;

    // The percentage of permeation energy required for the emitter to be at full volume. Defaults to 15% of the other emitter's PermeationRayCount * PermeationBounceCount.
    public float PermeationEnergyCap = 0.15f;

    // Number of permeation rays cast
    public int PermeationRayCount;

    // The position of this Emitter. Can be a Vector3F or IPosition
    public IPosition Position = Vector.Zero;

    // Contains reverb data that has been transformed into more usable parameters
    public ProcessedReverb ProcessedReverb;

    // Whether to render each trail a different color (dev build only)
    public bool RandomTrailColor;

    // Raw reverb properties calculated directly from raytracing
    public RawReverb RawReverb;

    // A ray trail will be re-created if an old ray bounce position is too far away from the new ray bounce position. This setting controls the allowed distance between old and new ray bounce positions. Clamped to minimum of 0.
    public float RefreshDistanceThreshold = 1.0f;

    // The number of trails that are rebuilt from scratch each frame to prevent staleness when the listener moves. Clamped to minimum of 0.
    public int RefreshRayCount = 16;

    // The lower bound of the relative reverb blend range
    public float RelativeReverbInnerThreshold = 0.6f;

    // The upper bound of the relative reverb blend range
    public float RelativeReverbOuterThreshold = 0.8f;

    // The number of emitters that are allocated ahead of time, to prevent runtime allocations. Clamped to minimum of 0
    public int ReservedEmitterTargets;

    // Number of bounces per reverb ray
    public int ReverbBounceCount;

    // The color of reverb rays in the debug window (dev build only)
    public Color ReverbColor = Color.Cyan.WithAlpha(0.0f);

    // True if both ReverbRayCount and ReverbBounceCount are greater than zero
    public bool ReverbEnabled;

    // The amount of returning energy required for reverb to be at maximum volume. Defaults to 100. Must adjust this setting if adjusting reverb ray and bounce counts.
    public float ReverbEnergyCap = 100.0f;

    // Number of reverb rays cast
    public int ReverbRayCount;

    // A seed used to randomise scattering vectors
    public int ScatteringSeed;

    // Number of bounces per trail
    public int TrailBounceCount;

    // The color of ray trails in the debug window (dev build only)
    public Color TrailColor = Color.White.WithAlpha(0.2f);

    // Number of trails this emitter will create
    public int TrailCount;

    // User-defined type for this emitter
    public int Type;

    // Number of times each visualisation ray bounces
    public int VisualisationBounceCount;

    // Callback that is invoked with VisualisationData for each bounce produced by an emitter's visualisation rays. Do not modify the array or access it outside this callback.
    public Action<VisualisationData[]> VisualisationCallback;

    // True if both VisualisationRayCount and VisualisationBounceCount are greater than zero
    public bool VisualisationEnabled;

    // Number of visualisation rays cast
    public int VisualisationRayCount;

    // How often - in milliseconds - to cast visualisation rays
    public int VisualisationUpdateFrequency;

    // Emitters outside the world bounds will not be raytraced. Set ClampPosition to true to keep this emitter inside the world bounds
    public bool WithinWorldBounds;

    public Emitter();

    // Adds an emitter to this emitter's target list
    public void AddTarget(Emitter target);

    // Get an object containing the LF and HF gain for a target emitter, to be applied to a low pass filter.
    // Only access when HasRaytracedTarget(Emitter) is true.
    public LowPassFilter GetTargetFilter(Emitter target);

    // Returns whether a target emitter has been raytraced. If true, it is safe to check the target's filter via GetTargetFilter
    public bool HasRaytracedTarget(Emitter target);

    // Returns whether the target emitter is in this emitter's target list
    public bool HasTarget(Emitter target);

    // Removes an emitter from this emitter's target list
    public void RemoveTarget(Emitter target);

    // Call this function to invalidate the ray cache - all memory will be cleaned up and all rays will be re-cast
    public void ResetTrails();

    // Validates this emitter's configuration
    public void Validate();
}

interface Emitter {
    // Created via: va.Emitter_Create()

    // Whether this emitter's EAX is blended to produce grouped EAX. Set to false for listener emitters
    get affectsGroupedEAX(); set affectsGroupedEAX(v);

    // Number of bounces per ambient occlusion ray
    get ambientOcclusionBounceCount(); set ambientOcclusionBounceCount(v);

    // Percentage of occlusion energy required for ambient sounds to be at full volume
    get ambientOcclusionEnergyCap(); set ambientOcclusionEnergyCap(v);

    // Number of ambient occlusion rays cast
    get ambientOcclusionRayCount(); set ambientOcclusionRayCount(v);

    // Number of bounces per ambient permeation ray
    get ambientPermeationBounceCount(); set ambientPermeationBounceCount(v);

    // Percentage of permeation energy required for ambient sounds to be at full volume
    get ambientPermeationEnergyCap(); set ambientPermeationEnergyCap(v);

    // Number of ambient permeation rays cast
    get ambientPermeationRayCount(); set ambientPermeationRayCount(v);

    // Whether to clamp this emitter's position to the world bounds
    get clampPosition(); set clampPosition(v);

    // Length (in milliseconds) of each entry in the echogram. 10ms is recommended
    get echogramGranularity(); set echogramGranularity(v);

    // Index indicating which grouped EAX reverb effect should be used for this emitter
    get groupedEAXIndex(); set groupedEAXIndex(v);

    // Whether this emitter is used as a reference point for calculating relative reverb gain and direction
    get hasRelativeReverb(); set hasRelativeReverb(v);

    // True if this emitter hasn't cast its own rays yet
    get initialising(); set initialising(v);

    // How long (in milliseconds) the echogram records data for. Returning reverb rays after this period are ignored
    get maxEchogramTime(); set maxEchogramTime(v);

    // Threshold below which permeation rays are cancelled to prevent unnecessary traversal
    get minimumPermeationEnergy(); set minimumPermeationEnergy(v);

    // Number of bounces per occlusion ray
    get occlusionBounceCount(); set occlusionBounceCount(v);

    // Percentage of occlusion energy required for the emitter to be at full volume
    get occlusionEnergyCap(); set occlusionEnergyCap(v);

    // Number of occlusion rays cast
    get occlusionRayCount(); set occlusionRayCount(v);

    // Whether to only scatter rays around their yaw (no pitch or Y component)
    get onlyScatterXZ(); set onlyScatterXZ(v);

    // Percentage of ambient occlusion rays that reached the edge of the world (0.0 to 1.0)
    get outsidePercent(); set outsidePercent(v);

    // Number of bounces per permeation ray
    get permeationBounceCount(); set permeationBounceCount(v);

    // Percentage of permeation energy required for the emitter to be at full volume
    get permeationEnergyCap(); set permeationEnergyCap(v);

    // Number of permeation rays cast
    get permeationRayCount(); set permeationRayCount(v);

    // 3D position of this emitter
    get position(); set position(v);

    // A ray trail is re-created if an old bounce position is further than this distance from the new position
    get refreshDistanceThreshold(); set refreshDistanceThreshold(v);

    // Number of trails rebuilt from scratch each frame to prevent staleness when the listener moves
    get refreshRayCount(); set refreshRayCount(v);

    // Lower bound of the relative reverb blend range
    get relativeReverbInnerThreshold(); set relativeReverbInnerThreshold(v);

    // Upper bound of the relative reverb blend range
    get relativeReverbOuterThreshold(); set relativeReverbOuterThreshold(v);

    // Number of emitters allocated ahead of time to prevent runtime allocations
    get reservedEmitterTargets(); set reservedEmitterTargets(v);

    // Number of bounces per reverb ray
    get reverbBounceCount(); set reverbBounceCount(v);

    // Amount of returning energy required for reverb to be at maximum volume
    get reverbEnergyCap(); set reverbEnergyCap(v);

    // Number of reverb rays cast
    get reverbRayCount(); set reverbRayCount(v);

    // User-defined type for this emitter
    get type(); set type(v);

    // Number of times each visualisation ray bounces
    get visualisationBounceCount(); set visualisationBounceCount(v);

    // Number of visualisation rays cast
    get visualisationRayCount(); set visualisationRayCount(v);

    // How often (in milliseconds) to cast visualisation rays
    get visualisationUpdateFrequency(); set visualisationUpdateFrequency(v);

    // Low- and high-frequency gain for ambient sounds
    get ambientFilter();

    // True if both ambientOcclusionRayCount and ambientOcclusionBounceCount are greater than zero
    get ambientOcclusionEnabled();

    // True if both ambientPermeationRayCount and ambientPermeationBounceCount are greater than zero
    get ambientPermeationEnabled();

    // Whether this emitter casts rays. False if all ray counts and/or bounce counts are 0
    get castsRays();

    // EAX reverb properties for the listener, compatible with EAX reverb effects
    get eax();

    // True if both occlusionRayCount and occlusionBounceCount are greater than zero
    get occlusionEnabled();

    // True if both permeationRayCount and permeationBounceCount are greater than zero
    get permeationEnabled();

    // Reverb data transformed into more usable parameters
    get processedReverb();

    // Raw reverb properties calculated directly from raytracing
    get rawReverb();

    // True if both reverbRayCount and reverbBounceCount are greater than zero
    get reverbEnabled();

    // Number of bounces per trail
    get trailBounceCount();

    // Number of trails this emitter will create
    get trailCount();

    // True if both visualisationRayCount and visualisationBounceCount are greater than zero
    get visualisationEnabled();

    // Whether this emitter is within the world bounds. Emitters outside the world are not raytraced
    get withinWorldBounds();

    // When defined, rays are cast from these positions rather than the emitter's position
    set overridePositions(v);

    // When defined, rays are cast in these directions rather than the default spherical distribution
    set overrideRayDirections(v);

    // Invoked with each bounce produced by visualisation rays. Do not store the array outside the callback
    set visualisationCallback(v);

    // Invoked when another emitter raytraces this emitter for the first time
    set onRaytracedByAnotherEmitter(fn);

    // Invoked after this emitter casts its rays for the first time
    set onRaytracingComplete(fn);

    // Adds an emitter to this emitter's target list
    addTarget(target);

    // Returns an object containing the LF and HF gain for a target emitter. Only access when hasRaytracedTarget is true
    getTargetFilter(target);

    // Returns the current ray trails for this emitter
    getWasmTrails(prev?);

    // Returns whether a target emitter has been raytraced. If true, it is safe to check the target's filter via getTargetFilter
    hasRaytracedTarget(target);

    // Returns whether the target emitter is in this emitter's target list
    hasTarget(target);

    // Removes an emitter from this emitter's target list
    removeTarget(target);

    // Invalidates the ray cache — all memory is cleaned up and all rays are re-cast
    resetTrails();

    // Sets the position of this emitter
    setPosition(x, y, z);

    // Validates this emitter's configuration
    validate();
}

// Creates a new emitter with default settings.
VAEmitter* vaEmitterCreate(void);

// Frees all resources owned by this emitter.
void vaEmitterDestroy(VAEmitter* emitter);

// Returns true if target has been added to this emitter via vaEmitterAddTarget().
bool vaEmitterHasTarget(VAEmitter* emitter, VAEmitter* target);

// Returns true if raytracing has produced results for this target at least once.
bool vaEmitterHasRaytracedTarget(VAEmitter* emitter, VAEmitter* target);

// Only safe to call when vaEmitterHasRaytracedTarget() returns true.
VALowPassFilter* vaEmitterGetTargetFilter(VAEmitter* emitter, VAEmitter* target);

int vaEmitterAddTarget(VAEmitter* emitter, VAEmitter* target);

// Removes a previously added target from this emitter.
void vaEmitterRemoveTarget(VAEmitter* emitter, VAEmitter* target);

// Invalidates the ray cache; all rays will be re-cast on the next Update().
void vaEmitterResetTrails(VAEmitter* emitter);

// Number of reverb rays cast per frame.
void vaEmitterSetReverbRayCount(VAEmitter* emitter, int value);

// Maximum number of bounces per reverb ray.
void vaEmitterSetReverbBounceCount(VAEmitter* emitter, int value);

// Number of occlusion rays cast per frame.
void vaEmitterSetOcclusionRayCount(VAEmitter* emitter, int value);

// Maximum number of bounces per occlusion ray.
void vaEmitterSetOcclusionBounceCount(VAEmitter* emitter, int value);

// Number of permeation rays cast per frame.
void vaEmitterSetPermeationRayCount(VAEmitter* emitter, int value);

// Maximum number of bounces per permeation ray.
void vaEmitterSetPermeationBounceCount(VAEmitter* emitter, int value);

// Number of ambient occlusion rays cast per frame.
void vaEmitterSetAmbientOcclusionRayCount(VAEmitter* emitter, int value);

// Maximum number of bounces per ambient occlusion ray.
void vaEmitterSetAmbientOcclusionBounceCount(VAEmitter* emitter, int value);

// Number of ambient permeation rays cast per frame.
void vaEmitterSetAmbientPermeationRayCount(VAEmitter* emitter, int value);

// Maximum number of bounces per ambient permeation ray.
void vaEmitterSetAmbientPermeationBounceCount(VAEmitter* emitter, int value);

// Energy threshold below which permeation rays are cancelled to prevent unnecessary traversal.
void vaEmitterSetMinimumPermeationEnergy(VAEmitter* emitter, float value);

int vaEmitterSetReverbEnergyCap(VAEmitter* emitter, float value);

int vaEmitterSetOverridePositions(VAEmitter* emitter, VAVector* positions, int count);

int vaEmitterSetOverrideRayDirections(VAEmitter* emitter, VAVector* directions, int count);

int vaEmitterSetGainFormula(VAEmitter* emitter, VAEmitterGainFormula formula);

int vaEmitterSetAmbientGainFormula(VAEmitter* emitter, VAEmitterGainFormula formula);

// True if reverb ray count and bounce count are both greater than zero.
bool vaEmitterReverbEnabled(const VAEmitter* emitter);

// True if occlusion ray count and bounce count are both greater than zero.
bool vaEmitterOcclusionEnabled(const VAEmitter* emitter);

// True if permeation ray count and bounce count are both greater than zero.
bool vaEmitterPermeationEnabled(const VAEmitter* emitter);

// True if ambient occlusion ray count and bounce count are both greater than zero.
bool vaEmitterAmbientOcclusionEnabled(const VAEmitter* emitter);

// True if ambient permeation ray count and bounce count are both greater than zero.
bool vaEmitterAmbientPermeationEnabled(const VAEmitter* emitter);

// True if visualisation ray count and bounce count are both greater than zero.
bool vaEmitterVisualisationEnabled(const VAEmitter* emitter);

// False if all ray counts and/or bounce counts are set to 0.
bool vaEmitterCastsRays(const VAEmitter* emitter);

// Emitters outside the world bounds will not be raytraced; set clampPosition to true to keep them inside the world.
bool vaEmitterWithinWorldBounds(const VAEmitter* emitter);

// Invoked after this emitter casts its rays for the first time.
void vaEmitterSetOnRaytracingCompleteCallback(VAEmitter* emitter, VAEmitterOnRaytracingComplete callback);

// Invoked when another emitter raytraces this emitter for the first time.
void vaEmitterSetOnRaytracedByAnotherEmitterCallback(VAEmitter* emitter, VAEmitterOnRaytracedByAnotherEmitter callback);

// Invoked with bounce data produced by visualisation rays; do not modify the array or access it outside the callback.
void vaEmitterSetVisualisationCallback(VAEmitter* emitter, VAEmitterVisualisationCallback callback);

// Invoked for informational log messages from this emitter.
void vaEmitterSetLogCallback(VAEmitter* emitter, VALogCallback callback);

// Invoked for error log messages from this emitter.
void vaEmitterSetLogErrorCallback(VAEmitter* emitter, VALogCallback callback);

// World-space position of this emitter.
void vaEmitterSetPosition(VAEmitter* emitter, VAVector position);

// World-space position of this emitter.
VAVector vaEmitterGetPosition(const VAEmitter* emitter);

// When true, the emitter has not yet received its first raytracing result.
bool vaEmitterGetInitialising(const VAEmitter* emitter);

// Whether this emitter's EAX is blended into grouped EAX. Set to false for listener emitters.
void vaEmitterSetAffectsGroupedEax(VAEmitter* emitter, bool value);

// Whether this emitter's EAX is blended into grouped EAX.
bool vaEmitterGetAffectsGroupedEax(const VAEmitter* emitter);

// Which grouped EAX reverb effect applies to this emitter (-1 = none).
void vaEmitterSetGroupedEaxIndex(VAEmitter* emitter, int value);

// Index into the world's grouped eax list (-1 = none).
int vaEmitterGetGroupedEaxIndex(const VAEmitter* emitter);

// Read-only percentage of energy in ambient occlusion rays that reached the edge of the world (0–1).
float vaEmitterGetOutsidePercent(const VAEmitter* emitter);

// Whether this emitter is used as a reference point for calculating relative reverb gain and direction.
void vaEmitterSetHasRelativeReverb(VAEmitter* emitter, bool value);

bool vaEmitterGetHasRelativeReverb(const VAEmitter* emitter);

// Lower bound of the relative reverb blend range.
void vaEmitterSetRelativeReverbInnerThreshold(VAEmitter* emitter, float value);

float vaEmitterGetRelativeReverbInnerThreshold(const VAEmitter* emitter);

// Upper bound of the relative reverb blend range.
void vaEmitterSetRelativeReverbOuterThreshold(VAEmitter* emitter, float value);

float vaEmitterGetRelativeReverbOuterThreshold(const VAEmitter* emitter);

// When true, position is clamped to world bounds to prevent going out of bounds.
void vaEmitterSetClampPosition(VAEmitter* emitter, bool value);

bool vaEmitterGetClampPosition(const VAEmitter* emitter);

// Seed used to randomise scattering vectors.
void vaEmitterSetScatteringSeed(VAEmitter* emitter, int value);

int vaEmitterGetScatteringSeed(const VAEmitter* emitter);

// Display name for debugging and logging.
void vaEmitterSetName(VAEmitter* emitter, const char* name);

// Display name for debugging and logging.
const char* vaEmitterGetName(const VAEmitter* emitter);

// User-defined integer tag for categorising emitters.
void vaEmitterSetType(VAEmitter* emitter, int value);

// User-defined integer tag for categorising emitters.
int vaEmitterGetType(const VAEmitter* emitter);

// Number of reverb rays cast per frame.
int vaEmitterGetReverbRayCount(const VAEmitter* emitter);

// Maximum number of bounces per reverb ray.
int vaEmitterGetReverbBounceCount(const VAEmitter* emitter);

// Number of occlusion rays cast per frame.
int vaEmitterGetOcclusionRayCount(const VAEmitter* emitter);

// Maximum number of bounces per occlusion ray.
int vaEmitterGetOcclusionBounceCount(const VAEmitter* emitter);

// Number of permeation rays cast per frame.
int vaEmitterGetPermeationRayCount(const VAEmitter* emitter);

// Maximum number of bounces per permeation ray.
int vaEmitterGetPermeationBounceCount(const VAEmitter* emitter);

// Number of ambient occlusion rays cast per frame.
int vaEmitterGetAmbientOcclusionRayCount(const VAEmitter* emitter);

// Maximum number of bounces per ambient occlusion ray.
int vaEmitterGetAmbientOcclusionBounceCount(const VAEmitter* emitter);

// Number of ambient permeation rays cast per frame.
int vaEmitterGetAmbientPermeationRayCount(const VAEmitter* emitter);

// Maximum number of bounces per ambient permeation ray.
int vaEmitterGetAmbientPermeationBounceCount(const VAEmitter* emitter);

// Number of visualisation rays cast per visualisation update.
int vaEmitterGetVisualisationRayCount(const VAEmitter* emitter);

// Number of visualisation rays cast per visualisation update.
void vaEmitterSetVisualisationRayCount(VAEmitter* emitter, int value);

// Maximum number of bounces per visualisation ray.
int vaEmitterGetVisualisationBounceCount(const VAEmitter* emitter);

// Maximum number of bounces per visualisation ray.
void vaEmitterSetVisualisationBounceCount(VAEmitter* emitter, int value);

// Interval in milliseconds between visualisation ray updates.
int vaEmitterGetVisualisationUpdateFrequency(const VAEmitter* emitter);

// Interval in milliseconds between visualisation ray updates.
void vaEmitterSetVisualisationUpdateFrequency(VAEmitter* emitter, int value);

// Total number of trails (reverb + occlusion + permeation) owned by this emitter.
int vaEmitterGetTrailCount(const VAEmitter* emitter);

// Total bounce budget per trail across all ray types.
int vaEmitterGetTrailBounceCount(const VAEmitter* emitter);

// How long (ms) the echogram records data. Returning reverb rays after this period are ignored. Defaults to 5000ms.
int vaEmitterGetMaxEchogramTime(const VAEmitter* emitter);

// How long (ms) the echogram records data. Returning reverb rays after this period are ignored. Defaults to 5000ms.
void vaEmitterSetMaxEchogramTime(VAEmitter* emitter, int value);

// Length (ms) of each entry in the echogram. Defaults to 50ms.
int vaEmitterGetEchogramGranularity(const VAEmitter* emitter);

// Length (ms) of each entry in the echogram. Defaults to 50ms.
void vaEmitterSetEchogramGranularity(VAEmitter* emitter, int value);

// Number of trails rebuilt from scratch each frame to prevent staleness when the emitter moves. Minimum 0.
int vaEmitterGetRefreshRayCount(const VAEmitter* emitter);

// Number of trails rebuilt from scratch each frame to prevent staleness when the emitter moves. Minimum 0.
void vaEmitterSetRefreshRayCount(VAEmitter* emitter, int value);

// A trail is re-created when an old bounce position is this far from the new position. Minimum 0.
float vaEmitterGetRefreshDistanceThreshold(const VAEmitter* emitter);

// A trail is re-created when an old bounce position is this far from the new position. Minimum 0.
void vaEmitterSetRefreshDistanceThreshold(VAEmitter* emitter, float value);

// Amount of returning energy required for reverb to be at maximum volume. Defaults to 100.
float vaEmitterGetReverbEnergyCap(const VAEmitter* emitter);

// Percentage of occlusion energy required for the emitter to be at full volume. Defaults to 15% of occlusionRayCount.
float vaEmitterGetOcclusionEnergyCap(const VAEmitter* emitter);

int vaEmitterSetOcclusionEnergyCap(VAEmitter* emitter, float value);

// Percentage of permeation energy required for the emitter to be at full volume. Defaults to 15% of permeationRayCount * permeationBounceCount.
float vaEmitterGetPermeationEnergyCap(const VAEmitter* emitter);

int vaEmitterSetPermeationEnergyCap(VAEmitter* emitter, float value);

// Percentage of ambient occlusion energy required for the emitter to be at full volume.
float vaEmitterGetAmbientOcclusionEnergyCap(const VAEmitter* emitter);

int vaEmitterSetAmbientOcclusionEnergyCap(VAEmitter* emitter, float value);

// Percentage of ambient permeation energy required for the emitter to be at full volume.
float vaEmitterGetAmbientPermeationEnergyCap(const VAEmitter* emitter);

int vaEmitterSetAmbientPermeationEnergyCap(VAEmitter* emitter, float value);

// Number of target emitter slots pre-allocated. Minimum 0.
int vaEmitterGetReservedEmitterCount(const VAEmitter* emitter);

// Number of target emitter slots pre-allocated. Minimum 0.
void vaEmitterSetReservedEmitterCount(VAEmitter* emitter, int value);

// Energy threshold below which permeation rays are cancelled to prevent unnecessary traversal.
float vaEmitterGetMinimumPermeationEnergy(const VAEmitter* emitter);

// Raw reverb results; only valid after raytracing has run at least once.
VARawReverb* vaEmitterGetRawReverb(const VAEmitter* emitter);

// Processed reverb results; only valid after raytracing has run at least once.
VAProcessedReverb* vaEmitterGetProcessedReverb(const VAEmitter* emitter);

// EAX reverb results; only valid after raytracing has run at least once.
VAEAXReverb* vaEmitterGetEAX(const VAEmitter* emitter);

// LF and HF gain for ambient sounds to apply to a low pass filter.
VALowPassFilter* vaEmitterGetAmbientFilter(const VAEmitter* emitter);

public class LowPassFilter
{
    // High-frequency gain in the range 0.0 to 1.0
    public float GainHF;

    // Low-frequency gain in the range 0.0 to 1.0
    public float GainLF;
}

interface LowPassFilter {
    // Created via: va.LowPassFilter_Create()

    // High-frequency gain in the range 0.0 to 1.0
    get gainHF(); set gainHF(v);

    // Low-frequency gain in the range 0.0 to 1.0
    get gainLF(); set gainLF(v);
}

typedef struct VALowPassFilter
{
    // Low-frequency gain in the range 0.0 to 1.0
    float gainLF;
    // High-frequency gain in the range 0.0 to 1.0
    float gainHF;
} VALowPassFilter;

public class MaterialProperties
{
    // Percentage of high-frequency energy that is lost on each bounce (0.0 to 1.0).
    public float AbsorptionHF;

    // Percentage of low-frequency energy that is lost on each bounce (0.0 to 1.0).
    public float AbsorptionLF;

    // Percentage of high-frequency energy lost when a ray passes through a flat PlanePrimitive, DiskPrimitive, TrianglePrimitive or non-watertight MeshPrimitive. Ranges from 0.0 to 1.0
    public float PlaneTransmissionHF;

    // Percentage of low-frequency energy lost when a ray passes through a flat PlanePrimitive, DiskPrimitive, TrianglePrimitive or non-watertight MeshPrimitive. Ranges from 0.0 to 1.0
    public float PlaneTransmissionLF;

    // Scattering strength (0.0 to 1.0), where 0.0 has no scattering and 1.0 skews the ray reflection direction by up to 90 degrees
    public float Scattering;

    // High-frequency transmission in decibels per meter (0.0 or greater).
    public float TransmissionHF;

    // Low-frequency transmission in decibels per meter (0.0 or greater).
    public float TransmissionLF;

    // Create a MaterialProperties with all values set to 0
    public MaterialProperties();

    // Create a MaterialProperties with all values provided
    public MaterialProperties(float absorptionLF, float absorptionHF, float scattering, float transmissionLF, float transmissionHF, float planeTransmissionLF, float planeTransmissionHF);

    // Create a MaterialProperties with the same values as another
    public MaterialProperties(MaterialProperties prop);

    // Copy all properties from another MaterialProperties
    public void Update(MaterialProperties prop);

    // Update all properties
    public void Update(float absorptionLF, float absorptionHF, float scattering, float transmissionLF, float transmissionHF, float planeTransmissionLF, float planeTransmissionHF);

    // Returns the dB/m transmission value that reduces energy to 0.1% after travelling metersToBlock meters through a material
    public static float TransmissionForThickness(float metersToBlock);
}

interface MaterialProperties {
    // Created via: va.MaterialProperties_Create()
    // Also: va.MaterialProperties_CreateWith(absorptionLF, absorptionHF, scattering, transmissionLF, transmissionHF, planeTransmissionLF, planeTransmissionHF)

    // Percentage of high-frequency energy lost on each bounce (0.0 to 1.0)
    get absorptionHF(); set absorptionHF(v);

    // Percentage of low-frequency energy lost on each bounce (0.0 to 1.0)
    get absorptionLF(); set absorptionLF(v);

    // Percentage of high-frequency energy lost when a ray passes through a flat plane, disk, triangle, or non-watertight mesh (0.0 to 1.0)
    get planeTransmissionHF(); set planeTransmissionHF(v);

    // Percentage of low-frequency energy lost when a ray passes through a flat plane, disk, triangle, or non-watertight mesh (0.0 to 1.0)
    get planeTransmissionLF(); set planeTransmissionLF(v);

    // Scattering strength (0.0 to 1.0), where 0.0 has no scattering and 1.0 scatters up to 90 degrees from the reflected direction
    get scattering(); set scattering(v);

    // High-frequency transmission in dB/m (0.0 or greater)
    get transmissionHF(); set transmissionHF(v);

    // Low-frequency transmission in dB/m (0.0 or greater)
    get transmissionLF(); set transmissionLF(v);
}

public enum MaterialType
{
    Air = 0,
    Brick,
    Cloth,
    Concrete,
    ConcretePolished,
    Dirt,
    Glass,
    Grass,
    Gravel,
    Gyprock,
    Ice,
    Leaf,
    Marble,
    Metal,
    Mud,
    Rock,
    Sand,
    Snow,
    Tile,
    Tree,
    Water,
    WoodIndoor,
    WoodOutdoor,
}

// Available via: import { MaterialType } from 'vaudio';
const MaterialType = {
    Air: 0,
    Brick: 1,
    Cloth: 2,
    Concrete: 3,
    ConcretePolished: 4,
    Dirt: 5,
    Glass: 6,
    Grass: 7,
    Gravel: 8,
    Gyprock: 9,
    Ice: 10,
    Leaf: 11,
    Marble: 12,
    Metal: 13,
    Mud: 14,
    Rock: 15,
    Sand: 16,
    Snow: 17,
    Tile: 18,
    Tree: 19,
    Water: 20,
    WoodIndoor: 21,
    WoodOutdoor: 22,
};

typedef enum VAMaterialType {
    VAMaterialAir = 0,
    VAMaterialBrick,
    VAMaterialCloth,
    VAMaterialConcrete,
    VAMaterialConcretePolished,
    VAMaterialDirt,
    VAMaterialGlass,
    VAMaterialGrass,
    VAMaterialGravel,
    VAMaterialGyprock,
    VAMaterialIce,
    VAMaterialLeaf,
    VAMaterialMarble,
    VAMaterialMetal,
    VAMaterialMud,
    VAMaterialRock,
    VAMaterialSand,
    VAMaterialSnow,
    VAMaterialTile,
    VAMaterialTree,
    VAMaterialWater,
    VAMaterialWoodIndoor,
    VAMaterialWoodOutdoor,
    VAMaterialTypeCount,
} VAMaterialType;

public struct Matrix
{
    public float M11;

    public float M12;

    public float M13;

    public float M14;

    public float M21;

    public float M22;

    public float M23;

    public float M24;

    public float M31;

    public float M32;

    public float M33;

    public float M34;

    public float M41;

    public float M42;

    public float M43;

    public float M44;

    public override bool Equals(object obj);

    public override int GetHashCode();

    // Returns the inverse of this matrix
    public Matrix Inverse();

    // Returns true if all elements are exactly equal to those in other
    public bool IsEqual(Matrix other);

    // Converts this matrix to a Matrix4x4
    public System.Numerics.Matrix4x4 ToNumerics();

    // Returns true if a does not equal b
    public static bool operator !=(Matrix a, Matrix b);

    // The identity matrix
    public static Matrix Identity = new(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);

    // Returns true if a equals b
    public static bool operator ==(Matrix a, Matrix b);

    // Create a rotation matrix from a Quaternion
    public static Matrix CreateFromQuaternion(System.Numerics.Quaternion q);

    // Create a transposed rotation matrix from a Quaternion
    public static Matrix CreateFromQuaternionTransposed(System.Numerics.Quaternion q);

    public static Matrix CreateOrthoProjection(float left, float top, float right, float bottom, float near, float far);

    // Create a rotation matrix around the X axis
    public static Matrix CreateRotationX(float rads);

    // Create a rotation matrix around the Y axis
    public static Matrix CreateRotationY(float rads);

    // Create a rotation matrix around the Z axis
    public static Matrix CreateRotationZ(float rads);

    // Create a scale matrix. Note scale matrices can only be set on MeshPrimitive and not any other primitive
    public static Matrix CreateScale(float scaleX, float scaleY, float scaleZ);

    // Create a scale matrix. Note scale matrices can only be set on MeshPrimitive and not any other primitive
    public static Matrix CreateScale(Vector v);

    // Create a scale matrix. Note scale matrices can only be set on MeshPrimitive and not any other primitive
    public static Matrix CreateScale(float scaleFactor);

    // Create a translation matrix
    public static Matrix CreateTranslation(System.Numerics.Vector3 vec);

    // Create a translation matrix
    public static Matrix CreateTranslation(Vector vec);

    // Create a translation matrix
    public static Matrix CreateTranslation(float x, float y, float z);

    // Multiply two matrices together
    public static Matrix operator *(Matrix a, Matrix b);
}

const Matrix = va.Matrix;

class Matrix {
    // Static properties
    static Identity;       // { m11, m12, ..., m44 }

    // Static factory methods
    static CreateTranslation(x, y, z);
    static CreateRotationX(rads);
    static CreateRotationY(rads);
    static CreateRotationZ(rads);
    static CreateScale(x, y?, z?);
    static CreateFromQuaternion(x, y, z, w);
    static Multiply(a, b);
}

typedef struct VAMatrix
{
    float m11;
    float m12;
    float m13;
    float m14;
    float m21;
    float m22;
    float m23;
    float m24;
    float m31;
    float m32;
    float m33;
    float m34;
    float m41;
    float m42;
    float m43;
    float m44;
} VAMatrix;

// Initializes a matrix with all 16 elements in column-major order (each group of 4 is one column)
VAMatrix vaMatrixCreate(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44);

// Returns the inverse of the matrix. Asserts if the determinant is zero (no inverse exists)
VAMatrix vaMatrixInverse(const VAMatrix* mat);

// Creates a translation matrix
VAMatrix vaMatrixCreateTranslation(float x, float y, float z);

// Creates a rotation matrix around the X axis. rads is the angle in radians
VAMatrix vaMatrixCreateRotationX(float rads);

// Creates a rotation matrix around the Y axis. rads is the angle in radians
VAMatrix vaMatrixCreateRotationY(float rads);

// Creates a rotation matrix around the Z axis. rads is the angle in radians
VAMatrix vaMatrixCreateRotationZ(float rads);

// Creates a scale matrix. Note scale matrices can only be set on mesh primitives and not any other primitive
VAMatrix vaMatrixCreateScale(float scaleX, float scaleY, float scaleZ);

// Multiplies two matrices together
VAMatrix vaMatrixMultiply(const VAMatrix* a, const VAMatrix* b);

// Returns true if all elements of a are exactly equal to those in b
bool vaMatrixIsEqual(const VAMatrix* a, const VAMatrix* b);

public struct Vector : IPosition
{
    // Gets or sets a component by index (0=X, 1=Y, 2=Z)
    public float this[int index];

    // The length of this vector
    public float Magnitude;

    // Returns a normalized copy of this vector
    public Vector Normalized;

    // The X component
    public float X;

    // The Y component
    public float Y;

    // The Z component
    public float Z;

    // Creates a vector with all components set to v
    public Vector(float v);

    // Creates a vector with the specified components
    public Vector(float x, float y, float z);

    // Creates a vector from a Vector3
    public Vector(System.Numerics.Vector3 v);

    public override bool Equals(object obj);

    public override int GetHashCode();

    // IPosition implementation, returns itself
    public Vector GetPosition();

    // Returns true if any component of this vector is greater than the corresponding component in the other vector
    public bool GreaterAny(Vector v);

    // Returns true if any component of this vector is greater than or equal to the corresponding component in the other vector
    public bool GreaterEqualAny(Vector v);

    // Returns true if all components of this vector equal those of other
    public bool IsEqual(Vector other);

    // Returns true if any component of this vector is less than the corresponding component in the other vector
    public bool LessAny(Vector v);

    // Returns true if any component of this vector is less than or equal to the corresponding component in the other vector
    public bool LessEqualAny(Vector v);

    // Normalizes this vector in place
    public void Normalize();

    // Converts to Vector3
    public System.Numerics.Vector3 ToNumerics();

    public override string ToString();

    // Returns true if a does not equal b
    public static bool operator !=(Vector a, Vector b);

    // Returns true if all components of a are greater than or equal to those of b
    public static bool operator >=(Vector a, Vector b);

    // A vector with all components set to MaxValue
    public static Vector MAX = new(float.MaxValue);

    // A vector with all components set to MinValue
    public static Vector MIN = new(float.MinValue);

    // A vector with all components set to one
    public static Vector One = new(1);

    // Returns true if all components of a are less than or equal to those of b
    public static bool operator <=(Vector a, Vector b);

    // Returns true if a equals b
    public static bool operator ==(Vector a, Vector b);

    // A unit vector pointing upward (0, 1, 0)
    public static Vector Up = new(0, 1, 0);

    // A vector with all components set to zero
    public static Vector Zero = new(0);

    // Returns true if all components of a are greater than those of b
    public static bool operator >(Vector a, Vector b);

    // Returns the cross product of a and b
    public static Vector Cross(Vector a, Vector b);

    // Returns the dot product of a and b
    public static float Dot(Vector a, Vector b);

    // Creates a direction vector from pitch and yaw angles in radians
    public static Vector FromPitchYaw(float pitch, float yaw);

    // Returns the component-wise maximum of a and b
    public static Vector GetMax(Vector a, Vector b);

    // Returns the component-wise minimum of a and b
    public static Vector GetMin(Vector a, Vector b);

    // Interpolates from one vector to another
    public static Vector Lerp(Vector a, Vector b, float c);

    // Returns true if all components of a are less than those of b
    public static bool operator <(Vector a, Vector b);

    // Reflects direction about the normal
    public static Vector Reflect(Vector direction, Vector normal);

    // Transforms a normal vector by a matrix, ignoring translation
    public static Vector TransformNormal(Vector a, Matrix b);

    // Scales a by scalar b
    public static Vector operator *(float b, Vector a);

    // Scales a by scalar b
    public static Vector operator *(Vector a, float b);

    // Transforms a vector by a matrix, including translation
    public static Vector operator *(Vector a, Matrix b);

    // Returns the component-wise product of a and b
    public static Vector operator *(Vector a, Vector b);

    // Returns the component-wise sum of a and b
    public static Vector operator +(Vector a, Vector b);

    // Returns the negation of a
    public static Vector operator -(Vector a);

    // Returns the component-wise difference of a and b
    public static Vector operator -(Vector a, Vector b);

    // Divides scalar b by each component of a
    public static Vector operator /(float b, Vector a);

    // Divides a by scalar b
    public static Vector operator /(Vector a, float b);

    // Returns the component-wise quotient of a and b
    public static Vector operator /(Vector a, Vector b);
}

typedef struct VAVector
{
    float x;
    float y;
    float z;
} VAVector;

// Creates a vector with the specified components
VAVector vaVectorCreate(float x, float y, float z);

// Creates a vector with all components set to value
VAVector vaVectorCreateUniform(float value);

// Returns the length of v
float vaVectorMagnitude(VAVector v);

// Returns the component-wise sum of a and b
VAVector vaVectorAdd(VAVector a, VAVector b);

// Returns the component-wise difference of a and b
VAVector vaVectorSubtract(VAVector a, VAVector b);

// Scales a by scalar
VAVector vaVectorMultiplyScalar(VAVector a, float scalar);

// Divides a by scalar
VAVector vaVectorDivideScalar(VAVector a, float scalar);

// Returns true if all components of a are greater than or equal to those of b
bool vaVectorGreaterEqual(VAVector a, VAVector b);

// Returns true if all components of a are less than or equal to those of b
bool vaVectorLessEqual(VAVector a, VAVector b);

// Returns true if any component of a is less than the corresponding component of b
bool vaVectorLessAny(VAVector a, VAVector b);

// Returns true if any component of a is greater than the corresponding component of b
bool vaVectorGreaterAny(VAVector a, VAVector b);

// Returns true if all components of a equal those of b
bool vaVectorEqual(VAVector a, VAVector b);

// Returns the component-wise minimum of a and b
VAVector vaVectorMin(VAVector a, VAVector b);

// Returns the component-wise maximum of a and b
VAVector vaVectorMax(VAVector a, VAVector b);

// Gets a component by index (0=x, 1=y, 2=z)
float vaVectorGetComponent(VAVector v, int index);

// Returns the dot product of a and b
float vaVectorDot(VAVector a, VAVector b);

// Returns the cross product of a and b
VAVector vaVectorCross(VAVector a, VAVector b);

// Returns the negation of a
VAVector vaVectorNegate(VAVector a);

// Returns a normalized copy of v
VAVector vaVectorNormalize(VAVector v);

// Creates a direction vector from pitch and yaw angles in radians
VAVector vaVectorFromPitchYaw(float pitch, float yaw);

// Transforms a point by a matrix, including translation (w=1)
VAVector vaVectorMultiplyMatrix(VAVector a, const VAMatrix* b);

// Transforms a normal vector by a matrix, ignoring translation, and normalizes the result
VAVector vaVectorTransformNormal(VAVector a, const VAMatrix* b);

// Returns true if any component of vec is NaN or infinity
bool vaVectorIsNanOrInfinity(VAVector vec);

// Reflects direction about normal
VAVector vaVectorReflect(VAVector direction, VAVector normal);

public struct VisualisationData
{
    // The world-space normal of the ray bounce. Guaranteed to be normalised
    public Vector normal;

    // The world-space position of the ray bounce
    public Vector position;
}

interface VisualisationData {
    // Created via: va.VisualisationData_Create()

    // The world-space normal of the ray bounce. Guaranteed to be normalised
    get normal(); set normal(v);

    // The world-space position of the ray bounce
    get position(); set position(v);
}

typedef struct VAVisualisationData
{
    VAVector position;
    VAVector normal;
} VAVisualisationData;

public class World
{
    // Air absorption settings. Set to null to disable air absorption.
    public AirAbsorptionSettings AirAbsorption;

    // The average time (in milliseconds) spent in the analysing thread after the raytracing threads complete. This phase runs after raytracing completes and calculate reverb properties.
    // Use this to monitor raytracing performance and adjust ray counts if needed.
    public float AnalysisTime;

    // True while background raytracing threads are still running.
    // After setting PendingShutdown, continue calling Update until this is false, then call Dispose.
    public bool AreThreadsRunning;

    // The pitch of the camera in the debug window.
    public float CameraPitch;

    // The position of the camera in the debug window.
    public Vector CameraPosition;

    // The yaw of the camera in the debug window.
    public float CameraYaw;

    // Custom formulas for calculating EAX properties (diffusion, density, etc). Set to null to use default formulas.
    public CustomEAXFormulas CustomEAXFormulas;

    // Whether Emitters outside the world have 0 occlusion/permeation energy (true) or maximum energy (false).
    public bool EmittersOutsideTheWorldAreMuffled;

    // The epsilon value used for ray offsets, world bounds clamping and line-of-sight tests. Defaults to 0.01f
    public float Epsilon;

    // The field of view (in radians) of the camera in the debug window.
    public float FieldOfView;

    // List of grouped EAX reverb properties for all emitters. Contains parameters compatible with EAX reverb effects.
    public List<EAXReverb> GroupedEAX = [];

    // Inverse speed of sound in seconds per meter. Defaults to 1.0f / 343.0f. Affects reverb calculation
    public float InverseSpeedOfSound;

    // A custom logging callback. Defaults to WriteLine()
    public Action<string> LogCallback;

    // Whether to log memory allocation warnings
    public bool LogMemoryAllocationWarnings = true;

    // The average time (in milliseconds) spent by Update on the main thread. This includes time spent handling previous raytracing results, applying new settings,
    // processing primitive updates and submitting work to background threads.
    // Use this metric to monitor main thread performance impact.
    public float MainThreadTime;

    // The maximum bounds of the world (Position + Size)
    public Vector MaxBounds;

    // The maximum amount of threads that can run in parallel for this world
    public int MaximumConcurrencyLevel;

    // The maximum number of grouped EAX reverb properties created for all emitters. Higher values increase accuracy but are more expensive to run.
    public int MaximumGroupedEAXCount = 2;

    // Gets meters per world unit. Affects air absorption and reverb calculation.
    public float MetersPerUnit = 1;

    // Callback that is invoked when keys are pressed
    public Action<KeyEvent> OnKeyEvent;

    // This is invoked after EAX reverb results are updated, and before emitter.OnRaytracingComplete callbacks are invoked. This gives you a chance to update your EAX effects, so they can be applied to an emitter in it's OnRaytracingComplete callback.
    public Action OnReverbUpdated = null;

    // When set to true, Update will stop submitting work to background threads.
    // When ThreadsRunning becomes false, it is safe to call Dispose.
    public bool PendingShutdown = false;

    // The minimum bounds of the world.
    // Emitters outside the world will not be raytraced, and Primitives that are fully outside these bounds will not affect raytracing.
    public Vector Position;

    // The average time (in milliseconds) spent in the preparation thread before the raytracing threads begin. This phase updates the BVH (Bounding Volume Hierarchy) acceleration structure with new, modified,
    // and removed primitives. Higher values are a result of complex scene changes.
    public float PreparationTime;

    // The percentage of rays that were reused from previous frames, rather than being cast this frame. Higher values indicate better performance.
    public float RayCachePercent;

    // The number of rays cast this frame.
    public int RaysCastThisFrame = 0;

    // The average time (in milliseconds) spent in the raytracing threads. This is the real-world elapsed time it takes for raytracing to complete, not the sum of all thread times.
    // This value is automatically adjusted based on how many threads perform raytracing.
    // Use this to monitor raytracing performance and adjust ray counts if needed.
    public float RaytracingTime;

    // High-frequency reference (Hz) for air absorption, reverb, and material scattering
    public float ReferenceFrequencyHF = 4000;

    // Low-frequency reference (Hz) for air absorption, reverb, and material scattering
    public float ReferenceFrequencyLF = 300;

    // Whether to render the raytracing scene in a separate window. Only one world can have rendering enabled
    public bool RenderingEnabled;

    // Returns true when raytracing has run at least once, and it is safe to access reverb objects
    public bool ReverbCalculated;

    // The size of the world.
    // Emitters outside the world will not be raytraced, and Primitives that are fully outside these bounds will be ignored
    public Vector Size;

    // The total number of rays that could potentially be cast each frame, including trail rays, reverb rays, occlusion rays, permeation rays and visualisation rays
    public int TotalPossibleRayCount;

    // The number of work items to split trails across for load balancing. A higher workItemCount helps evenly distribute work across all threads.
    public int WorkItemCount = 128;

    // Whether the entire world is considered indoors or outdoors. When false, reverb rays stop checking for line-of-sight after hitting the world edge. Defaults to false.
    public bool WorldIsIndoors;

    // Create a new world
    public World();

    // Add an Emitter to the world.
    // This method is thread-safe and will not affect the current raytracing threads.
    public Emitter AddEmitter(Emitter emitter);

    // Add a new material to this world
    public void AddMaterial(MaterialType type, MaterialProperties properties, Color color);

    // Adds a 3D object to the raytracing scene.
    // This method is thread-safe and will not affect the current raytracing threads.
    // Primitives completely outside the world bounds will be ignored during raytracing.
    public void AddPrimitive(Primitive primitive);

    // Waits for background thread to complete, then disposes everything.
    // After calling this method, this world cannot be reused.
    public void Dispose();

    // Get properties for a specific material.
    public MaterialProperties GetMaterial(MaterialType type);

    // Gets the debug rendering color for a specific material type
    public Color GetMaterialColor(MaterialType type);

    // Returns true if a material exists
    public bool HasMaterial(MaterialType type);

    // Returns true if a key is pressed in the debug window.
    public bool IsKeyPressed(Silk.NET.Input.Key keyCode);

    // Remove an Emitter from the world.
    // This method is thread-safe and will not affect the current raytracing threads.
    // This emitter's OnRaytracingComplete callback will not be invoked.
    public void RemoveEmitter(Emitter emitter);

    // Removes a 3D object from the raytracing scene.
    // This method is thread-safe and will not affect the current raytracing threads.
    public void RemovePrimitive(Primitive primitive);

    // Sets the debug rendering color for a specific material type
    public void SetMaterialColor(MaterialType type, Color color);

    // Updates the raytracing simulation. Call this method regularly to process raytracing results and submit new work.
    // 
    // This method does nothing if background raytracing threads are still running. When threads are idle, it performs the following operations:
    // - Handles the last raytracing results, updating reverb objects and invoking OnRaytracedByAnotherEmitter callbacks
    // - Applies new settings and resizes memory buffers if needed (e.g., if ray counts were changed)
    // - Processes new, modified, and removed primitives
    // - Starts raytracing again on background threads
    // 
    // This method must be called from the main thread. The actual raytracing runs on background threads.
    // Calling this more frequently (multiple times per frame) is safe and can reduce latency for emitter updates.
    public void Update();

    // Blocks the calling thread until all background raytracing threads complete, then handles the results (updates reverb objects and invokes OnRaytracingComplete and OnRaytracedByAnotherEmitter callbacks for each emitter).
    public void Wait();
}

interface World {
    // Created via: va.World_Create()

    // Air absorption settings. Set to null to disable air absorption
    get airAbsorption(); set airAbsorption(v);

    // Whether emitters outside the world have 0 occlusion/permeation energy (true) or maximum energy (false)
    get emittersOutsideTheWorldAreMuffled(); set emittersOutsideTheWorldAreMuffled(v);

    // Epsilon value for ray offsets, world bounds clamping and line-of-sight tests. Defaults to 0.01
    get epsilon(); set epsilon(v);

    // Whether to expose trail data for rendering
    get exposeTrails(); set exposeTrails(v);

    // Inverse speed of sound in seconds per meter. Defaults to 1/343. Affects reverb calculation
    get inverseSpeedOfSound(); set inverseSpeedOfSound(v);

    // Whether to log memory allocation warnings
    get logMemoryAllocationWarnings(); set logMemoryAllocationWarnings(v);

    // Maximum bounds of the world (position + size)
    get maxBounds(); set maxBounds(v);

    // Maximum number of threads that can run in parallel for this world
    get maximumConcurrencyLevel(); set maximumConcurrencyLevel(v);

    // Maximum number of grouped EAX reverb properties. Higher values increase accuracy but cost more
    get maximumGroupedEAXCount(); set maximumGroupedEAXCount(v);

    // Meters per world unit. Affects air absorption and reverb calculation
    get metersPerUnit(); set metersPerUnit(v);

    // When set to true, update() stops submitting work to background threads. Poll areThreadsRunning until false, then call destroy()
    get pendingShutdown(); set pendingShutdown(v);

    // Minimum bounds of the world. Emitters and primitives outside these bounds are ignored
    get position(); set position(v);

    // High-frequency reference in Hz for air absorption, reverb, and material scattering
    get referenceFrequencyHF(); set referenceFrequencyHF(v);

    // Low-frequency reference in Hz for air absorption, reverb, and material scattering
    get referenceFrequencyLF(); set referenceFrequencyLF(v);

    // Size of the world. Emitters and primitives fully outside these bounds are ignored
    get size(); set size(v);

    // Number of work items to split trails across for load balancing
    get workItemCount(); set workItemCount(v);

    // Whether the entire world is considered indoors or outdoors. Affects reverb ray behaviour at world bounds
    get worldIsIndoors(); set worldIsIndoors(v);

    // Average time (in milliseconds) spent in the analysis thread calculating reverb properties
    get analysisTime();

    // True while background raytracing threads are still running. Poll this after setting pendingShutdown, then call destroy() when false
    get areThreadsRunning();

    // Averaged EAX reverb objects for all emitters with affectsGroupedEAX set to true
    get groupedEAX();

    // Average time (in milliseconds) spent by update() on the main thread
    get mainThreadTime();

    // Average time (in milliseconds) spent in the preparation thread updating the BVH
    get preparationTime();

    // Average real-world elapsed time (in milliseconds) for raytracing threads to complete
    get raytracingTime();

    // True when raytracing has run at least once and reverb objects are safe to access
    get reverbCalculated();

    // Invoked after EAX reverb results are updated, before onRaytracingComplete callbacks
    set onReverbUpdated(fn);

    // Adds an emitter to the raytracing scene
    addEmitter(e);

    // Adds or replaces a material in this world
    addMaterial(materialType, properties);

    // Adds a 3D primitive to the raytracing scene
    addPrimitive(p);

    // Returns the number of background threads used by this world
    getBackgroundThreadCount();

    // Returns the acoustic properties for a specific material
    getMaterial(materialType);

    // Returns the total number of threads used by this world
    getThreadCount();

    // Returns true if a material exists in this world
    hasMaterial(materialType);

    // Removes an emitter from the raytracing scene
    removeEmitter(e);

    // Removes a 3D primitive from the raytracing scene
    removePrimitive(p);

    // Updates the raytracing simulation. Call regularly to process results and submit new work
    update();

    // Blocks until all background raytracing threads complete and handles the results
    wait();
}

// Creates a new world
VAWorld* vaWorldCreate();

// Waits for background thread to complete, then frees all resources. After calling this method, this world cannot be reused.
void vaWorldFree(VAWorld* world);

void vaWorldUpdate(VAWorld* world);

// Blocks the calling thread until all background raytracing threads complete, then handles the results (updates reverb objects and invokes OnRaytracingComplete and OnRaytracedByAnotherEmitter callbacks for each emitter).
void vaWorldWait(VAWorld* world);

void vaWorldSetPendingShutdown(VAWorld* world);

bool vaWorldGetThreadsRunning(VAWorld* world);

// Number of rays cast this frame.
int vaWorldGetRaysCastThisFrame(const VAWorld* world);

// List of grouped EAX reverb properties for all emitters. Contains parameters compatible with EAX reverb effects.
const VAEAXReverb** vaWorldGetGroupedEAX(const VAWorld* world);

// Current number of grouped EAX effects (may be less than the maximum).
int vaWorldGetGroupedEAXCount(const VAWorld* world);

// Primitive management — use the macros below, not these directly
void vaWorldAddPrimitive_(VAWorld* world, void* primitive);

void vaWorldRemovePrimitive_(VAWorld* world, void* primitive);

// The minimum bounds of the world. Emitters outside the world will not be raytraced, and primitives fully outside these bounds will not affect raytracing.
VAVector vaWorldGetPosition(const VAWorld* world);

// Set the world position. Returns VA_SUCCESS, or VA_INVALID_VALUE if the new value is NaN or Infinity.
VAResult vaWorldSetPosition(VAWorld* world, VAVector position);

// The size of the world. Emitters outside the world will not be raytraced, and primitives fully outside these bounds will be ignored.
VAVector vaWorldGetSize(const VAWorld* world);

// Set the world size. Returns VA_SUCCESS, or VA_INVALID_VALUE if the new value is NaN, Infinity or less than or equal to (0, 0, 0).
VAResult vaWorldSetSize(VAWorld* world, VAVector size);

// The maximum bounds of the world (Position + Size).
VAVector vaWorldGetMaxBounds(const VAWorld* world);

// Set the max bounds of the world. Returns VA_SUCCESS, or VA_INVALID_VALUE if the new value is NaN, Infinity or less than or equal to (0, 0, 0).
VAResult vaWorldSetMaxBounds(VAWorld* world, VAVector maxBounds);

// Number of emitters in this world
int vaWorldGetEmitterCount(const VAWorld* world);

// Total number of rays that could potentially be cast each frame across all emitters.
int vaWorldGetTotalPossibleRayCount(const VAWorld* world);

// Percentage of rays reused from previous frames rather than cast this frame. Higher values indicate better performance.
float vaWorldGetRayCachePercent(const VAWorld* world);

// The maximum number of grouped EAX reverb properties created for all emitters. Higher values increase accuracy but are more expensive to run. Must be >= 2. Returns VA_SUCCESS, or VA_OUT_OF_RANGE if value is less than 2.
VAResult vaWorldSetMaximumGroupedEAXCount(VAWorld* world, int value);

// The number of work items to split trails across for load balancing. A higher value helps evenly distribute work across all threads. Must be >= 1. Returns VA_SUCCESS, or VA_OUT_OF_RANGE if value is less than 1.
VAResult vaWorldSetWorkItemCount(VAWorld* world, int value);

// The maximum amount of threads that can run in parallel for this world. Must be >= 1. Returns VA_SUCCESS, or VA_OUT_OF_RANGE if value is less than 1.
VAResult vaWorldSetMaximumConcurrencyLevel(VAWorld* world, int value);

// Gets meters per world unit. Affects air absorption and reverb calculation. Returns VA_SUCCESS, VA_INVALID_VALUE if NaN or Infinity, or VA_OUT_OF_RANGE if <= 0.
VAResult vaWorldSetMetersPerUnit(VAWorld* world, float value);

// Inverse speed of sound in seconds per meter. Defaults to 1.0f / 343.0f. Affects reverb calculation. Returns VA_SUCCESS, VA_INVALID_VALUE if NaN or Infinity, or VA_OUT_OF_RANGE if <= 0.
VAResult vaWorldSetInverseSpeedOfSound(VAWorld* world, float value);

// Low-frequency reference (Hz) for air absorption, reverb, and material scattering. Returns VA_SUCCESS, VA_INVALID_VALUE if NaN or Infinity, or VA_OUT_OF_RANGE if <= 0.
VAResult vaWorldSetReferenceFrequencyLF(VAWorld* world, float value);

// High-frequency reference (Hz) for air absorption, reverb, and material scattering. Returns VA_SUCCESS, VA_INVALID_VALUE if NaN or Infinity, or VA_OUT_OF_RANGE if <= 0.
VAResult vaWorldSetReferenceFrequencyHF(VAWorld* world, float value);

// Air absorption settings
void* vaWorldGetAirAbsorption(VAWorld* world);

// Air absorption settings. Pass NULL to disable air absorption. Returns VA_SUCCESS, or VA_INVALID_VALUE if validation fails.
VAResult vaWorldSetAirAbsorption(VAWorld* world, VAAirAbsorptionSettings* value);

// Relative humidity as a percentage (0–1).
void vaWorldSetAirAbsorptionHumidity(VAWorld* world, float value);

// Air temperature in degrees Celsius.
void vaWorldSetAirAbsorptionTemperature(VAWorld* world, float value);

// Atmospheric pressure in Pascals.
void vaWorldSetAirAbsorptionPressure(VAWorld* world, float value);

// Custom LF air absorption formula. Takes distance in meters, returns energy loss as a percentage. NULL to use default.
void vaWorldSetAirAbsorptionCustomFormulaLF(VAWorld* world, VAAirAbsorptionCustomFormula value);

// Custom HF air absorption formula. Takes distance in meters, returns energy loss as a percentage. NULL to use default.
void vaWorldSetAirAbsorptionCustomFormulaHF(VAWorld* world, VAAirAbsorptionCustomFormula value);

// Custom formulas for calculating EAX properties (diffusion, density, etc). Pass NULL to use default formulas.
void vaWorldSetCustomEAXFormulas(VAWorld* world, VACustomEAXFormulas* formulas);

// Whether emitters outside the world have 0 occlusion/permeation energy (true) or maximum energy (false).
void vaWorldSetEmittersOutsideTheWorldAreMuffled(VAWorld* world, bool value);

// The maximum number of grouped EAX reverb properties created for all emitters.
int vaWorldGetMaximumGroupedEAXCount(const VAWorld* world);

// The number of work items to split trails across for load balancing.
int vaWorldGetWorkItemCount(const VAWorld* world);

// The maximum amount of threads that can run in parallel for this world.
int vaWorldGetMaximumConcurrencyLevel(const VAWorld* world);

// Whether the system is running in single-threaded mode.
bool vaWorldGetSingleThreaded(const VAWorld* world);

// Whether the system is running in single-threaded mode.
void vaWorldSetSingleThreaded(VAWorld* world, bool value);

// Gets meters per world unit. Affects air absorption and reverb calculation.
float vaWorldGetMetersPerUnit(const VAWorld* world);

// Inverse speed of sound in seconds per meter. Defaults to 1.0f / 343.0f. Affects reverb calculation.
float vaWorldGetInverseSpeedOfSound(const VAWorld* world);

// Low-frequency reference (Hz) for air absorption, reverb, and material scattering.
float vaWorldGetReferenceFrequencyLF(const VAWorld* world);

// High-frequency reference (Hz) for air absorption, reverb, and material scattering.
float vaWorldGetReferenceFrequencyHF(const VAWorld* world);

// Whether emitters outside the world have 0 occlusion/permeation energy (true) or maximum energy (false).
bool vaWorldGetEmittersOutsideTheWorldAreMuffled(const VAWorld* world);

// TODO
float vaWorldGetEpsilon(const VAWorld* world);

// TODO
void vaWorldSetEpsilon(VAWorld* world, float value);

// Add a new material to this world.
void vaWorldCreateMaterial(VAWorld* world, int materialId);

// Gets the percentage of low-frequency energy that is lost when a ray bounces off this material, in the range 0.0 to 1.0
float vaWorldGetMaterialAbsorptionLF(const VAWorld* world, int materialId);

// Gets the percentage of high-frequency energy that is lost when a ray bounces off this material, in the range 0.0 to 1.0
float vaWorldGetMaterialAbsorptionHF(const VAWorld* world, int materialId);

// Gets the scattering strength when a ray bounces off this material, in the range 0.0 to 1.0 (0.0 = no scattering, 1.0 skews the ray reflection direction by up to 90 degrees)
float vaWorldGetMaterialScattering(const VAWorld* world, int materialId);

// Gets how much low-frequency energy is lost (in dB/meter) when a permeation ray passes through this primitive, in the range 0.0 or greater
float vaWorldGetMaterialTransmissionLF(const VAWorld* world, int materialId);

// Gets how much high-frequency energy is lost (in dB/meter) when a permeation ray passes through this primitive, in the range 0.0 or greater
float vaWorldGetMaterialTransmissionHF(const VAWorld* world, int materialId);

// Gets the percentage of low-frequency energy that is lost when a permeation ray passes through a flat VAPlanePrimitive, VADiskPrimitive, VATrianglePrimitive, or non-watertight VAMeshPrimitive, in the range 0.0 to 1.0
float vaWorldGetMaterialPlaneTransmissionLF(const VAWorld* world, int materialId);

// Gets the percentage of high-frequency energy that is lost when a permeation ray passes through a flat VAPlanePrimitive, VADiskPrimitive, VATrianglePrimitive, or non-watertight VAMeshPrimitive, in the range 0.0 to 1.0
float vaWorldGetMaterialPlaneTransmissionHF(const VAWorld* world, int materialId);

// Updates the percentage of low-frequency energy that is lost when a ray bounces off this material. Must be in the range 0.0 to 1.0. Returns VA_SUCCESS, VA_INVALID_VALUE if NaN or Infinity, or VA_OUT_OF_RANGE if < 0.0 or > 1.0.
VAResult vaWorldSetMaterialAbsorptionLF(VAWorld* world, int materialId, float value);

// Updates the percentage of high-frequency energy that is lost when a ray bounces off this material. Must be in the range 0.0 to 1.0. Returns VA_SUCCESS, VA_INVALID_VALUE if NaN or Infinity, or VA_OUT_OF_RANGE if < 0.0 or > 1.0.
VAResult vaWorldSetMaterialAbsorptionHF(VAWorld* world, int materialId, float value);

// Updates the scattering strength (0.0 = no scattering, 1.0 skews the ray reflection direction by up to 90 degrees). Must be in the range 0.0 to 1.0. Returns VA_SUCCESS, VA_INVALID_VALUE if NaN or Infinity, or VA_OUT_OF_RANGE if < 0.0 or > 1.0.
VAResult vaWorldSetMaterialScattering(VAWorld* world, int materialId, float value);

// Updates how much low-frequency energy is lost (in dB/meter) when a permeation ray passes through this primitive. Must be 0.0 or greater. Returns VA_SUCCESS, VA_INVALID_VALUE if NaN or Infinity, or VA_OUT_OF_RANGE if < 0.0.
VAResult vaWorldSetMaterialTransmissionLF(VAWorld* world, int materialId, float value);

// Updates how much high-frequency energy is lost (in dB/meter) when a permeation ray passes through this primitive. Must be 0.0 or greater. Returns VA_SUCCESS, VA_INVALID_VALUE if NaN or Infinity, or VA_OUT_OF_RANGE if < 0.0.
VAResult vaWorldSetMaterialTransmissionHF(VAWorld* world, int materialId, float value);

// Updates the percentage of low-frequency energy that is lost when a permeation ray passes through a flat VAPlanePrimitive, VADiskPrimitive, VATrianglePrimitive, or non-watertight VAMeshPrimitive. Must be in the range 0.0 to 1.0. Returns VA_SUCCESS, VA_INVALID_VALUE if NaN or Infinity, or VA_OUT_OF_RANGE if < 0.0.
VAResult vaWorldSetMaterialPlaneTransmissionLF(VAWorld* world, int materialId, float value);

// Updates the percentage of high-frequency energy that is lost when a permeation ray passes through a flat VAPlanePrimitive, VADiskPrimitive, VATrianglePrimitive, or non-watertight VAMeshPrimitive. Must be in the range 0.0 to 1.0. Returns VA_SUCCESS, VA_INVALID_VALUE if NaN or Infinity, or VA_OUT_OF_RANGE if < 0.0.
VAResult vaWorldSetMaterialPlaneTransmissionHF(VAWorld* world, int materialId, float value);

// Average time (ms) spent by vaWorldUpdate() on the main thread
double vaWorldGetMainThreadTime(VAWorld* world);

// Average time (ms) spent in background raytracing threads
double vaWorldGetRaytracingTime(VAWorld* world);

// Average time (ms) spent in the preparation thread
double vaWorldGetPreparationTime(VAWorld* world);

// Average time (ms) spent in the analysis thread
double vaWorldGetAnalysisTime(VAWorld* world);

VAResult vaWorldAddEmitter(VAWorld* world, VAEmitter* emitter);

// Remove an emitter from the world. Thread-safe. This emitter's OnRaytracingComplete callback will not be invoked.
void vaWorldRemoveEmitter(VAWorld* world, VAEmitter* emitter);

// Returns true when raytracing has run at least once, and it is safe to access reverb objects.
bool vaWorldGetReverbCalculated(const VAWorld* world);

// Invoked after EAX reverb results are updated, and before emitter OnRaytracingComplete callbacks are invoked.
void vaWorldSetOnReverbUpdatedCallback(VAWorld* world, void (*callback)(void));

// A custom logging callback.
void vaWorldSetLogCallback(VAWorld* world, VALogCallback callback);

// Whether to log memory allocation warnings.
void vaWorldSetLogMemoryAllocationWarnings(VAWorld* world, bool value);

// Converts a world-space vector to a listener-relative pan direction given the listener's pitch and yaw angles.
VAVector vaWorldCalculateListenerRelativePan(VAVector worldVector, float listenerPitch, float listenerYaw);