@grame/faustwasm 0.2.3 → 0.3.0

package/src/FaustSensors.ts

@@ -0,0 +1,370 @@
+export interface AccParams {
+    isEnabled: boolean;
+    acc: string;
+    address: string;
+    min: number;
+    max: number;
+    init: number;
+    label: string;
+}
+
+/** Enum describing the axis of the accelerometer or gyroscope */
+export enum Axis { x, y, z }
+
+/** Enum describing the curve of the accelerometer */
+export enum Curve { Up, Down, UpDown, DownUp }
+
+/** Object describing value off accelerometer metadata values */
+class AccMeta {
+    axis: Axis;
+    curve: Curve;
+    amin: number;
+    amid: number;
+    amax: number;
+}
+
+interface Range {
+    fLo: number;
+    fHi: number;
+    clip(x: number): number;
+}
+
+interface InterpolateObject {
+    amin: number;
+    amax: number;
+}
+interface Interpolator {
+    fRange: Range;
+    fCoef: number;
+    fOffset: number;
+    returnMappedValue(v: number): number;
+    getLowHigh(amin: number, amax: number): InterpolateObject;
+}
+
+interface InterpolateObject3pt {
+    amin: number;
+    amid: number;
+    amax: number;
+}
+interface Interpolator3pt {
+    fSegment1: Interpolator;
+    fSegment2: Interpolator;
+    fMid: number;
+    returnMappedValue(v: number): number;
+    getMappingValues(amin: number, amid: number, amax: number): InterpolateObject3pt;
+}
+
+/**
+ * ValueConverter interface
+ */
+interface ValueConverter {
+    uiToFaust(x: number): number;
+    faustToUi(x: number): number;
+}
+
+/**
+ * UpdatableValueConverter interface
+ */
+export interface UpdatableValueConverter extends ValueConverter {
+    fActive: boolean;
+
+    setMappingValues(amin: number, amid: number, amax: number, min: number, init: number, max: number): void;
+    getMappingValues(amin: number, amid: number, amax: number): InterpolateObject3pt;
+
+    setActive(onOff: boolean): void;
+    getActive(): boolean;
+}
+
+
+
+export default class FaustSensors {
+    /**
+     * Function to convert a number to an axis type
+     * 
+     * @param value number
+     * @returns axis type
+     */
+    static convertToAxis(value: number): Axis {
+        switch (value) {
+            case 0:
+                return Axis.x;
+            case 1:
+                return Axis.y;
+            case 2:
+                return Axis.z;
+            default:
+                console.error("Error: Axis not found value: " + value);
+                return Axis.x;
+        }
+    }
+    /**
+     * Function to convert a number to a curve type
+     * 
+     * @param value number
+     * @returns curve type
+     */
+    static convertToCurve(value: number): Curve {
+        switch (value) {
+            case 0:
+                return Curve.Up;
+            case 1:
+                return Curve.Down;
+            case 2:
+                return Curve.UpDown;
+            case 3:
+                return Curve.DownUp;
+            default:
+                console.error("Error: Curve not found value: " + value);
+                return Curve.Up;
+        }
+    }
+
+    // Converter objects use to map acc and Faust value
+    static _Range: new (x: number, y: number) => Range;
+    static get Range() {
+        if (!this._Range) {
+            this._Range = class {
+                fLo: number;
+                fHi: number;
+
+                constructor(x: number, y: number) {
+                    this.fLo = Math.min(x, y);
+                    this.fHi = Math.max(x, y);
+                }
+
+                clip(x: number): number {
+                    if (x < this.fLo) return this.fLo;
+                    if (x > this.fHi) return this.fHi;
+                    return x;
+                }
+            };
+        }
+        return this._Range;
+    }
+
+    static _Interpolator: new (lo: number, hi: number, v1: number, v2: number) => Interpolator;
+    /**
+     * Interpolator class
+     */
+    static get Interpolator() {
+        if (!this._Interpolator) {
+            this._Interpolator = class {
+                fRange: Range;
+                fCoef: number;
+                fOffset: number;
+
+                constructor(lo: number, hi: number, v1: number, v2: number) {
+                    this.fRange = new FaustSensors.Range(lo, hi);
+                    if (hi !== lo) {
+                        // regular case
+                        this.fCoef = (v2 - v1) / (hi - lo);
+                        this.fOffset = v1 - lo * this.fCoef;
+                    } else {
+                        // degenerate case, avoids division by zero
+                        this.fCoef = 0;
+                        this.fOffset = (v1 + v2) / 2;
+                    }
+                }
+                returnMappedValue(v: number): number {
+                    var x = this.fRange.clip(v);
+                    return this.fOffset + x * this.fCoef;
+                }
+                getLowHigh(amin: number, amax: number): InterpolateObject {
+                    return { amin: this.fRange.fLo, amax: this.fRange.fHi };
+                }
+            };
+        }
+        return this._Interpolator;
+    }
+
+    static _Interpolator3pt: new (lo: number, mid: number, hi: number, v1: number, vMid: number, v2: number) => Interpolator3pt;
+    /**
+     * Interpolator3pt class, combine two interpolators
+     */
+    static get Interpolator3pt() {
+        if (!this._Interpolator3pt) {
+            this._Interpolator3pt = class {
+
+                fSegment1: Interpolator;
+                fSegment2: Interpolator;
+                fMid: number;
+
+                constructor(lo: number, mid: number, hi: number, v1: number, vMid: number, v2: number) {
+                    this.fSegment1 = new FaustSensors.Interpolator(lo, mid, v1, vMid);
+                    this.fSegment2 = new FaustSensors.Interpolator(mid, hi, vMid, v2);
+                    this.fMid = mid;
+                }
+                returnMappedValue(x: number): number {
+                    return (x < this.fMid) ? this.fSegment1.returnMappedValue(x) : this.fSegment2.returnMappedValue(x);
+                }
+
+                getMappingValues(amin: number, amid: number, amax: number): InterpolateObject3pt {
+                    var lowHighSegment1 = this.fSegment1.getLowHigh(amin, amid);
+                    var lowHighSegment2 = this.fSegment2.getLowHigh(amid, amax);
+                    return { amin: lowHighSegment1.amin, amid: lowHighSegment2.amin, amax: lowHighSegment2.amax };
+                }
+            }
+
+        }
+        return this._Interpolator3pt;
+    }
+    static _UpConverter: new (amin: number, amid: number, amax: number, fmin: number, fmid: number, fmax: number) => UpdatableValueConverter;
+    /**
+     * UpConverter class, convert accelerometer value to Faust value
+     */
+    static get UpConverter() {
+        if (!this._UpConverter) {
+            this._UpConverter = class implements UpdatableValueConverter {
+
+                fA2F: Interpolator3pt;
+                fF2A: Interpolator3pt;
+                fActive: boolean = true;
+
+                constructor(amin: number, amid: number, amax: number, fmin: number, fmid: number, fmax: number) {
+                    this.fA2F = new FaustSensors.Interpolator3pt(amin, amid, amax, fmin, fmid, fmax);
+                    this.fF2A = new FaustSensors.Interpolator3pt(fmin, fmid, fmax, amin, amid, amax);
+                }
+
+                uiToFaust(x: number) { return this.fA2F.returnMappedValue(x) }
+                faustToUi(x: number) { return this.fF2A.returnMappedValue(x) }
+
+                setMappingValues(amin: number, amid: number, amax: number, min: number, init: number, max: number): void {
+                    this.fA2F = new FaustSensors.Interpolator3pt(amin, amid, amax, min, init, max);
+                    this.fF2A = new FaustSensors.Interpolator3pt(min, init, max, amin, amid, amax);
+                }
+
+                getMappingValues(amin: number, amid: number, amax: number): InterpolateObject3pt {
+                    return this.fA2F.getMappingValues(amin, amid, amax);
+                }
+
+                setActive(onOff: boolean): void { this.fActive = onOff }
+                getActive(): boolean { return this.fActive }
+            }
+
+        }
+        return this._UpConverter;
+    }
+    static _DownConverter: new (amin: number, amid: number, amax: number, fmin: number, fmid: number, fmax: number) => UpdatableValueConverter;
+    /**
+     * DownConverter class, convert accelerometer value to Faust value
+     */
+    static get DownConverter() {
+        if (!this._DownConverter) {
+            this._DownConverter = class implements UpdatableValueConverter {
+
+                fA2F: Interpolator3pt;
+                fF2A: Interpolator3pt;
+                fActive: boolean = true;
+
+                constructor(amin: number, amid: number, amax: number, fmin: number, fmid: number, fmax: number) {
+                    this.fA2F = new FaustSensors.Interpolator3pt(amin, amid, amax, fmax, fmid, fmin);
+                    this.fF2A = new FaustSensors.Interpolator3pt(fmin, fmid, fmax, amax, amid, amin);
+                }
+
+                uiToFaust(x: number) { return this.fA2F.returnMappedValue(x) }
+                faustToUi(x: number) { return this.fF2A.returnMappedValue(x) }
+
+                setMappingValues(amin: number, amid: number, amax: number, min: number, init: number, max: number): void {
+                    this.fA2F = new FaustSensors.Interpolator3pt(amin, amid, amax, max, init, min);
+                    this.fF2A = new FaustSensors.Interpolator3pt(min, init, max, amax, amid, amin);
+                }
+                getMappingValues(amin: number, amid: number, amax: number): InterpolateObject3pt {
+                    return this.fA2F.getMappingValues(amin, amid, amax);
+                }
+
+                setActive(onOff: boolean): void { this.fActive = onOff }
+                getActive(): boolean { return this.fActive }
+            }
+
+        }
+        return this._DownConverter;
+    }
+    static _UpDownConverter: new (amin: number, amid: number, amax: number, fmin: number, fmid: number, fmax: number) => UpdatableValueConverter;
+    /**
+     * UpDownConverter class, convert accelerometer value to Faust value
+     */
+    static get UpDownConverter() {
+        if (!this._UpDownConverter) {
+            this._UpDownConverter = class implements UpdatableValueConverter {
+
+                fA2F: Interpolator3pt;
+                fF2A: Interpolator;
+                fActive: boolean = true;
+
+                constructor(amin: number, amid: number, amax: number, fmin: number, fmid: number, fmax: number) {
+                    this.fA2F = new FaustSensors.Interpolator3pt(amin, amid, amax, fmin, fmax, fmin);
+                    this.fF2A = new FaustSensors.Interpolator(fmin, fmax, amin, amax);
+                }
+
+                uiToFaust(x: number) { return this.fA2F.returnMappedValue(x) }
+                faustToUi(x: number) { return this.fF2A.returnMappedValue(x) }
+
+                setMappingValues(amin: number, amid: number, amax: number, min: number, init: number, max: number): void {
+                    this.fA2F = new FaustSensors.Interpolator3pt(amin, amid, amax, min, max, min);
+                    this.fF2A = new FaustSensors.Interpolator(min, max, amin, amax);
+                }
+                getMappingValues(amin: number, amid: number, amax: number): InterpolateObject3pt {
+                    return this.fA2F.getMappingValues(amin, amid, amax);
+                }
+
+                setActive(onOff: boolean): void { this.fActive = onOff }
+                getActive(): boolean { return this.fActive }
+            }
+
+        }
+        return this._UpDownConverter;
+    }
+    /**
+     * DownUpConverter class, convert accelerometer value to Faust value
+     */
+    static _DownUpConverter: new (amin: number, amid: number, amax: number, fmin: number, fmid: number, fmax: number) => UpdatableValueConverter;
+    static get DownUpConverter() {
+        if (!this._DownUpConverter) {
+            this._DownUpConverter = class implements UpdatableValueConverter {
+
+                fA2F: Interpolator3pt;
+                fF2A: Interpolator;
+                fActive: boolean = true;
+
+                constructor(amin: number, amid: number, amax: number, fmin: number, fmid: number, fmax: number) {
+                    this.fA2F = new FaustSensors.Interpolator3pt(amin, amid, amax, fmax, fmin, fmax);
+                    this.fF2A = new FaustSensors.Interpolator(fmin, fmax, amin, amax);
+                }
+
+                uiToFaust(x: number) { return this.fA2F.returnMappedValue(x) }
+                faustToUi(x: number) { return this.fF2A.returnMappedValue(x) }
+
+                setMappingValues(amin: number, amid: number, amax: number, min: number, init: number, max: number): void {
+                    this.fA2F = new FaustSensors.Interpolator3pt(amin, amid, amax, max, min, max);
+                    this.fF2A = new FaustSensors.Interpolator(min, max, amin, amax);
+                }
+                getMappingValues(amin: number, amid: number, amax: number): InterpolateObject3pt {
+                    return this.fA2F.getMappingValues(amin, amid, amax);
+                }
+
+                setActive(onOff: boolean): void { this.fActive = onOff }
+                getActive(): boolean { return this.fActive }
+            }
+        }
+        return this._DownUpConverter;
+    }
+    /**
+     * Public function to build the accelerometer handler
+     *
+     * @returns `UpdatableValueConverter` built for the given curve
+     */
+    static buildHandler(curve: Curve, amin: number, amid: number, amax: number, min: number, init: number, max: number): UpdatableValueConverter {
+        switch (curve) {
+            case Curve.Up:
+                return new FaustSensors.UpConverter(amin, amid, amax, min, init, max);
+            case Curve.Down:
+                return new FaustSensors.DownConverter(amin, amid, amax, min, init, max);
+            case Curve.UpDown:
+                return new FaustSensors.UpDownConverter(amin, amid, amax, min, init, max);
+            case Curve.DownUp:
+                return new FaustSensors.DownUpConverter(amin, amid, amax, min, init, max);
+            default:
+                return new FaustSensors.UpConverter(amin, amid, amax, min, init, max);
+        }
+    }
+}

package/src/FaustWebAudioDsp.ts

@@ -1,5 +1,6 @@
 import type { FaustMonoDspInstance, FaustPolyDspInstance, IFaustDspInstance } from "./FaustDspInstance";
 import type { AudioData, FaustDspMeta, FaustUIDescriptor, FaustUIGroup, FaustUIInputItem, FaustUIItem, LooseFaustDspFactory } from "./types";
+import FaustSensors, { Axis, Curve, UpdatableValueConverter } from "./FaustSensors";
 
 // Public API
 export type OutputParamHandler = (path: string, value: number) => void;
@@ -10,6 +11,16 @@ export type MetadataHandler = (key: string, value: string) => void;
 // Implementation API
 export type UIHandler = (item: FaustUIItem) => void;
 
+// Accelerometer or gyroscope handler
+export type SensorEventHandler = (val: number) => void;
+
+// Define a type for the accelerometer or gyroscope handlers
+export type SensorEventHandlers = {
+    x: SensorEventHandler[];
+    y: SensorEventHandler[];
+    z: SensorEventHandler[];
+};
+
 /** Definition of the AudioBufferItem type */
 export interface AudioBufferItem {
     pathName: string;
@@ -499,6 +510,16 @@ export interface IFaustBaseWebAudioDsp {
      * Destroy the DSP.
      */
     destroy(): void;
+
+    /** Indicating if the DSP handles the accelerometer */
+    readonly hasAccInput: boolean;
+    /** Accelerometer handling */
+    propagateAcc(accelerationIncludingGravity: NonNullable<DeviceMotionEvent["accelerationIncludingGravity"]>): void;
+
+    /** Indicating if the DSP handles the gyroscope */
+    readonly hasGyrInput: boolean;
+    /** Gyroscope handling */
+    propagateGyr(event: Pick<DeviceOrientationEvent, "alpha" | "beta" | "gamma">): void;
 }
 
 export interface IFaustMonoWebAudioDsp extends IFaustBaseWebAudioDsp { }
@@ -557,6 +578,10 @@ export class FaustBaseWebAudioDsp implements IFaustBaseWebAudioDsp {
     /** Keep the end of memory offset before soundfiles */
     protected fEndMemory: number;
 
+    // Accelerometer handling
+    protected fAcc: SensorEventHandlers; // array of accelerometer handlers on x,y,y axes, to be called with DeviceMotionEvent
+    protected fGyr: SensorEventHandlers; // array of gyroscope handlers on alpha,beta,gama axes, to be called with DeviceMotionEvent
+
     // Buffers in wasm memory
     protected fAudioInputs!: number;
     protected fAudioOutputs!: number;
@@ -579,18 +604,30 @@ export class FaustBaseWebAudioDsp implements IFaustBaseWebAudioDsp {
             this.fInputsItems.push(item.address);
             this.fPathTable[item.address] = item.index;
             this.fDescriptor.push(item);
-            // Parse 'midi' metadata
             if (!item.meta) return;
             item.meta.forEach((meta) => {
-                const { midi } = meta;
-                if (!midi) return;
-                const strMidi = midi.trim();
-                if (strMidi === "pitchwheel") {
-                    this.fPitchwheelLabel.push({ path: item.address, min: item.min as number, max: item.max as number });
-                } else {
-                    const matched = strMidi.match(/^ctrl\s(\d+)/);
-                    if (!matched) return;
-                    this.fCtrlLabel[parseInt(matched[1])].push({ path: item.address, min: item.min as number, max: item.max as number });
+                const { midi, acc, gyr } = meta;
+                // Parse 'midi' metadata
+                if (midi) {
+                    const strMidi = midi.trim();
+                    if (strMidi === "pitchwheel") {
+                        this.fPitchwheelLabel.push({ path: item.address, min: item.min as number, max: item.max as number });
+                    } else {
+                        const matched = strMidi.match(/^ctrl\s(\d+)/);
+                        if (matched) {
+                            this.fCtrlLabel[parseInt(matched[1])].push({ path: item.address, min: item.min as number, max: item.max as number });
+                        }
+                    }
+                }
+                // Parse 'acc' metadata
+                if (acc) {
+                    const numAcc: number[] = acc.trim().split(" ").map(Number);
+                    this.setupAccHandler(item.address, FaustSensors.convertToAxis(numAcc[0]), FaustSensors.convertToCurve(numAcc[1]), numAcc[2], numAcc[3], numAcc[4], item.min as number, item.init as number, item.max as number);
+                }
+                // Parse 'gyr' metadata
+                if (gyr) {
+                    const numAcc: number[] = gyr.trim().split(" ").map(Number);
+                    this.setupGyrHandler(item.address, FaustSensors.convertToAxis(numAcc[0]), FaustSensors.convertToCurve(numAcc[1]), numAcc[2], numAcc[3], numAcc[4], item.min as number, item.init as number, item.max as number);
                 }
             });
         } else if (item.type === "soundfile") {
@@ -610,6 +647,8 @@ export class FaustBaseWebAudioDsp implements IFaustBaseWebAudioDsp {
         this.fPtrSize = sampleSize; // Done on wast/wasm backend side
         this.fSampleSize = sampleSize;
         this.fSoundfileBuffers = soundfiles;
+        this.fAcc = { x: [], y: [], z: [] };
+        this.fGyr = { x: [], y: [], z: [] };
     }
 
     // Tools
@@ -647,6 +686,65 @@ export class FaustBaseWebAudioDsp implements IFaustBaseWebAudioDsp {
         return trimmed.split(";").map(str => str.length <= 2 ? '' : str.substring(1, str.length - 1));
     }
 
+    get hasAccInput() { return this.fAcc.x.length + this.fAcc.y.length + this.fAcc.z.length > 0; }
+    propagateAcc(accelerationIncludingGravity: NonNullable<DeviceMotionEvent["accelerationIncludingGravity"]>) {
+
+        // Get accelerometervalues
+        const { x, y, z } = accelerationIncludingGravity;
+
+        // Call the accelerometer handlers
+        if (x !== null) this.fAcc.x.forEach(handler => handler(x));
+        if (y !== null) this.fAcc.y.forEach(handler => handler(y));
+        if (z !== null) this.fAcc.z.forEach(handler => handler(z));
+    }
+
+    get hasGyrInput() { return this.fGyr.x.length + this.fGyr.y.length + this.fGyr.z.length > 0; }
+    propagateGyr(event: Pick<DeviceOrientationEvent, "alpha" | "beta" | "gamma">) {
+
+        // Get gyroscope values
+        const { alpha, beta, gamma } = event;
+
+        // Call the gyroscope handlers
+        if (alpha !== null) this.fGyr.x.forEach(handler => handler(alpha));
+        if (beta !== null) this.fGyr.y.forEach(handler => handler(beta));
+        if (gamma !== null) this.fGyr.z.forEach(handler => handler(gamma));
+    }
+
+    /** Build the accelerometer handler */
+    private setupAccHandler(path: string, axis: Axis, curve: Curve, amin: number, amid: number, amax: number, min: number, init: number, max: number) {
+
+        const handler: UpdatableValueConverter = FaustSensors.buildHandler(curve, amin, amid, amax, min, init, max);
+        switch (axis) {
+            case Axis.x:
+                this.fAcc.x.push((val) => this.setParamValue(path, handler.uiToFaust(val)));
+                break;
+            case Axis.y:
+                this.fAcc.y.push((val) => this.setParamValue(path, handler.uiToFaust(val)));
+                break;
+            case Axis.z:
+                this.fAcc.z.push((val) => this.setParamValue(path, handler.uiToFaust(val)));
+                break;
+        }
+    }
+
+    /** Build the gyroscope handler */
+    private setupGyrHandler(path: string, axis: Axis, curve: Curve, amin: number, amid: number, amax: number, min: number, init: number, max: number) {
+
+        const handler: UpdatableValueConverter = FaustSensors.buildHandler(curve, amin, amid, amax, min, init, max);
+        switch (axis) {
+            case Axis.x:
+                this.fGyr.x.push((val) => this.setParamValue(path, handler.uiToFaust(val)));
+                break;
+            case Axis.y:
+                this.fGyr.y.push((val) => this.setParamValue(path, handler.uiToFaust(val)));
+                break;
+            case Axis.z:
+                this.fGyr.z.push((val) => this.setParamValue(path, handler.uiToFaust(val)));
+                break;
+        }
+    }
+
+
     static extractUrlsFromMeta(dspMeta: FaustDspMeta): string[] {
         // Find the entry with the "soundfiles" key
         const soundfilesEntry = dspMeta.meta.find(entry => entry.soundfiles !== undefined);
@@ -911,6 +1009,7 @@ export class FaustMonoWebAudioDsp extends FaustBaseWebAudioDsp implements IFaust
             // Init soundfiles memory
             this.initSoundfileMemory(allocator, this.fDSP);
         }
+
     }
 
     private initMemory(): number {

package/test/faustlive-wasm/faustwasm/index.d.ts

@@ -376,6 +376,12 @@ export type PlotHandler = (plotted: Float32Array[] | Float64Array[], index: numb
 }[]) => void;
 export type MetadataHandler = (key: string, value: string) => void;
 export type UIHandler = (item: FaustUIItem) => void;
+export type SensorEventHandler = (val: number) => void;
+export type SensorEventHandlers = {
+	x: SensorEventHandler[];
+	y: SensorEventHandler[];
+	z: SensorEventHandler[];
+};
 /** Definition of the AudioBufferItem type */
 export interface AudioBufferItem {
 	pathName: string;
@@ -626,6 +632,14 @@ export interface IFaustBaseWebAudioDsp {
 	 * Destroy the DSP.
 	 */
 	destroy(): void;
+	/** Indicating if the DSP handles the accelerometer */
+	readonly hasAccInput: boolean;
+	/** Accelerometer handling */
+	propagateAcc(accelerationIncludingGravity: NonNullable<DeviceMotionEvent["accelerationIncludingGravity"]>): void;
+	/** Indicating if the DSP handles the gyroscope */
+	readonly hasGyrInput: boolean;
+	/** Gyroscope handling */
+	propagateGyr(event: Pick<DeviceOrientationEvent, "alpha" | "beta" | "gamma">): void;
 }
 export interface IFaustMonoWebAudioDsp extends IFaustBaseWebAudioDsp {
 }
@@ -676,6 +690,8 @@ export declare class FaustBaseWebAudioDsp implements IFaustBaseWebAudioDsp {
 	protected fSoundfileBuffers: LooseFaustDspFactory["soundfiles"];
 	/** Keep the end of memory offset before soundfiles */
 	protected fEndMemory: number;
+	protected fAcc: SensorEventHandlers;
+	protected fGyr: SensorEventHandlers;
 	protected fAudioInputs: number;
 	protected fAudioOutputs: number;
 	protected fBufferSize: number;
@@ -707,6 +723,14 @@ export declare class FaustBaseWebAudioDsp implements IFaustBaseWebAudioDsp {
 	static parseItem(item: FaustUIItem, callback: (item: FaustUIItem) => any): void;
 	/** Split the soundfile names and return an array of names */
 	static splitSoundfileNames(input: string): string[];
+	get hasAccInput(): boolean;
+	propagateAcc(accelerationIncludingGravity: NonNullable<DeviceMotionEvent["accelerationIncludingGravity"]>): void;
+	get hasGyrInput(): boolean;
+	propagateGyr(event: Pick<DeviceOrientationEvent, "alpha" | "beta" | "gamma">): void;
+	/** Build the accelerometer handler */
+	private setupAccHandler;
+	/** Build the gyroscope handler */
+	private setupGyrHandler;
 	static extractUrlsFromMeta(dspMeta: FaustDspMeta): string[];
 	/**
 	 * Load a soundfile possibly containing several parts in the DSP struct.
@@ -1098,6 +1122,10 @@ export declare class FaustOfflineProcessor<Poly extends boolean = false> {
 	start(): void;
 	stop(): void;
 	destroy(): void;
+	get hasAccInput(): boolean;
+	propagateAcc(accelerationIncludingGravity: NonNullable<DeviceMotionEvent["accelerationIncludingGravity"]>): void;
+	get hasGyrInput(): boolean;
+	propagateGyr(event: Pick<DeviceOrientationEvent, "alpha" | "beta" | "gamma">): void;
 	/**
 	 * Render frames in an array.
 	 *
@@ -1239,6 +1267,7 @@ declare const FaustAudioWorkletNode_base: {
  * Base class for Monophonic and Polyphonic AudioWorkletNode
  */
 export declare class FaustAudioWorkletNode<Poly extends boolean = false> extends FaustAudioWorkletNode_base {
+	#private;
 	protected fJSONDsp: FaustDspMeta;
 	protected fJSON: string;
 	protected fInputsItems: string[];
@@ -1248,6 +1277,8 @@ export declare class FaustAudioWorkletNode<Poly extends boolean = false> extends
 	protected fUICallback: UIHandler;
 	protected fDescriptor: FaustUIInputItem[];
 	constructor(context: BaseAudioContext, name: string, factory: LooseFaustDspFactory, options: FaustAudioWorkletNodeOptions<Poly>["processorOptions"], nodeOptions?: Partial<FaustAudioWorkletNodeOptions>);
+	/** Setup accelerometer and gyroscope handlers */
+	listenMotion(): Promise<void>;
 	setOutputParamHandler(handler: OutputParamHandler | null): void;
 	getOutputParamHandler(): OutputParamHandler | null;
 	setComputeHandler(handler: ComputeHandler | null): void;
@@ -1261,6 +1292,10 @@ export declare class FaustAudioWorkletNode<Poly extends boolean = false> extends
 	midiMessage(data: number[] | Uint8Array): void;
 	ctrlChange(channel: number, ctrl: number, value: number): void;
 	pitchWheel(channel: number, wheel: number): void;
+	get hasAccInput(): boolean;
+	propagateAcc(accelerationIncludingGravity: NonNullable<DeviceMotionEvent["accelerationIncludingGravity"]>): void;
+	get hasGyrInput(): boolean;
+	propagateGyr(event: Pick<DeviceOrientationEvent, "alpha" | "beta" | "gamma">): void;
 	setParamValue(path: string, value: number): void;
 	getParamValue(path: string): number;
 	getParams(): string[];
@@ -1305,6 +1340,8 @@ export declare class FaustScriptProcessorNode<Poly extends boolean = false> exte
 	protected fInputs: Float32Array[];
 	protected fOutputs: Float32Array[];
 	init(instance: Poly extends true ? FaustPolyWebAudioDsp : FaustMonoWebAudioDsp): void;
+	/** Setup accelerometer and gyroscope handlers */
+	listenMotion(): Promise<void>;
 	compute(input: Float32Array[], output: Float32Array[]): boolean;
 	setOutputParamHandler(handler: OutputParamHandler): void;
 	getOutputParamHandler(): OutputParamHandler | null;
@@ -1328,6 +1365,10 @@ export declare class FaustScriptProcessorNode<Poly extends boolean = false> exte
 	start(): void;
 	stop(): void;
 	destroy(): void;
+	get hasAccInput(): boolean;
+	propagateAcc(accelerationIncludingGravity: NonNullable<DeviceMotionEvent["accelerationIncludingGravity"]>): void;
+	get hasGyrInput(): boolean;
+	propagateGyr(event: Pick<DeviceOrientationEvent, "alpha" | "beta" | "gamma">): void;
 }
 export declare class FaustMonoScriptProcessorNode extends FaustScriptProcessorNode<false> implements IFaustMonoWebAudioDsp {
 }