@grame/faustwasm 0.2.2 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grame/faustwasm",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "WebAssembly version of Faust Compiler",
   "main": "dist/cjs/index.js",
   "types": "dist/esm/index.d.ts",

package/src/FaustAudioWorkletNode.ts

@@ -15,6 +15,8 @@ export class FaustAudioWorkletNode<Poly extends boolean = false> extends (global
     protected fPlotHandler: PlotHandler | null;
     protected fUICallback: UIHandler;
     protected fDescriptor: FaustUIInputItem[];
+    #hasAccInput = false;
+    #hasGyrInput = false;
 
     constructor(context: BaseAudioContext, name: string, factory: LooseFaustDspFactory, options: FaustAudioWorkletNodeOptions<Poly>["processorOptions"], nodeOptions: Partial<FaustAudioWorkletNodeOptions> = {}) {
 
@@ -47,8 +49,15 @@ export class FaustAudioWorkletNode<Poly extends boolean = false> extends (global
                 // Keep inputs adresses
                 this.fInputsItems.push(item.address);
                 this.fDescriptor.push(item);
+                if (!item.meta) return;
+                item.meta.forEach((meta) => {
+                    const { midi, acc, gyr } = meta;
+                    if (acc) this.#hasAccInput = true;
+                    if (gyr) this.#hasGyrInput = true;
+                });
             }
         }
+
         FaustBaseWebAudioDsp.parseUI(this.fJSONDsp.ui, this.fUICallback);
 
         // Patch it with additional functions
@@ -62,6 +71,55 @@ export class FaustAudioWorkletNode<Poly extends boolean = false> extends (global
     }
 
     // Public API
+
+    /** Setup accelerometer and gyroscope handlers */
+    async listenMotion() {
+        if (this.hasAccInput) {
+            const handleDeviceMotion = ({ accelerationIncludingGravity }: DeviceMotionEvent) => {
+                if (!accelerationIncludingGravity) return;
+                const { x, y, z } = accelerationIncludingGravity;
+                this.propagateAcc({ x, y, z });
+            };
+            if (window.DeviceMotionEvent) {
+                if (typeof (window.DeviceMotionEvent as any).requestPermission === "function") { // for iOS 13+
+                    try {
+                        const response = await (window.DeviceMotionEvent as any).requestPermission();
+                        if (response !== "granted") throw new Error("Unable to access the accelerometer.");
+                        window.addEventListener("devicemotion", handleDeviceMotion, true);
+                    } catch (error) {
+                        console.error(error);
+                    }
+                } else {
+                    window.addEventListener("devicemotion", handleDeviceMotion, true);
+                }
+            } else {
+                // Browser doesn't support DeviceMotionEvent
+                console.log("Cannot set the accelerometer handler.");
+            }
+        }
+        if (this.hasGyrInput) {
+            const handleDeviceOrientation = ({ alpha, beta, gamma }: DeviceOrientationEvent) => {
+                this.propagateGyr({ alpha, beta, gamma });
+            };
+            if (window.DeviceMotionEvent) {
+                if (typeof (window.DeviceOrientationEvent as any).requestPermission === "function") { // for iOS 13+
+                    try {
+                        const response = await (window.DeviceOrientationEvent as any).requestPermission();
+                        if (response !== "granted") throw new Error("Unable to access the gyroscope.");
+                        window.addEventListener("deviceorientation", handleDeviceOrientation, true);
+                    } catch (error) {
+                        console.error(error);
+                    }
+                } else {
+                    window.addEventListener("deviceorientation", handleDeviceOrientation, true);
+                }
+            } else {
+                // Browser doesn't support DeviceMotionEvent
+                console.log("Cannot set the gyroscope handler.");
+            }
+        }
+    }
+
     setOutputParamHandler(handler: OutputParamHandler | null) {
         this.fOutputHandler = handler;
     }
@@ -126,6 +184,20 @@ export class FaustAudioWorkletNode<Poly extends boolean = false> extends (global
         this.port.postMessage(e);
     }
 
+    get hasAccInput() { return this.#hasAccInput; }
+    propagateAcc(accelerationIncludingGravity: NonNullable<DeviceMotionEvent["accelerationIncludingGravity"]>) {
+        if (!accelerationIncludingGravity) return;
+        const e = { type: "acc", data: accelerationIncludingGravity };
+        this.port.postMessage(e);
+    }
+
+    get hasGyrInput() { return this.#hasGyrInput; }
+    propagateGyr(event: Pick<DeviceOrientationEvent, "alpha" | "beta" | "gamma">) {
+        if (!event) return;
+        const e = { type: "gyr", data: event };
+        this.port.postMessage(e);
+    }
+
     setParamValue(path: string, value: number) {
         const e = { type: "param", data: { path, value } };
         this.port.postMessage(e);
@@ -158,6 +230,7 @@ export class FaustAudioWorkletNode<Poly extends boolean = false> extends (global
         this.port.postMessage({ type: "destroy" });
         this.port.close();
     }
+
 }
 
 /**

package/src/FaustAudioWorkletProcessor.ts

@@ -125,13 +125,34 @@ const getFaustAudioWorkletProcessor = <Poly extends boolean = false>(dependencie
             const msg = e.data;
 
             switch (msg.type) {
+                // Sensors messages
+                case "acc": {
+                    this.propagateAcc(msg.data);
+                    break;
+                }
+                case "gyr": {
+                    this.propagateGyr(msg.data);
+                    break;
+                }
                 // Generic MIDI message
-                case "midi": this.midiMessage(msg.data); break;
+                case "midi": {
+                    this.midiMessage(msg.data);
+                    break;
+                }
                 // Typed MIDI message
-                case "ctrlChange": this.ctrlChange(msg.data[0], msg.data[1], msg.data[2]); break;
-                case "pitchWheel": this.pitchWheel(msg.data[0], msg.data[1]); break;
+                case "ctrlChange": {
+                    this.ctrlChange(msg.data[0], msg.data[1], msg.data[2]);
+                    break;
+                }
+                case "pitchWheel": {
+                    this.pitchWheel(msg.data[0], msg.data[1]);
+                    break;
+                }
                 // Generic data message
-                case "param": this.setParamValue(msg.data.path, msg.data.value); break;
+                case "param": {
+                    this.setParamValue(msg.data.path, msg.data.value);
+                    break;
+                }
                 // Plot handler set on demand
                 case "setPlotHandler": {
                     if (msg.data) {
@@ -175,6 +196,14 @@ const getFaustAudioWorkletProcessor = <Poly extends boolean = false>(dependencie
         protected pitchWheel(channel: number, wheel: number) {
             this.fDSPCode.pitchWheel(channel, wheel);
         }
+
+        protected propagateAcc(accelerationIncludingGravity: NonNullable<DeviceMotionEvent["accelerationIncludingGravity"]>) {
+            this.fDSPCode.propagateAcc(accelerationIncludingGravity);
+        }
+
+        protected propagateGyr(event: Pick<DeviceOrientationEvent, "alpha" | "beta" | "gamma">) {
+            this.fDSPCode.propagateGyr(event);
+        }
     }
 
     /**

package/src/FaustDspGenerator.ts

@@ -6,9 +6,11 @@ import FaustWasmInstantiator from "./FaustWasmInstantiator";
 import { FaustMonoOfflineProcessor, FaustPolyOfflineProcessor, IFaustMonoOfflineProcessor, IFaustPolyOfflineProcessor } from "./FaustOfflineProcessor";
 import { FaustMonoScriptProcessorNode, FaustPolyScriptProcessorNode } from "./FaustScriptProcessorNode";
 import { FaustBaseWebAudioDsp, FaustMonoWebAudioDsp, FaustPolyWebAudioDsp, FaustWebAudioDspVoice, IFaustMonoWebAudioNode, IFaustPolyWebAudioNode, Soundfile, WasmAllocator } from "./FaustWebAudioDsp";
+import SoundfileReader from "./SoundfileReader";
+import FaustSensors from "./FaustSensors";
 import type { IFaustCompiler } from "./FaustCompiler";
 import type { FaustDspFactory, FaustUIDescriptor, FaustDspMeta, FFTUtils, LooseFaustDspFactory, AudioData } from "./types";
-import SoundfileReader from "./SoundfileReader";
+
 
 export interface GeneratorSupportingSoundfiles {
     /**
@@ -252,6 +254,7 @@ export class FaustMonoDspGenerator implements IFaustMonoDspGenerator {
         if (sp) {
             const instance = await FaustWasmInstantiator.createAsyncMonoDSPInstance(factory);
             const monoDsp = new FaustMonoWebAudioDsp(instance, context.sampleRate, sampleSize, bufferSize, factory.soundfiles);
+
             const sp = context.createScriptProcessor(bufferSize, monoDsp.getNumInputs(), monoDsp.getNumOutputs()) as FaustMonoScriptProcessorNode;
             Object.setPrototypeOf(sp, FaustMonoScriptProcessorNode.prototype);
             sp.init(monoDsp);
@@ -282,6 +285,8 @@ var ${Soundfile.name} = ${Soundfile.toString()}
 var Soundfile = ${Soundfile.name};
 var ${WasmAllocator.name} = ${WasmAllocator.toString()}
 var WasmAllocator = ${WasmAllocator.name};
+var ${FaustSensors.name} = ${FaustSensors.toString()}
+var FaustSensors = ${FaustSensors.name};
 // Put them in dependencies
 const dependencies = {
     FaustBaseWebAudioDsp,
@@ -302,7 +307,8 @@ const dependencies = {
                 }
             }
             // Create the AWN
-            const node = new FaustMonoAudioWorkletNode(context, processorName, factory, sampleSize)
+            const node = new FaustMonoAudioWorkletNode(context, processorName, factory, sampleSize);
+
             return node as SP extends true ? FaustMonoScriptProcessorNode : FaustMonoAudioWorkletNode;
         }
     }
@@ -345,6 +351,8 @@ var ${Soundfile.name} = ${Soundfile.toString()}
 var Soundfile = ${Soundfile.name};
 var ${WasmAllocator.name} = ${WasmAllocator.toString()}
 var WasmAllocator = ${WasmAllocator.name};
+var ${FaustSensors.name} = ${FaustSensors.toString()}
+var FaustSensors = ${FaustSensors.name};
 var FFTUtils = ${fftUtils.toString()}
 // Put them in dependencies
 const dependencies = {
@@ -578,6 +586,7 @@ process = adaptorIns(dsp_code.process) : dsp_code.effect : adaptorOuts;
             const instance = await FaustWasmInstantiator.createAsyncPolyDSPInstance(voiceFactory, mixerModule, voices, effectFactory || undefined);
             const soundfiles = { ...effectFactory?.soundfiles, ...voiceFactory.soundfiles };
             const polyDsp = new FaustPolyWebAudioDsp(instance, context.sampleRate, sampleSize, bufferSize, soundfiles);
+
             const sp = context.createScriptProcessor(bufferSize, polyDsp.getNumInputs(), polyDsp.getNumOutputs()) as FaustPolyScriptProcessorNode;
             Object.setPrototypeOf(sp, FaustPolyScriptProcessorNode.prototype);
             sp.init(polyDsp);
@@ -611,6 +620,8 @@ var ${Soundfile.name} = ${Soundfile.toString()}
 var Soundfile = ${Soundfile.name};
 var ${WasmAllocator.name} = ${WasmAllocator.toString()}
 var WasmAllocator = ${WasmAllocator.name};
+var ${FaustSensors.name} = ${FaustSensors.toString()}
+var FaustSensors = ${FaustSensors.name};
 // Put them in dependencies
 const dependencies = {
     FaustBaseWebAudioDsp,
@@ -632,6 +643,7 @@ const dependencies = {
             }
             // Create the AWN
             const node = new FaustPolyAudioWorkletNode(context, processorName, voiceFactory, mixerModule, voices, sampleSize, effectFactory || undefined);
+
             return node as SP extends true ? FaustPolyScriptProcessorNode : FaustPolyAudioWorkletNode;
         }
     }

package/src/FaustOfflineProcessor.ts

@@ -81,6 +81,16 @@ export class FaustOfflineProcessor<Poly extends boolean = false> {
 
     destroy() { this.fDSPCode.destroy(); }
 
+    get hasAccInput() { return this.fDSPCode.hasAccInput; }
+    propagateAcc(accelerationIncludingGravity: NonNullable<DeviceMotionEvent["accelerationIncludingGravity"]>) {
+        this.fDSPCode.propagateAcc(accelerationIncludingGravity);
+    }
+
+    get hasGyrInput() { return this.fDSPCode.hasGyrInput; }
+    propagateGyr(event: Pick<DeviceOrientationEvent, "alpha" | "beta" | "gamma">) {
+        this.fDSPCode.propagateGyr(event);
+    }
+
     /**
      * Render frames in an array.
      *

package/src/FaustScriptProcessorNode.ts

@@ -15,7 +15,7 @@ export class FaustScriptProcessorNode<Poly extends boolean = false> extends (glo
 
         this.fInputs = new Array(this.fDSPCode.getNumInputs());
         this.fOutputs = new Array(this.fDSPCode.getNumOutputs());
-
+    
         this.onaudioprocess = (e) => {
 
             // Read inputs
@@ -33,7 +33,57 @@ export class FaustScriptProcessorNode<Poly extends boolean = false> extends (glo
 
         this.start();
     }
+    
     // Public API
+
+    /** Setup accelerometer and gyroscope handlers */
+    async listenMotion() {
+        if (this.hasAccInput) {
+            const handleDeviceMotion = ({ accelerationIncludingGravity }: DeviceMotionEvent) => {
+                if (!accelerationIncludingGravity) return;
+                const { x, y, z } = accelerationIncludingGravity;
+                this.propagateAcc({ x, y, z });
+            };
+            if (window.DeviceMotionEvent) {
+                if (typeof (window.DeviceMotionEvent as any).requestPermission === "function") { // for iOS 13+
+                    try {
+                        const response = await (window.DeviceMotionEvent as any).requestPermission();
+                        if (response !== "granted") throw new Error("Unable to access the accelerometer.");
+                        window.addEventListener("devicemotion", handleDeviceMotion, true);
+                    } catch (error) {
+                        console.error(error);
+                    }
+                } else {
+                    window.addEventListener("devicemotion", handleDeviceMotion, true);
+                }
+            } else {
+                // Browser doesn't support DeviceMotionEvent
+                console.log("Cannot set the accelerometer handler.");
+            }
+        }
+        if (this.hasGyrInput) {
+            const handleDeviceOrientation = ({ alpha, beta, gamma }: DeviceOrientationEvent) => {
+                this.propagateGyr({ alpha, beta, gamma });
+            };
+            if (window.DeviceMotionEvent) {
+                if (typeof (window.DeviceOrientationEvent as any).requestPermission === "function") { // for iOS 13+
+                    try {
+                        const response = await (window.DeviceOrientationEvent as any).requestPermission();
+                        if (response !== "granted") throw new Error("Unable to access the gyroscope.");
+                        window.addEventListener("deviceorientation", handleDeviceOrientation, true);
+                    } catch (error) {
+                        console.error(error);
+                    }
+                } else {
+                    window.addEventListener("deviceorientation", handleDeviceOrientation, true);
+                }
+            } else {
+                // Browser doesn't support DeviceMotionEvent
+                console.log("Cannot set the gyroscope handler.");
+            }
+        }
+    }
+
     compute(input: Float32Array[], output: Float32Array[]) { return this.fDSPCode.compute(input, output); }
 
     setOutputParamHandler(handler: OutputParamHandler) { this.fDSPCode.setOutputParamHandler(handler); }
@@ -68,6 +118,16 @@ export class FaustScriptProcessorNode<Poly extends boolean = false> extends (glo
     stop() { this.fDSPCode.stop(); }
 
     destroy() { this.fDSPCode.destroy(); }
+
+    get hasAccInput() { return this.fDSPCode.hasAccInput; }
+    propagateAcc(accelerationIncludingGravity: NonNullable<DeviceMotionEvent["accelerationIncludingGravity"]>) {
+        this.fDSPCode.propagateAcc(accelerationIncludingGravity);
+    }
+
+    get hasGyrInput() { return this.fDSPCode.hasGyrInput; }
+    propagateGyr(event: Pick<DeviceOrientationEvent, "alpha" | "beta" | "gamma">) {
+        this.fDSPCode.propagateGyr(event);
+    }
 }
 
 export class FaustMonoScriptProcessorNode extends FaustScriptProcessorNode<false> implements IFaustMonoWebAudioDsp {