@woosh/meep-engine 3.14.3 → 3.14.5

package/src/shade/renderer/particles/isa/InstructionStream.js

@@ -0,0 +1,162 @@
+import { assert } from "../../../../core/assert.js";
+import { PARTICLE_VM_INSTRUCTION_WORDS, PARTICLE_VM_REGISTER_COUNT } from "../ParticleConstants.js";
+import { VM_ISA, VM_OP } from "./ParticleVMISA.js";
+
+/**
+ * A single VM instruction stream (a SPAWN or UPDATE section). Instructions are appended in order;
+ * {@link toWords} flattens them to the packed `Uint32Array` the program consumes.
+ *
+ * Register usage is tracked as instructions are emitted so the assembler can report how many
+ * registers the program touches without a separate pass.
+ */
+export class InstructionStream {
+    /** @type {number[][]} */
+    instructions = [];
+    /** @type {number} highest register index referenced, plus one */
+    register_count = 0;
+
+    #use_register(index) {
+        assert.isNonNegativeInteger(index, "register index");
+        assert.lessThan(index, PARTICLE_VM_REGISTER_COUNT, "register index exceeds the VM register file");
+        if (index + 1 > this.register_count) {
+            this.register_count = index + 1;
+        }
+    }
+
+    /**
+     * Emit a raw instruction. Validates the opcode and tracks register usage. Prefer the typed
+     * helpers below where they exist — they document the non-obvious operand packing.
+     *
+     * @param {number} op
+     * @param {number} [dst]
+     * @param {number} [s0]
+     * @param {number} [s1]
+     * @param {number} [s2]
+     * @returns {InstructionStream} this, for chaining
+     */
+    emit(op, dst = 0, s0 = 0, s1 = 0, s2 = 0) {
+        const meta = VM_ISA.get(op);
+        assert.defined(meta, `unknown opcode ${op}`);
+
+        if (meta.dst) {
+            // For value-producing ops this is the destination; for STORE_ATTR/KILL it is a source
+            // register living in the dst slot. Either way it must be a valid register.
+            this.#use_register(dst);
+        }
+
+        const operands = meta.operands;
+        const slots = [s0, s1, s2];
+        for (let i = 0; i < 3; i++) {
+            if (operands[i] === "reg") {
+                this.#use_register(slots[i]);
+            }
+        }
+
+        this.instructions.push([op, dst >>> 0, s0 >>> 0, s1 >>> 0, s2 >>> 0]);
+        return this;
+    }
+
+    // --- typed helpers (packing that isn't obvious from `emit`) ---
+
+    /**
+     * @param {number} dst
+     * @param {number} src
+     * @returns {InstructionStream}
+     */
+    mov(dst, src) {
+        return this.emit(VM_OP.MOV, dst, src);
+    }
+
+    /**
+     * @param {number} dst
+     * @param {number} constant_index
+     * @returns {InstructionStream}
+     */
+    loadConst(dst, constant_index) {
+        return this.emit(VM_OP.LOAD_CONST, dst, constant_index);
+    }
+
+    /**
+     * @param {number} dst
+     * @param {number} word_offset
+     * @param {number} component_count
+     * @returns {InstructionStream}
+     */
+    loadAttr(dst, word_offset, component_count) {
+        return this.emit(VM_OP.LOAD_ATTR, dst, word_offset, component_count);
+    }
+
+    /**
+     * @param {number} src_register
+     * @param {number} word_offset
+     * @param {number} component_count
+     * @returns {InstructionStream}
+     */
+    storeAttr(src_register, word_offset, component_count) {
+        return this.emit(VM_OP.STORE_ATTR, src_register, word_offset, component_count);
+    }
+
+    /**
+     * @param {number} dst
+     * @param {number} builtin_id
+     * @returns {InstructionStream}
+     */
+    loadBuiltin(dst, builtin_id) {
+        return this.emit(VM_OP.LOAD_BUILTIN, dst, builtin_id);
+    }
+
+    /**
+     * @param {number} condition_register
+     * @returns {InstructionStream}
+     */
+    kill(condition_register) {
+        return this.emit(VM_OP.KILL, condition_register);
+    }
+
+    /**
+     * @param {number} dst
+     * @param {number} mode
+     * @returns {InstructionStream}
+     */
+    random(dst, mode) {
+        return this.emit(VM_OP.RANDOM, dst, mode);
+    }
+
+    /**
+     * @param {number} dst
+     * @param {number} curve_handle
+     * @param {number} t_register
+     * @returns {InstructionStream}
+     */
+    curve(dst, curve_handle, t_register) {
+        return this.emit(VM_OP.CURVE, dst, curve_handle, t_register);
+    }
+
+    /**
+     * @returns {InstructionStream}
+     */
+    halt() {
+        return this.emit(VM_OP.HALT);
+    }
+
+    /**
+     * @returns {number}
+     */
+    get instruction_count() {
+        return this.instructions.length;
+    }
+
+    /**
+     * @returns {Uint32Array}
+     */
+    toWords() {
+        const instructions = this.instructions;
+        const words = new Uint32Array(instructions.length * PARTICLE_VM_INSTRUCTION_WORDS);
+
+        for (let i = 0; i < instructions.length; i++) {
+            words.set(instructions[i], i * PARTICLE_VM_INSTRUCTION_WORDS);
+        }
+
+        return words;
+    }
+}

package/src/shade/renderer/particles/isa/ParticleAssembler.d.ts

@@ -1,51 +1,3 @@
-/**
- * A single VM instruction stream (a SPAWN or UPDATE section). Instructions are appended in order;
- * {@link toWords} flattens them to the packed `Uint32Array` the program consumes.
- *
- * Register usage is tracked as instructions are emitted so the assembler can report how many
- * registers the program touches without a separate pass.
- */
-export class InstructionStream {
-    /** @type {number[][]} */
-    instructions: number[][];
-    /** @type {number} highest register index referenced, plus one */
-    register_count: number;
-    /**
-     * Emit a raw instruction. Validates the opcode and tracks register usage. Prefer the typed
-     * helpers below where they exist — they document the non-obvious operand packing.
-     *
-     * @param {number} op
-     * @param {number} [dst]
-     * @param {number} [s0]
-     * @param {number} [s1]
-     * @param {number} [s2]
-     * @returns {InstructionStream} this, for chaining
-     */
-    emit(op: number, dst?: number, s0?: number, s1?: number, s2?: number): InstructionStream;
-    /** @param {number} dst @param {number} src @returns {InstructionStream} */
-    mov(dst: number, src: number): InstructionStream;
-    /** @param {number} dst @param {number} constant_index @returns {InstructionStream} */
-    loadConst(dst: number, constant_index: number): InstructionStream;
-    /** @param {number} dst @param {number} word_offset @param {number} component_count @returns {InstructionStream} */
-    loadAttr(dst: number, word_offset: number, component_count: number): InstructionStream;
-    /** @param {number} src_register @param {number} word_offset @param {number} component_count @returns {InstructionStream} */
-    storeAttr(src_register: number, word_offset: number, component_count: number): InstructionStream;
-    /** @param {number} dst @param {number} builtin_id @returns {InstructionStream} */
-    loadBuiltin(dst: number, builtin_id: number): InstructionStream;
-    /** @param {number} condition_register @returns {InstructionStream} */
-    kill(condition_register: number): InstructionStream;
-    /** @param {number} dst @param {number} mode @returns {InstructionStream} */
-    random(dst: number, mode: number): InstructionStream;
-    /** @param {number} dst @param {number} curve_handle @param {number} t_register @returns {InstructionStream} */
-    curve(dst: number, curve_handle: number, t_register: number): InstructionStream;
-    /** @returns {InstructionStream} */
-    halt(): InstructionStream;
-    /** @returns {number} */
-    get instruction_count(): number;
-    /** @returns {Uint32Array} */
-    toWords(): Uint32Array;
-    #private;
-}
 /**
  * Convenience builder for a {@link ParticleProgram}: two instruction streams sharing one constant
  * pool. Used directly by tests and internally by the node-graph compiler.
@@ -72,5 +24,6 @@ export class ParticleAssembler {
      */
     build(): ParticleProgram;
 }
+import { InstructionStream } from "./InstructionStream.js";
 import { ParticleProgram } from "./ParticleProgram.js";
 //# sourceMappingURL=ParticleAssembler.d.ts.map

package/src/shade/renderer/particles/isa/ParticleAssembler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleAssembler.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/isa/ParticleAssembler.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH;IAEQ,yBAAyB;IACzB,cADW,MAAM,EAAE,EAAE,CACC;IACtB,iEAAiE;IACjE,gBADW,MAAM,CACM;IAW3B;;;;;;;;;;OAUG;IACH,SAPW,MAAM,QACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,GACJ,iBAAiB,CAsB7B;IAID,2EAA2E;IAC3E,SADY,MAAM,OAAc,MAAM,GAAgB,iBAAiB,CACf;IAExD,sFAAsF;IACtF,eADY,MAAM,kBAAc,MAAM,GAA2B,iBAAiB,CACS;IAE3F,mHAAmH;IACnH,cADY,MAAM,eAAc,MAAM,mBAAsB,MAAM,GAA4B,iBAAiB,CACM;IAErH,4HAA4H;IAC5H,wBADY,MAAM,eAAuB,MAAM,mBAAsB,MAAM,GAA4B,iBAAiB,CACiB;IAEzI,kFAAkF;IAClF,iBADY,MAAM,cAAc,MAAM,GAAuB,iBAAiB,CACS;IAEvF,sEAAsE;IACtE,yBADY,MAAM,GAA+B,iBAAiB,CACY;IAE9E,4EAA4E;IAC5E,YADY,MAAM,QAAc,MAAM,GAAiB,iBAAiB,CACR;IAEhE,+GAA+G;IAC/G,WADY,MAAM,gBAAc,MAAM,cAAuB,MAAM,GAAuB,iBAAiB,CACL;IAEtG,mCAAmC;IACnC,QADc,iBAAiB,CACS;IAExC,wBAAwB;IACxB,gCAEC;IAED,6BAA6B;IAC7B,WADc,WAAW,CAOxB;;CACJ;AAED;;;GAGG;AACH;IAEQ,gCAAgC;IAChC,OADW,iBAAiB,CACQ;IACpC,gCAAgC;IAChC,QADW,iBAAiB,CACS;IACrC,8DAA8D;IAC9D,WADW,MAAM,EAAE,CACA;IAGvB;;;;;;;;OAQG;IACH,YANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAYlB;IAED;;OAEG;IACH,SAFa,eAAe,CAS3B;CACJ;gCArJ+B,sBAAsB"}
+{"version":3,"file":"ParticleAssembler.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/isa/ParticleAssembler.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH;IACI,gCAAgC;IAChC,OADW,iBAAiB,CACI;IAEhC,gCAAgC;IAChC,QADW,iBAAiB,CACK;IAEjC,8DAA8D;IAC9D,WADW,MAAM,EAAE,CACJ;IAEf;;;;;;;;OAQG;IACH,YANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAyBlB;IAED;;OAEG;IACH,SAFa,eAAe,CAS3B;CACJ;kCA9DiC,wBAAwB;gCAC1B,sBAAsB"}

package/src/shade/renderer/particles/isa/ParticleAssembler.js

@@ -1,121 +1,19 @@
-import { assert } from "../../../../core/assert.js";
-import { PARTICLE_VM_INSTRUCTION_WORDS, PARTICLE_VM_REGISTER_COUNT } from "../ParticleConstants.js";
+import { InstructionStream } from "./InstructionStream.js";
 import { ParticleProgram } from "./ParticleProgram.js";
-import { VM_ISA, VM_OP } from "./ParticleVMISA.js";
-
-/**
- * A single VM instruction stream (a SPAWN or UPDATE section). Instructions are appended in order;
- * {@link toWords} flattens them to the packed `Uint32Array` the program consumes.
- *
- * Register usage is tracked as instructions are emitted so the assembler can report how many
- * registers the program touches without a separate pass.
- */
-export class InstructionStream {
-    constructor() {
-        /** @type {number[][]} */
-        this.instructions = [];
-        /** @type {number} highest register index referenced, plus one */
-        this.register_count = 0;
-    }
-
-    #use_register(index) {
-        assert.isNonNegativeInteger(index, "register index");
-        assert.lessThan(index, PARTICLE_VM_REGISTER_COUNT, "register index exceeds the VM register file");
-        if (index + 1 > this.register_count) {
-            this.register_count = index + 1;
-        }
-    }
-
-    /**
-     * Emit a raw instruction. Validates the opcode and tracks register usage. Prefer the typed
-     * helpers below where they exist — they document the non-obvious operand packing.
-     *
-     * @param {number} op
-     * @param {number} [dst]
-     * @param {number} [s0]
-     * @param {number} [s1]
-     * @param {number} [s2]
-     * @returns {InstructionStream} this, for chaining
-     */
-    emit(op, dst = 0, s0 = 0, s1 = 0, s2 = 0) {
-        const meta = VM_ISA.get(op);
-        assert.defined(meta, `unknown opcode ${op}`);
-
-        if (meta.dst) {
-            // For value-producing ops this is the destination; for STORE_ATTR/KILL it is a source
-            // register living in the dst slot. Either way it must be a valid register.
-            this.#use_register(dst);
-        }
-
-        const operands = meta.operands;
-        const slots = [s0, s1, s2];
-        for (let i = 0; i < 3; i++) {
-            if (operands[i] === "reg") {
-                this.#use_register(slots[i]);
-            }
-        }
-
-        this.instructions.push([op, dst >>> 0, s0 >>> 0, s1 >>> 0, s2 >>> 0]);
-        return this;
-    }
-
-    // --- typed helpers (packing that isn't obvious from `emit`) ---
-
-    /** @param {number} dst @param {number} src @returns {InstructionStream} */
-    mov(dst, src) { return this.emit(VM_OP.MOV, dst, src); }
-
-    /** @param {number} dst @param {number} constant_index @returns {InstructionStream} */
-    loadConst(dst, constant_index) { return this.emit(VM_OP.LOAD_CONST, dst, constant_index); }
-
-    /** @param {number} dst @param {number} word_offset @param {number} component_count @returns {InstructionStream} */
-    loadAttr(dst, word_offset, component_count) { return this.emit(VM_OP.LOAD_ATTR, dst, word_offset, component_count); }
-
-    /** @param {number} src_register @param {number} word_offset @param {number} component_count @returns {InstructionStream} */
-    storeAttr(src_register, word_offset, component_count) { return this.emit(VM_OP.STORE_ATTR, src_register, word_offset, component_count); }
-
-    /** @param {number} dst @param {number} builtin_id @returns {InstructionStream} */
-    loadBuiltin(dst, builtin_id) { return this.emit(VM_OP.LOAD_BUILTIN, dst, builtin_id); }
-
-    /** @param {number} condition_register @returns {InstructionStream} */
-    kill(condition_register) { return this.emit(VM_OP.KILL, condition_register); }
-
-    /** @param {number} dst @param {number} mode @returns {InstructionStream} */
-    random(dst, mode) { return this.emit(VM_OP.RANDOM, dst, mode); }
-
-    /** @param {number} dst @param {number} curve_handle @param {number} t_register @returns {InstructionStream} */
-    curve(dst, curve_handle, t_register) { return this.emit(VM_OP.CURVE, dst, curve_handle, t_register); }
-
-    /** @returns {InstructionStream} */
-    halt() { return this.emit(VM_OP.HALT); }
-
-    /** @returns {number} */
-    get instruction_count() {
-        return this.instructions.length;
-    }
-
-    /** @returns {Uint32Array} */
-    toWords() {
-        const words = new Uint32Array(this.instructions.length * PARTICLE_VM_INSTRUCTION_WORDS);
-        for (let i = 0; i < this.instructions.length; i++) {
-            words.set(this.instructions[i], i * PARTICLE_VM_INSTRUCTION_WORDS);
-        }
-        return words;
-    }
-}
 
 /**
  * Convenience builder for a {@link ParticleProgram}: two instruction streams sharing one constant
  * pool. Used directly by tests and internally by the node-graph compiler.
  */
 export class ParticleAssembler {
-    constructor() {
-        /** @type {InstructionStream} */
-        this.spawn = new InstructionStream();
-        /** @type {InstructionStream} */
-        this.update = new InstructionStream();
-        /** @type {number[]} flat constant pool, 4 floats per entry */
-        this.constants = [];
-    }
+    /** @type {InstructionStream} */
+    spawn = new InstructionStream();
+
+    /** @type {InstructionStream} */
+    update = new InstructionStream();
+
+    /** @type {number[]} flat constant pool, 4 floats per entry */
+    constants = [];
 
     /**
      * Intern a `vec4f` constant into the shared pool, deduplicating exact matches so identical
@@ -127,14 +25,27 @@ export class ParticleAssembler {
      * @returns {number} constant-pool index
      */
     constant(x, y = 0, z = 0, w = 0) {
-        const count = this.constants.length / 4;
+        const data = this.constants;
+        const count = data.length / 4;
+
         for (let i = 0; i < count; i++) {
             const base = i * 4;
-            if (this.constants[base] === x && this.constants[base + 1] === y && this.constants[base + 2] === z && this.constants[base + 3] === w) {
+
+            if (
+                data[base] === x
+                && data[base + 1] === y
+                && data[base + 2] === z
+                && data[base + 3] === w
+            ) {
+
                 return i;
+
             }
+
         }
-        this.constants.push(x, y, z, w);
+
+        data.push(x, y, z, w);
+
         return count;
     }
 

package/src/shade/renderer/particles/particle_prototype.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"particle_prototype.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/particle_prototype.js"],"names":[],"mappings":"AAMA;;;;;;;;;;GAUG;AAEH;;;;;;;;;GASG;AACH;IAL4B,UAAU,GAA3B,MAAM;IACW,WAAW,GAA5B,MAAM;IACW,eAAe,GAAhC,MAAM;;YACK,cAAc;YAAU,MAAM;aAAW,MAAM;EA2GpE;AAED;;;;GAIG;AACH;YAFsB,cAAc;YAAU,MAAM;aAAW,MAAM;EAcpE;AAED;;;;;;;;;;;;;;;GAeG;AACH,0CALW,OAAO,wBAAwB,EAAE,iBAAiB;IAEjC,IAAI,GAArB,MAAM;;UACG,MAAM;WAAS,MAAM;EAWxC;+BAhL8B,4BAA4B"}
+{"version":3,"file":"particle_prototype.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/particle_prototype.js"],"names":[],"mappings":"AAOA;;;;;;;;;;GAUG;AAEH;;;;;;;;;GASG;AACH;IAL4B,UAAU,GAA3B,MAAM;IACW,WAAW,GAA5B,MAAM;IACW,eAAe,GAAhC,MAAM;;YACK,cAAc;YAAU,MAAM;aAAW,MAAM;EA2GpE;AAED;;;;GAIG;AACH;YAFsB,cAAc;YAAU,MAAM;aAAW,MAAM;EAcpE;AAED;;;;;;;;;;;;;;;GAeG;AACH,0CALW,OAAO,wBAAwB,EAAE,iBAAiB;IAEjC,IAAI,GAArB,MAAM;;UACG,MAAM;WAAS,MAAM;EAWxC;+BAhL8B,4BAA4B"}