@woosh/meep-engine 3.14.3 → 3.14.4

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/shaders/chunk_particle_curve_animation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_particle_curve_animation.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/chunk_particle_curve_animation.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;GAgBG;AACH,6CAFU,SAAS,CAO0C;0BA1BnC,oCAAoC"}
+{"version":3,"file":"chunk_particle_curve_animation.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/chunk_particle_curve_animation.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;GAgBG;AACH,6CAFU,SAAS,CAS0C;0BA5BnC,oCAAoC"}

package/src/shade/renderer/particles/shaders/chunk_particle_curve_animation.js

@@ -21,9 +21,11 @@ const CURVE_TABLE = ANIMATION_DATABASE_SPEC.get("animation_curves");
  *
  * @type {CodeChunk}
  */
-export const chunk_particle_curve_animation = CodeChunk.from(/* wgsl */ `
+export const chunk_particle_curve_animation = CodeChunk.from(
+    /* language=wgsl */
+    `
 fn particle_vm_sample_curve(handle : u32, t : f32) -> f32 {
     let header = ${CURVE_TABLE.marshalling_method_read}(&particle_curve_database, handle);
     return animation_curve_evaluate(t, &particle_curve_database, header);
 }
-`, [CURVE_TABLE.chunk_read, chunk_animation_curve_evaluate]);
+`, [CURVE_TABLE.chunk_read, chunk_animation_curve_evaluate]);

package/src/shade/renderer/particles/shaders/chunk_particle_lighting.d.ts

@@ -1,9 +1,9 @@
 /**
- * Pluggable lighting hook for the billboard fragment shader. `particle_apply_lighting(color, world,
- * normal)` returns the lit colour; the default is a pass-through (unlit / emissive).
+ * Pluggable lighting hook for the billboard fragment shader. `particle_apply_lighting(color, world, normal)`
+ * returns the lit colour; the default is a pass-through (unlit / emissive).
  *
- * The production feature swaps this for a chunk that binds {@link
- * ../../deferred/SHADING_LIGHT_RESOURCE_GROUP.js} and calls `shade_standard_material_direct` + IBL —
+ * The production feature swaps this for a chunk that binds
+ * {@link ../../deferred/SHADING_LIGHT_RESOURCE_GROUP.js} and calls `shade_standard_material_direct` + IBL —
  * i.e. billboards reuse the exact same lighting path as opaque surfaces when an emitter opts in via
  * its `lighting` flag. Keeping it a hook means unlit emitters compile without pulling in the whole
  * clustered-lighting resource group.

package/src/shade/renderer/particles/shaders/chunk_particle_lighting.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_particle_lighting.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/chunk_particle_lighting.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,4CAFU,SAAS,CAMhB;0BAlBuB,oCAAoC"}
+{"version":3,"file":"chunk_particle_lighting.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/chunk_particle_lighting.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,4CAFU,SAAS,CAQhB;0BApBuB,oCAAoC"}

package/src/shade/renderer/particles/shaders/chunk_particle_lighting.js

@@ -1,18 +1,20 @@
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 
 /**
- * Pluggable lighting hook for the billboard fragment shader. `particle_apply_lighting(color, world,
- * normal)` returns the lit colour; the default is a pass-through (unlit / emissive).
+ * Pluggable lighting hook for the billboard fragment shader. `particle_apply_lighting(color, world, normal)`
+ * returns the lit colour; the default is a pass-through (unlit / emissive).
  *
- * The production feature swaps this for a chunk that binds {@link
- * ../../deferred/SHADING_LIGHT_RESOURCE_GROUP.js} and calls `shade_standard_material_direct` + IBL —
+ * The production feature swaps this for a chunk that binds
+ * {@link ../../deferred/SHADING_LIGHT_RESOURCE_GROUP.js} and calls `shade_standard_material_direct` + IBL —
  * i.e. billboards reuse the exact same lighting path as opaque surfaces when an emitter opts in via
  * its `lighting` flag. Keeping it a hook means unlit emitters compile without pulling in the whole
  * clustered-lighting resource group.
  *
  * @type {CodeChunk}
  */
-export const chunk_particle_lighting_unlit = CodeChunk.from(/* wgsl */ `
+export const chunk_particle_lighting_unlit = CodeChunk.from(
+    /* language=wgsl */
+    `
 fn particle_apply_lighting(color : vec4<f32>, world_position : vec3<f32>, normal : vec3<f32>) -> vec4<f32> {
     return color;
 }

package/src/shade/renderer/particles/shaders/chunk_particle_render_math.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_particle_render_math.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/chunk_particle_render_math.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH,yCAFU,SAAS,CAyFhB;0BAzGuB,oCAAoC"}
+{"version":3,"file":"chunk_particle_render_math.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/chunk_particle_render_math.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH,yCAFU,SAAS,CA2FhB;0BA3GuB,oCAAoC"}

package/src/shade/renderer/particles/shaders/chunk_particle_render_math.js

@@ -16,7 +16,9 @@ import { EMITTER_BLEND, EMITTER_PROJECTION } from "../data/PARTICLE_EMITTER_LAYO
  *
  * @type {CodeChunk}
  */
-export const chunk_particle_render_math = CodeChunk.from(/* wgsl */ `
+export const chunk_particle_render_math = CodeChunk.from(
+    /* language=wgsl */
+    `
 const PARTICLE_PROJ_BILLBOARD : u32 = ${EMITTER_PROJECTION.BILLBOARD}u;
 const PARTICLE_PROJ_STRETCHED : u32 = ${EMITTER_PROJECTION.STRETCHED}u;
 const PARTICLE_PROJ_HORIZONTAL : u32 = ${EMITTER_PROJECTION.HORIZONTAL}u;

package/src/shade/renderer/particles/shaders/shader_particle_emit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_emit.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_emit.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;GAYG;AAEH,2CAHU,aAAa,CAGwB;AA6F/C,iDAIG;8BAhI2B,+BAA+B"}
+{"version":3,"file":"shader_particle_emit.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_emit.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;GAYG;AAEH,2CAHU,aAAa,CAGwB;AA+F/C,iDAIG;8BAlI2B,+BAA+B"}

package/src/shade/renderer/particles/shaders/shader_particle_emit.js

@@ -64,7 +64,9 @@ resources.createGroup()
     .addStorageBuffer("alive_out", WebGPUArray.u32, true)
     .addStorageBuffer("dead", WebGPUArray.u32, true)
     .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true);
-const body = CodeChunk.from(/* wgsl */ `
+const body = CodeChunk.from(
+    /* language=wgsl */
+    `
 const PARTICLE_RECORD_WORDS : u32 = ${PARTICLE_RECORD_WORD_COUNT}u;
 const PARTICLE_USER_WORD_START : u32 = ${PARTICLE_RECORD_USER_WORD_START}u;
 const PARTICLE_HEADER_EMITTER : u32 = ${PARTICLE_RECORD_HEADER_EMITTER}u;

package/src/shade/renderer/particles/shaders/shader_particle_finalize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_finalize.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_finalize.js"],"names":[],"mappings":"AA4BA,2DAWG;AAaH,2DAwBG;;8BA1E2B,+BAA+B;iDAIZ,+BAA+B"}
+{"version":3,"file":"shader_particle_finalize.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_finalize.js"],"names":[],"mappings":"AA4BA,2DAYG;AAaH,2DA0BG;;8BA7E2B,+BAA+B;iDAIZ,+BAA+B"}

package/src/shade/renderer/particles/shaders/shader_particle_finalize.js

@@ -29,7 +29,8 @@ reset_resources.createGroup().addStorageBuffer("counters", WebGPUArray.from(atom
 export const shader_particle_reset_counters = ComputeShader.from({
     label: "Particle Reset Counters",
     resources: reset_resources,
-    body: CodeChunk.from(/* wgsl */ `
+    body: CodeChunk.from(
+        /* language=wgsl */ `
 @compute @workgroup_size(1, 1, 1)
 fn main() {
     atomicStore(&counters[${PARTICLE_COUNTER.ALIVE}u], 0u);
@@ -53,7 +54,9 @@ indirect_resources.createGroup()
 export const shader_particle_build_indirect = ComputeShader.from({
     label: "Particle Build Indirect",
     resources: indirect_resources,
-    body: CodeChunk.from(/* wgsl */ `
+    body: CodeChunk.from(
+        /* language=wgsl */
+        `
 @compute @workgroup_size(1, 1, 1)
 fn main() {
     let alive = atomicLoad(&counters[${PARTICLE_COUNTER.ALIVE}u]);

package/src/shade/renderer/particles/shaders/shader_particle_render.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_render.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_render.js"],"names":[],"mappings":"AA6JA;;;;;;;;;GASG;AACH;IAP4B,YAAY,GAA7B,MAAM;IACgB,YAAY,GAAlC,MAAM,GAAC,IAAI;IAEkB,aAAa;IAExC,wBAAwB,CAqBpC;;;;;;;;;;;;;;;;AAED,yFAAyF;AACzF,uEAAsD;yCA7Lb,iEAAiE;4CAO9D,sDAAsD"}
+{"version":3,"file":"shader_particle_render.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_render.js"],"names":[],"mappings":"AA8JA;;;;;;;;;GASG;AACH;IAP4B,YAAY,GAA7B,MAAM;IACgB,YAAY,GAAlC,MAAM,GAAC,IAAI;IAEkB,aAAa;IAExC,wBAAwB,CA2BpC;;;;;;;;;;;;;;;;AAED,yFAAyF;AACzF,uEAAsD;yCApMb,iEAAiE;4CAO9D,sDAAsD"}

package/src/shade/renderer/particles/shaders/shader_particle_render.js

@@ -52,7 +52,8 @@ resources.createGroup()
     // Only textureLoad-ed (soft depth), so it can be unfilterable — matches an r32float scene depth.
     .addTexture("scene_depth", "unfilterable-float");
 
-const body = CodeChunk.from(/* wgsl */ `
+const body = CodeChunk.from(
+    /* language=wgsl */ `
 const PARTICLE_RECORD_WORDS : u32 = ${PARTICLE_RECORD_WORD_COUNT}u;
 const PARTICLE_HEADER_EMITTER : u32 = ${PARTICLE_RECORD_HEADER_EMITTER}u;
 const PARTICLE_ATTRIBUTE_ABSENT : u32 = ${EMITTER_ATTRIBUTE_ABSENT}u;
@@ -165,7 +166,12 @@ const descriptor = ShaderDescriptor.from({ label: "Particle Billboard", body, re
  *   reverse-Z scenes (the engine convention), "less"/"less-equal" for a standard-Z scene
  * @returns {RenderPipelineDescriptor}
  */
-export function create_particle_billboard_pipeline({ color_format = "rgba16float", depth_format = "depth32float", depth_compare = "greater" } = {}) {
+export function create_particle_billboard_pipeline({
+                                                       color_format = "rgba16float",
+                                                       depth_format = "depth32float",
+                                                       depth_compare = "greater"
+} = {}) {
+
     const code = descriptor.source;
 
     return RenderPipelineDescriptor.from({
@@ -184,6 +190,7 @@ export function create_particle_billboard_pipeline({ color_format = "rgba16float
             : DepthStencilState.from({ format: depth_format, depthWriteEnabled: false, depthCompare: depth_compare }),
         primitive: { topology: "triangle-list", cullMode: "none" },
     });
+
 }
 
 /** The billboard shader's resource set (for building bind groups + the draw command). */

package/src/shade/renderer/particles/shaders/shader_particle_simulate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_simulate.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_simulate.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,+CAHU,aAAa,CAG4B;AAqEnD,qDAIG;8BA3G2B,+BAA+B"}
+{"version":3,"file":"shader_particle_simulate.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_simulate.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,+CAHU,aAAa,CAG4B;AAuEnD,qDAIG;8BA7G2B,+BAA+B"}

package/src/shade/renderer/particles/shaders/shader_particle_simulate.js

@@ -62,7 +62,9 @@ resources.createGroup()
     .addStorageBuffer("alive_out", WebGPUArray.u32, true)
     .addStorageBuffer("dead", WebGPUArray.u32, true)
     .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true);
-const body = CodeChunk.from(/* wgsl */ `
+
+
+const body = CodeChunk.from(/* language=wgsl */ `
 const PARTICLE_RECORD_WORDS : u32 = ${PARTICLE_RECORD_WORD_COUNT}u;
 const PARTICLE_HEADER_EMITTER : u32 = ${PARTICLE_RECORD_HEADER_EMITTER}u;
 const PARTICLE_INSTRUCTION_WORDS : u32 = ${PARTICLE_VM_INSTRUCTION_WORDS}u;

package/src/shade/renderer/particles/prototypeParticleSystem.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=prototypeParticleSystem.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"prototypeParticleSystem.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/prototypeParticleSystem.js"],"names":[],"mappings":""}