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 = 0.2f,
            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 { initVA, MaterialType } from './vaudio-wrapper.js';

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

// Initialise the .NET runtime and wrap Web Assembly calls into JS objects with get/setters
const va = await initVA(dotnet, YOUR_THREAD_COUNT);

// 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 = 0.2;
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, 0.2f);
    
    vaEmitterSetOcclusionRayCount(listener, 512);
    vaEmitterSetOcclusionBounceCount(listener, 8);
    vaEmitterSetPermeationRayCount(listener, 128);
    vaEmitterSetPermeationBounceCount(listener, 3);
    
    vaEmitterSetAmbientOcclusionRayCount(listener, 512);
    vaEmitterSetAmbientOcclusionBounceCount(listener, 8);
    vaEmitterSetAmbientPermeationRayCount(listener, 128);
    vaEmitterSetAmbientPermeationBounceCount(listener, 3);

    VAResult result = vaWorldAddEmitter(world, listener);
    assert(result == VA_SUCCESS);
    
    // 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);
    
    result = vaWorldAddEmitter(world, source);
    assert(result == VA_SUCCESS);    
    
    // 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;
}

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

    // Radius of the capsule
    float radius;

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

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

    get length(); set length(v);

    get material(); set material(v);

    get radius(); set radius(v);

    get transform(); set transform(v);
}

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

// Free all resources owned by this primitive
VAResult vaCapsulePrimitiveDestroy(VACapsulePrimitive* capsule);

VAResult vaCapsulePrimitiveSetMaterial(VACapsulePrimitive* capsule, VAMaterialType material);

// Get the material for this capsule
VAMaterialType vaCapsulePrimitiveGetMaterial(const VACapsulePrimitive* capsule);

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

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

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

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

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

// Get the world-space transform of this capsule
const VAMatrix* vaCapsulePrimitiveGetTransform(const VACapsulePrimitive* capsule);

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

    // Radius of the cone base
    float radius;

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

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

    get height(); set height(v);

    get material(); set material(v);

    get radius(); set radius(v);

    get transform(); set transform(v);
}

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

// Free all resources owned by this primitive
VAResult vaConePrimitiveDestroy(VAConePrimitive* cone);

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

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

// World-space 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);

// Set the world-space 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);

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

    // Radius of the cylinder
    float radius;

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

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

    get length(); set length(v);

    get material(); set material(v);

    get radius(); set radius(v);

    get transform(); set transform(v);
}

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

// Free all resources owned by this primitive
VAResult vaCylinderPrimitiveDestroy(VACylinderPrimitive* cylinder);

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

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

// World-space 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);

// Set the world-space 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);

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

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

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

    get material(); set material(v);

    get radius(); set radius(v);

    get transform(); set transform(v);
}

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

// Free all resources owned by this primitive
VAResult vaDiskPrimitiveDestroy(VADiskPrimitive* disk);

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

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

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

// Set the world-space 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);

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

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

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

    get material(); set material(v);

    get radius(); set radius(v);

    get transform(); set transform(v);
}

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

// Free all resources owned by this primitive
VAResult vaHalfSpherePrimitiveDestroy(VAHalfSpherePrimitive* halfSphere);

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

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

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

// Set the world-space 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);

class MeshPrimitive : Primitive
{
    // If this is a watertight mesh, permeation rays will lose energy based on how far the ray travels through this mesh. If not, set this field to false and permeation rays will lose a flat percentage of energy when they touch this mesh (controlled by PlaneTransmissionLF and PlaneTransmissionHF).
    bool Supports3DPermeation;

    // Can contain scale, rotation and translation components
    Matrix transform;

    // Create a mesh primitive from a list of vertices
    MeshPrimitive(MaterialType material, List<Vector> vertices, Vector minBounds, Vector maxBounds, Matrix transform);

    // Create a mesh primitive that shares geometry with a Mesh. The BVH is built once in the Mesh and reused by every instance.
    MeshPrimitive(MaterialType material, Mesh mesh, Matrix transform);

    // Create a mesh primitive from an unmanaged array of vertices
    MeshPrimitive(MaterialType material, Vector* vertices, int verticesCount, Vector minBounds, Vector maxBounds, Matrix transform);

    // Create a mesh primitive from an array of vertices
    MeshPrimitive(MaterialType material, Vector[] vertices, Vector minBounds, Vector maxBounds, Matrix transform);

    // Dispose the OpenGL vertex buffer (dev build only)
    void DisposeBuffer();
}

interface MeshPrimitive
{
    // Created via: va.MeshPrimitive_Create()
    // Also: va.MeshPrimitive_CreateFromMesh(material, mesh, transform)

    get material(); set material(v);

    get supports3DPermeation(); set supports3DPermeation(v);

    get transform(); set transform(v);
}

VAMeshPrimitive* vaMeshPrimitiveCreate(VAMaterialType material, const VAVector* vertices, int vertexCount, VAVector minBounds, VAVector maxBounds, const VAMatrix* transform);

// Creates a new MeshPrimitive that shares geometry from a VAMesh
VAMeshPrimitive* vaMeshPrimitiveCreateFromMesh(VAMaterialType material, VAMesh* mesh, const VAMatrix* transform);

// Free all resources owned by this primitive
VAResult vaMeshPrimitiveDestroy(VAMeshPrimitive* primitive);

// World-space transform matrix for this mesh
const VAMatrix* vaMeshPrimitiveGetTransform(const VAMeshPrimitive* primitive);

// Set the world-space transform matrix; updates all triangle bounds
void vaMeshPrimitiveSetTransform(VAMeshPrimitive* primitive, const VAMatrix* transform);

// Material assigned to this primitive
VAMaterialType vaMeshPrimitiveGetMaterial(const VAMeshPrimitive* cylinder);

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

// Whether sound can permeate through this mesh. Set to true for watertight meshes
bool vaMeshPrimitiveGetSupports3DPermeation(const VAMeshPrimitive* primitive);

// Whether sound can permeate through this mesh. Set to true for watertight meshes
void vaMeshPrimitiveSetSupports3DPermeation(VAMeshPrimitive* primitive, bool supports3DPermeation);

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

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

    // Width of the plane
    float width;
}

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

    get height(); set height(v);

    get material(); set material(v);

    get transform(); set transform(v);

    get width(); set width(v);
}

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

// Free all resources owned by this primitive
VAResult vaPlanePrimitiveDestroy(VAPlanePrimitive* plane);

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

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

// World-space 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);

// Set the world-space 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);

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

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

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

    get material(); set material(v);

    get size(); set size(v);

    get transform(); set transform(v);
}

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

// Free all resources owned by this primitive
VAResult vaPrismPrimitiveDestroy(VAPrismPrimitive* prism);

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

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

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

// Set the world-space 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);

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

    // Length of the rectangular base
    float length;

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

    // Width of the rectangular base
    float width;
}

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

    get height(); set height(v);

    get length(); set length(v);

    get material(); set material(v);

    get transform(); set transform(v);

    get width(); set width(v);
}

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

// Free all resources owned by this primitive
VAResult vaRectangularConePrimitiveDestroy(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-space 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);

// Set the world-space 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);

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

    // Radius of the sphere
    float radius;
}

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

    get center(); set center(v);

    get material(); set material(v);

    get radius(); set radius(v);
}

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

// Free all resources owned by this primitive
VAResult vaSpherePrimitiveDestroy(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);

// Free all resources owned by this primitive
VAResult vaTrianglePrimitiveDestroy(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);

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

    // The radius of the triangular base
    float radius;

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

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

    get height(); set height(v);

    get material(); set material(v);

    get radius(); set radius(v);

    get transform(); set transform(v);
}

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

// Free all resources owned by this primitive
VAResult vaTriangularConePrimitiveDestroy(VATriangularConePrimitive* cone);

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

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

// World-space 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);

// Set the world-space 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);

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

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

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

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

    get length(); set length(v);

    get material(); set material(v);

    get radius(); set radius(v);

    get transform(); set transform(v);
}

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

// Free all resources owned by this primitive
VAResult vaTriangularPrismPrimitiveDestroy(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-space 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);

// Set the world-space 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);

class VoxelPrimitive : Primitive
{
    // Voxel data
    readonly MaterialType[,,] data;

    // Helper overload for accessing and editing voxel data
    MaterialType this[int x, int y, int z];

    // Scale of the voxels
    float scale;

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

    // Create a new voxel primitive with the specified grid size
    VoxelPrimitive(int width, int height, int depth);

    // Call this after editing voxel data
    void SetDataDirty();
}

interface VoxelPrimitive
{
    // Created via: va.VoxelPrimitive_Create()

    get material(); set material(v);

    get scale(); set scale(v);

    get transform(); set transform(v);

    get depth();

    get height();

    get width();

    getData();

    getVoxel(x, y, z);

    setData(data);

    setVoxel(x, y, z, value);
}

// Creates a new VoxelPrimitive with the specified grid size. All voxels default to VAMaterialAir
VAVoxelPrimitive* vaVoxelPrimitiveCreate(int width, int height, int depth);

// Free all resources owned by this primitive
VAResult vaVoxelPrimitiveDestroy(VAVoxelPrimitive* voxel);

// Scale of the voxels
float vaVoxelPrimitiveGetScale(VAVoxelPrimitive* voxel);

// Scale of the voxels
void vaVoxelPrimitiveSetScale(VAVoxelPrimitive* voxel, float scale);

// Must only contain rotation and translation components, not scale
const VAMatrix* vaVoxelPrimitiveGetTransform(const VAVoxelPrimitive* voxel);

// Must only contain rotation and translation components, not scale
void vaVoxelPrimitiveSetTransform(VAVoxelPrimitive* voxel, const VAMatrix* transform);

// Grid dimensions, set at creation time
void vaVoxelPrimitiveGetSize(const VAVoxelPrimitive* voxel, int* width, int* height, int* depth);

// Material of the voxel at the given grid cell
VAMaterialType vaVoxelPrimitiveGetVoxel(const VAVoxelPrimitive* voxel, int x, int y, int z);

// Set the material of the voxel at the given grid cell. Call vaVoxelPrimitiveSetDataDirty after editing
void vaVoxelPrimitiveSetVoxel(VAVoxelPrimitive* voxel, int x, int y, int z, VAMaterialType material);

// Call this after editing voxel data
void vaVoxelPrimitiveSetDataDirty(VAVoxelPrimitive* voxel);

// Material assigned to this primitive
VAMaterialType vaVoxelPrimitiveGetMaterial(const VAVoxelPrimitive* voxel);

// Material assigned to this primitive. Must not be VAMaterialAir
void vaVoxelPrimitiveSetMaterial(VAVoxelPrimitive* voxel, VAMaterialType material);

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

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

    // Calculates the low and high frequency gain values relative to a reference energy level
    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
    virtual float CalculateLateReverbDelay();

    // Calculates the gain for early reflections and late reverb by splitting the echogram at a transition point
    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
    virtual float CalculateReflectionsDelay(float energyThreshold);

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

    // Initialises the formula calculator with echogram data from a processed reverb result
    virtual void Initialise(ProcessedReverb processed, float totalReturnedEnergyLF, float totalReturnedEnergyHF, 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 totalReturnedEnergyLF;
    float totalReturnedEnergyHF;
    float totalReturnedEnergyAverage;
    float totalReturnedEnergy;
    float* echogramLF;
    float* echogramHF;
    float* echogramAverage;
    int echogramLength;

    float maxEnergy;

    VAWorld* world;
};

VACustomEAXFormulas* vaCustomEAXFormulasCreate(void);

// Free all resources owned by these formulas. Returns VA_ERROR_IN_USE if the formulas are still assigned to a world
VAResult vaCustomEAXFormulasDestroy(VACustomEAXFormulas* formulas);

class EAXConstants
{
    const float AIR_ABSORPTION_GAIN_HF_MAX = 1.0f;

    const float AIR_ABSORPTION_GAIN_HF_MIN = 0.892f;

    const int DECAY_HF_LIMIT_MAX = 1;

    const int DECAY_HF_LIMIT_MIN = 0;

    const float DECAY_HF_RATIO_MAX = 2.0f;

    const float DECAY_HF_RATIO_MIN = 0.1f;

    const float DECAY_LF_RATIO_MAX = 2.0f;

    const float DECAY_LF_RATIO_MIN = 0.1f;

    const float DECAY_TIME_MAX = 20.0f;

    const float DECAY_TIME_MIN = 0.1f;

    const float DENSITY_MAX = 1.0f;

    const float DENSITY_MIN = 0.0f;

    const float DIFFUSION_MAX = 1.0f;

    const float DIFFUSION_MIN = 0.0f;

    const float ECHO_DEPTH_MAX = 1.0f;

    const float ECHO_DEPTH_MIN = 0.0f;

    const float ECHO_TIME_MAX = 0.25f;

    const float ECHO_TIME_MIN = 0.075f;

    const float GAIN_HF_MAX = 1.0f;

    const float GAIN_HF_MIN = 0.0f;

    const float GAIN_LF_MAX = 1.0f;

    const float GAIN_LF_MIN = 0.0f;

    const float GAIN_MAX = 1.0f;

    const float GAIN_MIN = 0.0f;

    const float HF_REFERENCE_MAX = 20000f;

    const float HF_REFERENCE_MIN = 1000f;

    const float LATE_REVERB_DELAY_MAX = 0.1f;

    const float LATE_REVERB_DELAY_MIN = 0.0f;

    const float LATE_REVERB_GAIN_MAX = 10.0f;

    const float LATE_REVERB_GAIN_MIN = 0.0f;

    const float LF_REFERENCE_MAX = 1000f;

    const float LF_REFERENCE_MIN = 20f;

    const float MODULATION_DEPTH_MAX = 1.0f;

    const float MODULATION_DEPTH_MIN = 0.0f;

    const float MODULATION_TIME_MAX = 4.0f;

    const float MODULATION_TIME_MIN = 0.04f;

    const float REFLECTIONS_DELAY_MAX = 0.3f;

    const float REFLECTIONS_DELAY_MIN = 0.0f;

    const float REFLECTIONS_GAIN_MAX = 3.16f;

    const float REFLECTIONS_GAIN_MIN = 0.0f;

    const float ROOM_ROLLOFF_FACTOR_MAX = 10.0f;

    const float ROOM_ROLLOFF_FACTOR_MIN = 0.0f;

    static Vector LATE_REVERB_PAN_MAX = new(1);

    static Vector LATE_REVERB_PAN_MIN = new(-1);

    static Vector REFLECTIONS_PAN_MAX = new(1);

    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();
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    override bool Equals(object obj);

    override int GetHashCode();

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

interface EAXReverb
{

    get airAbsorptionGainHF();

    get decayHFLimit();

    get decayHFRatio();

    get decayLFRatio();

    get decayTime();

    get density();

    get diffusion();

    get echoDepth();

    get echoTime();

    get gain();

    get gainHF();

    get gainLF();

    get hfReference();

    get lateReverbDelay();

    get lateReverbGain();

    get lfReference();

    get modulationDepth();

    get modulationTime();

    get reflectionsDelay();

    get reflectionsGain();

    get roomRolloffFactor();

    relativeDirections(emitter);

    relativeGains(emitter);
}

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

    VAEmitter** relativeEmitters;   /* Emitter keys for relativeDirections/relativeGains */
    VAVector* relativeDirections;   /* Direction that reverb should be heard from, relative to each emitter with hasRelativeReverb=true. Access via vaEAXReverbGetRelativeDirection */
    float* relativeGains;           /* Gain for this reverb effect, relative to each emitter with hasRelativeReverb=true. Access via vaEAXReverbGetRelativeGain */
    int relativeCount;
    int relativeCapacity;

    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;

// Get the direction that reverb should be heard from for the provided emitter. Returns NULL if no entry exists for this emitter (the emitter must have hasRelativeReverb=true)
VAVector* vaEAXReverbGetRelativeDirection(const VAEAXReverb* eax, const VAEmitter* emitter);

// Get the volume of this reverb preset, relative to the provided emitter. Returns NULL if no entry exists for this emitter (the emitter must have hasRelativeReverb=true)
float* vaEAXReverbGetRelativeGain(const VAEAXReverb* eax, const VAEmitter* emitter);

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

    // Computes how long a removed-but-tailing emitter should be kept alive and raytraced, using the slower of the low/high frequency decay ratios
    static float GetEffectiveTailSeconds(EAXReverb eax, float maxVolume = 1.0f);

    // Computes a similarity score between two reverb presets
    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);
}

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

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

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

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

    // Inverse of MaterialRoughness.
    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.
    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.
    float MeasuredDecayTimeLF;

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

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

interface ProcessedReverb
{

    get materialAbsorption();

    get materialAbsorptionHF();

    get materialAbsorptionLF();

    get materialRoughness();

    get materialSmoothness();

    get measuredDecayTimeHF();

    get measuredDecayTimeLF();

    get outsidePercent();

    get returnedPercent();
}

typedef struct VAProcessedReverb
{
    // percentages
    float returnedPercent;        /* 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);

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)
    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
    float OutsideTotal;

    // The total number of times that a ray returned to the listener. Will be in the range 0.0 to ReverbRayCount * ReverbBounceCount
    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;

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

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

    // Relative humidity as a percentage (0–1). Defaults to 0.1f
    float Humidity;

    // Atmospheric pressure in Pascals. Defaults to 101325
    float Pressure;

    // Air temperature in degrees Celsius. Defaults to 26
    float Temperature;

    // Create a new AirAbsorptionSettings with default settings
    AirAbsorptionSettings();
}

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

    get humidity(); set humidity(v);

    get pressure(); set pressure(v);

    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 — return VA_SUCCESS, VA_INVALID_VALUE if NaN/Infinity, or VA_OUT_OF_RANGE if out of range
// Relative humidity as a percentage (0–1)
VAResult vaAirAbsorptionSetHumidity(VAAirAbsorptionSettings* settings, float value);

// Air temperature in degrees Celsius (must be > -273.15)
VAResult vaAirAbsorptionSetTemperature(VAAirAbsorptionSettings* settings, float value);

// Atmospheric pressure in Pascals (must be > 0)
VAResult 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);

// Free all resources owned by this settings object
void vaAirAbsorptionDestroy(VAAirAbsorptionSettings* settings);

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

    // This object contains the LF and HF gain for ambient sounds, to be applied to a low pass filter
    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.
    // This formula is invoked on the main thread.
    // Parameters: (bool lowFrequency, int ambientOcclusionRayCount, int ambientPermeationRayCount, int ambientPermeationBounceCount, float ambientOcclusionEnergy, float ambientPermeationEnergy)
    // Returns: float
    Func<bool, int, int, int, float, float, float> AmbientGainFormula;

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

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

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

    // Number of ambient occlusion rays cast
    int AmbientOcclusionRayCount;

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

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

    // True if both AmbientPermeationRayCount and AmbientPermeationBounceCount are greater than zero
    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.
    float AmbientPermeationEnergyCap = 0.15f;

    // Number of ambient permeation rays cast
    int AmbientPermeationRayCount;

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

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

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

    // The length (in milliseconds) of each entry in the echogram
    int EchogramGranularity = 200;

    // 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.
    // This formula is invoked on background threads. Do not attempt to access data from the main thread within this function.
    // Parameters: (bool lowFrequency, int occlusionRayCount, int permeationRayCount, int permeationBounceCount, float occlusionEnergy, float permeationEnergy)
    // Returns: float
    Func<bool, int, int, int, float, float, float> GainFormula;

    // Read-only index indicating which GroupedEAX reverb effect should be used for this emitter
    int GroupedEAXIndex;

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

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

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

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

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

    // The loudest linear volume (0–1) this emitter's dry source will ever be played at by the consuming application. Used to estimate how long the emitter's reverb tail stays audible in GetEffectiveTailSeconds - a quieter source reaches an inaudible reverb tail sooner. Defaults to 1 (full volume)
    float MaxVolume = 1.0f;

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

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

    // Maximum number of bounces per occlusion ray
    int OcclusionBounceCount;

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

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

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

    // Number of occlusion rays cast
    int OcclusionRayCount;

    // Whether to only scatter rays around their yaw (no pitch or Y component)
    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.
    Action<Emitter> OnRaytracedByAnotherEmitter;

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

    // A callback that is invoked when this emitter is actually removed from the World. If it casts reverb rays and affects grouped EAX, it won't be removed until its reverb tail finishes playing.
    Action OnRemoved;

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

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

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

    // Whether this emitter has been marked for removal when its reverb tail has finished playing
    bool PendingRemoval;

    // Number of bounces per permeation ray
    int PermeationBounceCount;

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

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

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

    // Number of permeation rays cast
    int PermeationRayCount;

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

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

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

    // 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. Defaults to 1.0f. Clamped to minimum of 0.
    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.
    int RefreshRayCount = 16;

    // The lower bound of the relative reverb blend range. This affects the directional reverb that is heard by this emitter.
    float RelativeReverbInnerThreshold = 0.6f;

    // The upper bound of the relative reverb blend range. This affects the directional reverb that is heard by this emitter.
    float RelativeReverbOuterThreshold = 0.8f;

    // Number of bounces per reverb ray
    int ReverbBounceCount;

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

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

    // The percentage of returning energy required for reverb to be at maximum volume. Defaults to 20%.
    float ReverbEnergyCap = 0.2f;

    // Number of reverb rays cast
    int ReverbRayCount;

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

    // Number of bounces per trail
    int TrailBounceCount;

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

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

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

    // Number of bounces per visualisation ray
    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.
    Action<VisualisationData[]> VisualisationCallback;

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

    // Number of visualisation rays cast
    int VisualisationRayCount;

    // How often to cast visualisation rays (milliseconds)
    int VisualisationUpdateFrequency;

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

    // Create a new Emitter with default settings
    Emitter();

    // Adds an emitter to this emitter's target list
    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.
    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
    bool HasRaytracedTarget(Emitter target);

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

    // Removes an emitter from this emitter's target list
    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
    void ResetTrails();

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

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

    get affectsGroupedEAX(); set affectsGroupedEAX(v);

    get ambientOcclusionBounceCount(); set ambientOcclusionBounceCount(v);

    get ambientOcclusionEnergyCap(); set ambientOcclusionEnergyCap(v);

    get ambientOcclusionRayCount(); set ambientOcclusionRayCount(v);

    get ambientPermeationBounceCount(); set ambientPermeationBounceCount(v);

    get ambientPermeationEnergyCap(); set ambientPermeationEnergyCap(v);

    get ambientPermeationRayCount(); set ambientPermeationRayCount(v);

    get clampPosition(); set clampPosition(v);

    get echogramGranularity(); set echogramGranularity(v);

    get groupedEAXIndex(); set groupedEAXIndex(v);

    get hasRelativeReverb(); set hasRelativeReverb(v);

    get initialising(); set initialising(v);

    get maxEchogramTime(); set maxEchogramTime(v);

    get minimumPermeationEnergy(); set minimumPermeationEnergy(v);

    get occlusionBounceCount(); set occlusionBounceCount(v);

    get occlusionEnergyCap(); set occlusionEnergyCap(v);

    get occlusionRayCount(); set occlusionRayCount(v);

    get onlyScatterXZ(); set onlyScatterXZ(v);

    get outsidePercent(); set outsidePercent(v);

    get permeationBounceCount(); set permeationBounceCount(v);

    get permeationEnergyCap(); set permeationEnergyCap(v);

    get permeationRayCount(); set permeationRayCount(v);

    get position(); set position(v);

    get refreshDistanceThreshold(); set refreshDistanceThreshold(v);

    get refreshRayCount(); set refreshRayCount(v);

    get relativeReverbInnerThreshold(); set relativeReverbInnerThreshold(v);

    get relativeReverbOuterThreshold(); set relativeReverbOuterThreshold(v);

    get reverbBounceCount(); set reverbBounceCount(v);

    get reverbEnergyCap(); set reverbEnergyCap(v);

    get reverbRayCount(); set reverbRayCount(v);

    get type(); set type(v);

    get visualisationBounceCount(); set visualisationBounceCount(v);

    get visualisationRayCount(); set visualisationRayCount(v);

    get visualisationUpdateFrequency(); set visualisationUpdateFrequency(v);

    get ambientFilter();

    get ambientOcclusionEnabled();

    get ambientPermeationEnabled();

    get castsRays();

    get eax();

    get occlusionEnabled();

    get permeationEnabled();

    get processedReverb();

    get reverbEnabled();

    get trailBounceCount();

    get trailCount();

    get visualisationEnabled();

    get withinWorldBounds();

    set overridePositions(v);

    set overrideRayDirections(v);

    set visualisationCallback(v);

    set onRaytracedByAnotherEmitter(fn);

    set onRaytracingComplete(fn);

    addTarget(target);

    getTargetFilter(target);

    getWasmTrails(prev?);

    hasRaytracedTarget(target);

    hasTarget(target);

    removeTarget(target);

    resetTrails();

    setPosition(x, y, z);

    validate();
}

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

// Free all resources owned by this emitter. Returns VA_ERROR_IN_USE if the emitter is still added to a world
VAResult 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);

// Get the low pass filter to be applied to the target emitter. Only safe to call when vaEmitterHasRaytracedTarget() returns true for the provided target
VALowPassFilter* vaEmitterGetTargetFilter(VAEmitter* emitter, VAEmitter* target);

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

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

// Invalidate the ray cache. All rays will be re-cast the next time raytracing occurs.
void vaEmitterResetTrails(VAEmitter* emitter);

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

int vaEmitterGetReverbRayCount(const VAEmitter* emitter);

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

int vaEmitterGetReverbBounceCount(const VAEmitter* emitter);

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

int vaEmitterGetOcclusionRayCount(const VAEmitter* emitter);

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

int vaEmitterGetOcclusionBounceCount(const VAEmitter* emitter);

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

int vaEmitterGetPermeationRayCount(const VAEmitter* emitter);

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

int vaEmitterGetPermeationBounceCount(const VAEmitter* emitter);

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

int vaEmitterGetAmbientOcclusionRayCount(const VAEmitter* emitter);

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

int vaEmitterGetAmbientOcclusionBounceCount(const VAEmitter* emitter);

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

int vaEmitterGetAmbientPermeationRayCount(const VAEmitter* emitter);

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

int vaEmitterGetAmbientPermeationBounceCount(const VAEmitter* emitter);

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

void vaEmitterSetVisualisationRayCount(VAEmitter* emitter, int value);

// Number of bounces per visualisation ray
int vaEmitterGetVisualisationBounceCount(const VAEmitter* emitter);

void vaEmitterSetVisualisationBounceCount(VAEmitter* emitter, int value);

// Optimisation field - permeation rays that drop below this threshold will be treated as having 0 energy
void vaEmitterSetMinimumPermeationEnergy(VAEmitter* emitter, float value);

float vaEmitterGetMinimumPermeationEnergy(const VAEmitter* emitter);

VAResult vaEmitterSetMaxVolume(VAEmitter* emitter, float value);

float vaEmitterGetMaxVolume(const VAEmitter* emitter);

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

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

VAResult vaEmitterSetGainFormula(VAEmitter* emitter, VAEmitterGainFormula formula);

VAResult vaEmitterSetAmbientGainFormula(VAEmitter* emitter, VAEmitterGainFormula formula);

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

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

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

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

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

// True if any of the above ray types (except visualisation) are enabled
bool vaEmitterGetCastsAnyRays(const VAEmitter* emitter);

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

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

// A callback that is invoked after this emitter casts its rays for the first time
void vaEmitterSetOnRaytracingCompleteCallback(VAEmitter* emitter, VAEmitterOnRaytracingComplete callback);

// A callback that is invoked when another emitter raytraces this emitter for the first time
void vaEmitterSetOnRaytracedByAnotherEmitterCallback(VAEmitter* emitter, VAEmitterOnRaytracedByAnotherEmitter callback);

// A callback that is invoked when this emitter is actually removed from the world. If it casts reverb rays and affects grouped EAX, it won't be removed until its reverb tail finishes playing
void vaEmitterSetOnRemovedCallback(VAEmitter* emitter, VAEmitterOnRemoved 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);

VAVector vaEmitterGetPosition(const VAEmitter* emitter);

// True if this emitter hasn't cast its own rays yet
bool vaEmitterGetInitialising(const VAEmitter* emitter);

// True once vaWorldRemoveEmitter() has been called on this emitter and it is waiting for its reverb tail to finish before actually being removed
bool vaEmitterGetPendingRemoval(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);

bool vaEmitterGetAffectsGroupedEAX(const VAEmitter* emitter);

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

// Percentage of energy in ambient occlusion rays that reached the edge of the world (0.0 – 1.0)
float vaEmitterGetOutsidePercent(const VAEmitter* emitter);

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

bool vaEmitterGetHasRelativeReverb(const VAEmitter* emitter);

// The lower bound of the relative reverb blend range. This affects the directional reverb that is heard by this emitter
void vaEmitterSetRelativeReverbInnerThreshold(VAEmitter* emitter, float value);

float vaEmitterGetRelativeReverbInnerThreshold(const VAEmitter* emitter);

// The upper bound of the relative reverb blend range. This affects the directional reverb that is heard by this emitter
void vaEmitterSetRelativeReverbOuterThreshold(VAEmitter* emitter, float value);

float vaEmitterGetRelativeReverbOuterThreshold(const VAEmitter* emitter);

// Whether to clamp this emitter's position to the world bounds, to prevent it from 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. The emitter copies the string internally, so the caller does not need to keep the buffer alive after this call
void vaEmitterSetName(VAEmitter* emitter, const char* name);

// Returns the emitter's internal copy of the name. The pointer is valid until the next call to vaEmitterSetName or vaEmitterDestroy; do not free it
const char* vaEmitterGetName(const VAEmitter* emitter);

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

int vaEmitterGetType(const VAEmitter* emitter);

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

void vaEmitterSetVisualisationUpdateFrequency(VAEmitter* emitter, int value);

// Number of trails this emitter will create
int vaEmitterGetTrailCount(const VAEmitter* emitter);

// Number of bounces per trail
int vaEmitterGetTrailBounceCount(const VAEmitter* emitter);

// How long (in milliseconds) the echogram records data for. Returning reverb rays after this period will be ignored
int vaEmitterGetMaxEchogramTime(const VAEmitter* emitter);

void vaEmitterSetMaxEchogramTime(VAEmitter* emitter, int value);

// The length (in milliseconds) of each entry in the echogram
int vaEmitterGetEchogramGranularity(const VAEmitter* emitter);

void vaEmitterSetEchogramGranularity(VAEmitter* emitter, int value);

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

void vaEmitterSetRefreshRayCount(VAEmitter* emitter, int value);

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

void vaEmitterSetRefreshDistanceThreshold(VAEmitter* emitter, float value);

VAResult vaEmitterSetReverbEnergyCap(VAEmitter* emitter, float value);

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

VAResult vaEmitterSetOcclusionEnergyCap(VAEmitter* emitter, float value);

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

VAResult vaEmitterSetPermeationEnergyCap(VAEmitter* emitter, float value);

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

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

VAResult vaEmitterSetAmbientOcclusionEnergyCap(VAEmitter* emitter, float value);

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

VAResult vaEmitterSetAmbientPermeationEnergyCap(VAEmitter* emitter, float value);

// Get this emitter's processed reverb results. This is NULL until raytracing has run at least once
VAProcessedReverb* vaEmitterGetProcessedReverb(const VAEmitter* emitter);

// Get this emitter's EAX reverb results. This is NULL until raytracing has run at least once
VAEAXReverb* vaEmitterGetEAX(const VAEmitter* emitter);

// Get the low pass filter to be applied to ambient sounds. This is NULL until raytracing has run at least once
VALowPassFilter* vaEmitterGetAmbientFilter(const VAEmitter* emitter);

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

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

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

    get gainHF(); set gainHF(v);

    get gainLF(); set gainLF(v);
}

typedef struct VALowPassFilter
{
    float gainLF;
    float gainHF;
} VALowPassFilter;

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

    // Percentage of low-frequency energy that is lost on each bounce (0.0 to 1.0).
    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
    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
    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
    float Scattering;

    // How many meters a ray must travel through a primitive before it loses all high-frequency energy
    float TransmissionHF;

    // How many meters a ray must travel through a primitive before it loses all low-frequency energy
    float TransmissionLF;

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

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

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

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

    // Update all properties
    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 meters meters through a material
    static float MetersToTransmission(float meters);

    // Returns the distance in meters that reduces energy to 0.1% for the provided dB/m transmission value
    static float TransmissionToMeters(float transmission);
}

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

    get absorptionHF(); set absorptionHF(v);

    get absorptionLF(); set absorptionLF(v);

    get planeTransmissionHF(); set planeTransmissionHF(v);

    get planeTransmissionLF(); set planeTransmissionLF(v);

    get scattering(); set scattering(v);

    get transmissionHF(); set transmissionHF(v);

    get transmissionLF(); set transmissionLF(v);
}

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;

struct Matrix
{
    // Returns true if this matrix only contains translation components
    bool IsTranslationOnly;

    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;

    override bool Equals(object obj);

    override int GetHashCode();

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

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

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

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

    // The identity matrix
    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
    static bool operator ==(Matrix a, Matrix b);

    // Create a pure rotation/reflection matrix that reorients the whole rendered scene so that geometry imported verbatim from a CoordinateSystem-authored source (whose raw axis components land straight into this SDK's internal Y+-up/Z--forward fields with no conversion at import time) displays upright, for insertion into the shared view/projection chain (<c>cache_mvp</c>) so every draw call (primitives, grid, bounding boxes) rotates identically. Coefficients mirror ToInternal(CoordinateSystem, Vector) (not <c>ToConsumer</c> — that maps the opposite direction and rotates the scene around the wrong axis, e.g. spinning a Z-up import horizontally instead of standing it upright). Row convention: row i is where internal basis axis i is displayed (row-vector, v' = v * M).
    static Matrix CreateCoordinateSystemRotation(CoordinateSystem system);

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

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

    // Create an orthographic projection matrix
    static Matrix CreateOrthoProjection(float left, float top, float right, float bottom, float near, float far);

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

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

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

    // Create a scale matrix. Note scale matrices can only be set on MeshPrimitive and not any other primitive
    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
    static Matrix CreateScale(float scaleFactor);

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

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

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

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

    // Multiply two matrices together
    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);

// Returns true if the matrix only contains translation components
bool vaMatrixIsTranslationOnly(const VAMatrix* a);

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

    // The length of this vector
    float Magnitude;

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

    // The X component
    float X;

    // The Y component
    float Y;

    // The Z component
    float Z;

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

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

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

    override bool Equals(object obj);

    override int GetHashCode();

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

    // Returns true if any component of this vector is greater than the corresponding component in the other vector
    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
    bool GreaterEqualAny(Vector v);

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

    // Returns true if any component of this vector is less than the corresponding component in the other vector
    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
    bool LessEqualAny(Vector v);

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

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

    override string ToString();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // Transforms a normal vector by the transpose of the given inverse matrix (i.e. the inverse-transpose of the forward transform), supporting non-uniform scale
    static Vector TransformNormalByInverseTranspose(Vector a, Matrix inverseMatrix);

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

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

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

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

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

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

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

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

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

    // Returns the component-wise quotient of a and b
    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);

// Multiplies the vector by a scalar value
VAVector vaVectorMultiplyScalar(VAVector a, float scalar);

// Divides the vector by a scalar value
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);

// Get a component via an 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 a
VAVector vaVectorNormalize(VAVector a);

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

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

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

// Transforms a normal by the transpose of the given inverse matrix (inverse-transpose of the forward transform), supporting non-uniform scale
VAVector vaVectorTransformNormalByInverseTranspose(VAVector a, const VAMatrix* inverseMatrix);

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

// Reflects a direction vector about a normalised vector
VAVector vaVectorReflect(VAVector direction, VAVector normal);

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

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

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

    get normal(); set normal(v);

    get position(); set position(v);
}

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

class World
{
    // Air absorption settings. Set to null to disable air absorption.
    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.
    double AnalysisTime;

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

    // The pitch of the camera in the debug window (dev build only)
    float CameraPitch;

    // The position of the camera in the debug window (dev build only)
    Vector CameraPosition;

    // The speed of the camera in the debug window (dev build only)
    float CameraSpeed;

    // The yaw of the camera in the debug window (dev build only)
    float CameraYaw;

    // Coordinate system used in the debug window and when calculating listener-relative reverb directionality
    CoordinateSystem CoordinateSystem;

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

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

    // The epsilon value used for raytracing and primitive intersections. Defaults to 0.01f
    float Epsilon;

    // The field of view (in radians) of the camera in the debug window (dev build only)
    float FieldOfView;

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

    // True until raytracing has run at least once
    bool Initialising;

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

    // The average time (in milliseconds) between when Update is invoked, and when OnReverbUpdated is invoked.
    double Latency;

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

    // Whether to log memory allocation warnings
    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.
    double MainThreadTime;

    // Whether the debug window can independently move its camera around (dev build only)
    bool ManualCamera;

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

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

    // The maximum number of grouped EAX reverb properties shared across all emitters that affect grouped EAX. Higher values increase accuracy but are more expensive to run.
    int MaximumGroupedEAXCount = 3;

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

    // Callback that is invoked when keys are pressed (dev build only)
    Action<KeyEvent> OnKeyEvent;

    // This callback is invoked right after the background threads finish running. At this point, the results of the background threads have not been processed yet (EAX is not updated yet, low pass filters not updated, ambience not updated, etc). After this, OnReverbUpdated will be invoked next.
    Action OnRaytracingCompleted = null;

    // This callback is invoked after all raytracing results (EAX, filters, etc) have been processed. After this, new emitter/primitive settings will be applied, and the background threads will start again.
    Action OnRaytracingResultsHandled = null;

    // This callback is invoked after EAX reverb results are updated. This gives you a chance to update your EAX effects, so they can be applied to an emitter in it's OnRaytracingComplete callback. After this, each emitter's callback are invoked, and then OnRaytracingResultsHandled will be invoked next.
    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.
    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.
    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.
    double PreparationTime;

    // The number of rays cast this frame.
    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.
    double RaytracingTime;

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

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

    // Whether to render the raytracing scene in a separate window (dev build only)
    bool RenderingEnabled;

    // The time spent (in milliseconds) rendering the debug window (dev build only)
    double RenderTime;

    // Whether to render primitives in the debug window (dev build only)
    bool ShouldRenderPrimitives;

    // Whether to render rays in the debug window (dev build only)
    bool ShouldRenderRays;

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

    // The position of the debug window (dev build only)
    Vector2D WindowPosition;

    // The size of the debug window (dev build only)
    Vector2D WindowSize;

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

    // Whether the entire world is considered indoors or outdoors. When false, reverb rays stop accumulating energy after hitting the world edge. Defaults to false.
    bool WorldIsIndoors;

    // Create a new world
    World();

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

    // Add a new material to this world
    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.
    void AddPrimitive(Primitive primitive);

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

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

    // Get the debug rendering color for a specific material type (dev build only)
    Color GetMaterialColor(MaterialType type);

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

    // Returns true if a key is pressed in the debug window (dev build only)
    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.
    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.
    void RemovePrimitive(Primitive primitive);

    // Set the debug rendering color for a specific material type (dev build only)
    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. Calling this more frequently is safe and can reduce latency for emitter updates.
    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).
    void Wait();
}

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

    get airAbsorption(); set airAbsorption(v);

    get emittersOutsideTheWorldAreMuffled(); set emittersOutsideTheWorldAreMuffled(v);

    get epsilon(); set epsilon(v);

    get exposeTrails(); set exposeTrails(v);

    get inverseSpeedOfSound(); set inverseSpeedOfSound(v);

    get logMemoryAllocationWarnings(); set logMemoryAllocationWarnings(v);

    get maxBounds(); set maxBounds(v);

    get maximumConcurrencyLevel(); set maximumConcurrencyLevel(v);

    get maximumGroupedEAXCount(); set maximumGroupedEAXCount(v);

    get metersPerUnit(); set metersPerUnit(v);

    get pendingShutdown(); set pendingShutdown(v);

    get position(); set position(v);

    get referenceFrequencyHF(); set referenceFrequencyHF(v);

    get referenceFrequencyLF(); set referenceFrequencyLF(v);

    get size(); set size(v);

    get workItemCount(); set workItemCount(v);

    get worldIsIndoors(); set worldIsIndoors(v);

    get analysisTime();

    get areThreadsRunning();

    get groupedEAX();

    get initialising();

    get mainThreadTime();

    get preparationTime();

    get raytracingTime();

    set onReverbUpdated(fn);

    addEmitter(e);

    addMaterial(materialType, properties);

    addPrimitive(p);

    export();

    getBackgroundThreadCount();

    getMaterial(materialType);

    getThreadCount();

    hasMaterial(materialType);

    import(data);

    removeEmitter(e);

    removePrimitive(p);

    update();

    wait();
}