@woosh/meep-engine 3.2.0 → 3.4.0

package/src/shade/wgsl/emulator/WGSLJavaScriptCompiler.js

@@ -324,6 +324,46 @@ function literalToJs(text) {
     return t.replace(/[uifh]$/, '');
 }
 
+/**
+ * The tracked type of a literal token, as far as its own spelling settles it.
+ *
+ * Only an explicit suffix is honoured. A bare `2043` is WGSL's AbstractInt, which takes its
+ * concrete type from context this compiler does not track, so it stays unknown rather than being
+ * guessed at.
+ *
+ * The suffix matters because operator selection reads these types. `index / 2043u` is truncating
+ * integer division in WGSL and plain division in JavaScript, and the two differ for every pair
+ * where the divisor does not divide the dividend — which is what a paged table's
+ * `index / elements_per_page` is. Left untyped, the generated code returned a fractional page
+ * index, indexed the page-address table with it, and read `undefined` back as zero: every record
+ * past the first page slot came out of the emulator zero-filled, with nothing to say it had.
+ *
+ * @param {string} text
+ * @returns {WgslType}
+ */
+function literalType(text) {
+    const t = text.trim();
+
+    if (t === 'true' || t === 'false') {
+        return { kind: 'primitive', name: 'bool' };
+    }
+
+    if (/[ui]$/.test(t)) {
+        return { kind: 'primitive', name: t.endsWith('u') ? 'u32' : 'i32' };
+    }
+
+    // `f`/`h` are only suffixes on a decimal-format literal; on a hex int they are digits.
+    if (!/^0[xX]/.test(t) && /[fh]$/.test(t)) {
+        return { kind: 'primitive', name: t.endsWith('f') ? 'f32' : 'f16' };
+    }
+
+    if (/[.eE]/.test(t) && !/^0[xX]/.test(t)) {
+        return { kind: 'primitive', name: 'f32' };
+    }
+
+    return T_UNKNOWN;
+}
+
 // =========================================================================
 // Operator handling
 // =========================================================================
@@ -1127,6 +1167,10 @@ function emitWriteStatement(lhs_compiled, rhs_code) {
     if (lhs_compiled.code.startsWith('wgsl.mat_col(') && lhs_compiled.code.endsWith(')')) {
         return `${lhs_compiled.code}.set(${rhs_code});`;
     }
+    // `*p = v` has to reach the caller's object; assigning would only rebind the parameter.
+    if (lhs_compiled.through_pointer === true) {
+        return `${lhs_compiled.code} = wgsl.store_ptr(${lhs_compiled.code}, ${rhs_code});`;
+    }
     return `${lhs_compiled.code} = ${rhs_code};`;
 }
 
@@ -1277,10 +1321,16 @@ function emitForUpdateInline(c, node) {
             const lhs_compiled = compileLhs(c, lhs);
             const rhs_compiled = compileExpression(c, expr);
             if (op_text === '=' || op_text === '') {
+                if (lhs_compiled.through_pointer === true) {
+                    return `${lhs_compiled.code} = wgsl.store_ptr(${lhs_compiled.code}, ${rhs_compiled.code})`;
+                }
                 return `${lhs_compiled.code} = ${rhs_compiled.code}`;
             }
             const arith = { '+=': 'add', '-=': 'sub', '*=': 'mul', '/=': 'div', '%=': 'rem' };
             if (arith.hasOwnProperty(op_text)) {
+                if (lhs_compiled.through_pointer === true) {
+                    return `${lhs_compiled.code} = wgsl.store_ptr(${lhs_compiled.code}, wgsl.${arith[op_text]}(${lhs_compiled.code}, ${rhs_compiled.code}))`;
+                }
                 return `${lhs_compiled.code} = wgsl.${arith[op_text]}(${lhs_compiled.code}, ${rhs_compiled.code})`;
             }
             return `${lhs_compiled.code} ${op_text} ${rhs_compiled.code}`;
@@ -1503,7 +1553,7 @@ function compileExpression(c, node) {
 
     // Primary subkinds
     if (u.type === 'literal' || u.type === 'int_literal' || u.type === 'float_literal' || u.type === 'bool_literal') {
-        return { code: literalToJs(u.text), type: T_UNKNOWN };
+        return { code: literalToJs(u.text), type: literalType(u.text) };
     }
     if (u.type === 'paren_expression') {
         const inner = namedChildByType(u, 'expression');
@@ -2108,11 +2158,25 @@ function compileLhs(c, node) {
     // Pointer deref / address-of: `*lhs` / `&lhs`. The emulator models pointers as values, so
     // both collapse to the operand's value. The grammar puts the `*` / `&` as an unnamed leading
     // token with a nested `lhs_expression` named child.
+    //
+    // A whole-value store through a deref (`*p = v`, with nothing selected out of it) is flagged
+    // so {@link emitWriteStatement} writes through the reference rather than rebinding the local
+    // — see `wgsl.store_ptr`. A store into part of the pointee (`(*p).x`, `(*p)[i]`) already
+    // lands on the shared object and needs no such treatment.
     const prefix = textBeforeFirstNamed(node).trim();
     if (prefix === '*' || prefix === '&') {
         const nested_lhs = namedChildByType(node, 'lhs_expression');
         if (nested_lhs !== null) {
-            return compileLhs(c, nested_lhs);
+            const inner = compileLhs(c, nested_lhs);
+
+            const selects_part = node.namedChildren.some(
+                child => child.type === 'component_or_swizzle_specifier'
+            );
+
+            return {
+                ...inner,
+                through_pointer: prefix === '*' && !selects_part,
+            };
         }
     }
 

package/src/shade/wgsl/emulator/WGSLLanguageCore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":"AA2OA;;;;;;;;;;;;GAYG;AACH,+BAFU,MAAM,CA+sBd"}
+{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":"AA2OA;;;;;;;;;;;;GAYG;AACH,+BAFU,MAAM,CAkyBd"}

package/src/shade/wgsl/emulator/WGSLLanguageCore.js

@@ -337,6 +337,47 @@ export const WGSLLanguageCore = {
         return m.subarray(i * rows, (i + 1) * rows);
     },
 
+    /**
+     * Store a whole value through a pointer: WGSL's `*p = value`. Returns what the pointer variable
+     * should now hold, which the caller assigns back.
+     *
+     * Pointers are modelled as the pointee itself, so `*p = value` used to compile to a plain
+     * assignment to the parameter binding — which rebinds the callee's local and leaves the
+     * caller's object untouched. Every shader returning a result through an out-parameter then read
+     * back whatever it had initialised the variable to, silently and with nothing raised:
+     * `ray_triangle_compute_intersection_barycentric` reported hits at a distance of zero, which is
+     * a hit the traversal keeps and shades.
+     *
+     * Vectors, matrices and structs are objects, so the store goes through the reference and the
+     * caller sees it. **A pointer to a scalar still cannot**: a JavaScript number has no identity
+     * to write through, so the rebind is all there is, and a caller passing `&some_f32` sees its
+     * variable unchanged. Within the callee the value is right — `*p` reads back what `*p = …`
+     * wrote — so the in-out scalar accumulators in `sample_discrete_wrs_*` behave, and only a
+     * result handed *out* through a scalar pointer is lost. Widen such an out-parameter to a
+     * vector or a struct, or return it, if a test needs to see it.
+     *
+     * @param {Float32Array|Float16Array|Uint32Array|Int32Array|Array|object|number|boolean} target
+     * @param {ArrayLike<number>|object|number|boolean} value
+     * @returns {*} the value the pointer variable should be rebound to
+     */
+    store_ptr(target, value) {
+        if (ArrayBuffer.isView(target) || Array.isArray(target)) {
+            for (let i = 0; i < target.length; i++) {
+                target[i] = value[i];
+            }
+
+            return target;
+        }
+
+        if (target !== null && typeof target === 'object') {
+            Object.assign(target, value);
+
+            return target;
+        }
+
+        return value;
+    },
+
     /**
      * Determinant of a square matrix stored as a flat column-major typed array.
      * Supports the WGSL square-matrix sizes: 2x2, 3x3, 4x4.
@@ -416,6 +457,48 @@ export const WGSLLanguageCore = {
         });
     },
 
+    // Bit counting (WGSL §17.9). Component-wise over vectors. All of these read their operand as
+    // 32 bits regardless of whether the WGSL type was u32 or i32 — which is what the spec says and
+    // what makes `countLeadingZeros` the exact counterpart of JS's `Math.clz32`.
+
+    /** `countLeadingZeros(e)` — number of consecutive zero bits above the most significant set bit; 32 for 0. */
+    countLeadingZeros: (e) => unop(e, x => Math.clz32(x)),
+
+    /** `countTrailingZeros(e)` — number of consecutive zero bits below the least significant set bit; 32 for 0. */
+    countTrailingZeros: (e) => unop(e, x => (x === 0 ? 32 : 31 - Math.clz32(x & -x))),
+
+    /** `countOneBits(e)` — population count. */
+    countOneBits: (e) => unop(e, x => {
+        let bits = x >>> 0;
+        let count = 0;
+
+        while (bits !== 0) {
+            bits &= bits - 1;
+            count += 1;
+        }
+
+        return count;
+    }),
+
+    /** `firstLeadingBit(e)` — index of the most significant set bit; `0xffffffff` for 0 (u32 reading). */
+    firstLeadingBit: (e) => unop(e, x => (x === 0 ? 0xffffffff : 31 - Math.clz32(x))),
+
+    /** `firstTrailingBit(e)` — index of the least significant set bit; `0xffffffff` for 0. */
+    firstTrailingBit: (e) => unop(e, x => (x === 0 ? 0xffffffff : 31 - Math.clz32(x & -x))),
+
+    /** `reverseBits(e)` — reverse the order of all 32 bits. */
+    reverseBits: (e) => unop(e, x => {
+        let source = x >>> 0;
+        let reversed = 0;
+
+        for (let i = 0; i < 32; i++) {
+            reversed = ((reversed << 1) | (source & 1)) >>> 0;
+            source >>>= 1;
+        }
+
+        return reversed;
+    }),
+
     /** `insertBits(e, newbits, offset, count)` — replace bits `[offset, offset+count)` of `e` with the low `count` bits of `newbits`. */
     insertBits(e, newbits, offset, count) {
         const o = Math.min(offset >>> 0, 32);

package/src/view/interaction/InterfaceCommand.d.ts

@@ -4,8 +4,8 @@ declare class InterfaceCommand {
      *
      * @param {InteractionCommand} command
      * @param {Object} [style]
-     * @param {SoundTrack} [actionSound]
-     * @param {SoundTrack} [hoverSound]
+     * @param {EventDescription} [actionSound]
+     * @param {EventDescription} [hoverSound]
      * @param {string} [tooltip]
      * @param {string[]} [tags]
      * @returns {InterfaceCommand}
@@ -16,8 +16,8 @@ declare class InterfaceCommand {
      * @param {string} [name]
      * @param {Object} [style]
      * @param {string} [tooltip]
-     * @param {SoundTrack} [actionSound]
-     * @param {SoundTrack} [hoverSound]
+     * @param {EventDescription} [actionSound]
+     * @param {EventDescription} [hoverSound]
      * @param {string[]} [tags]
      * @constructor
      */
@@ -39,14 +39,14 @@ declare class InterfaceCommand {
     style: any;
     /**
      *
-     * @type {SoundTrack}
+     * @type {EventDescription}
      */
-    actionSound: SoundTrack;
+    actionSound: EventDescription;
     /**
      *
-     * @type {SoundTrack}
+     * @type {EventDescription}
      */
-    hoverSound: SoundTrack;
+    hoverSound: EventDescription;
     /**
      * Localization key for the tooltip
      * @type {string}

package/src/view/interaction/InterfaceCommand.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InterfaceCommand.d.ts","sourceRoot":"","sources":["../../../../src/view/interaction/InterfaceCommand.js"],"names":[],"mappings":";AAGA;IAmEI;;;;;;;;;OASG;IACH,wEARW,kBAAkB,GAMhB,gBAAgB,CAuB5B;IAjGD;;;;;;;;;OASG;IACH,8EATW,kBAAkB,EA+D5B;IAzCG;;;OAGG;IACH,MAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,SAFU,kBAAkB,CAEN;IAEtB;;;OAGG;IACH,WAAkB;IAElB;;;OAGG;IACH,wBAA8B;IAE9B;;;OAGG;IACH,uBAA4B;IAE5B;;;OAGG;IACH,SAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,MAFU,MAAM,EAAE,CAEF;IAoCpB;;;;OAIG;IACH,YAHW,MAAM,GACL,OAAO,CAIlB;IAED;;;OAGG;IACH,iBAEC;IAED;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,uBAEC;CACJ;mCA9IkC,yBAAyB"}
+{"version":3,"file":"InterfaceCommand.d.ts","sourceRoot":"","sources":["../../../../src/view/interaction/InterfaceCommand.js"],"names":[],"mappings":";AAGA;IAmEI;;;;;;;;;OASG;IACH,wEARW,kBAAkB,GAMhB,gBAAgB,CAuB5B;IAjGD;;;;;;;;;OASG;IACH,8EATW,kBAAkB,EA+D5B;IAzCG;;;OAGG;IACH,MAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,SAFU,kBAAkB,CAEN;IAEtB;;;OAGG;IACH,WAAkB;IAElB;;;OAGG;IACH,8BAA8B;IAE9B;;;OAGG;IACH,6BAA4B;IAE5B;;;OAGG;IACH,SAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,MAFU,MAAM,EAAE,CAEF;IAoCpB;;;;OAIG;IACH,YAHW,MAAM,GACL,OAAO,CAIlB;IAED;;;OAGG;IACH,iBAEC;IAED;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,uBAEC;CACJ;mCA9IkC,yBAAyB"}

package/src/view/interaction/InterfaceCommand.js

@@ -1,146 +1,146 @@
-import { assert } from "../../core/assert.js";
-import { InteractionCommand } from "./InteractionCommand.js";
-
-class InterfaceCommand {
-    /**
-     * @param {InteractionCommand} command
-     * @param {string} [name]
-     * @param {Object} [style]
-     * @param {string} [tooltip]
-     * @param {SoundTrack} [actionSound]
-     * @param {SoundTrack} [hoverSound]
-     * @param {string[]} [tags]
-     * @constructor
-     */
-    constructor(
-        {
-            command,
-            style = {},
-            tooltip,
-            name = "",
-            actionSound = null,
-            hoverSound = null,
-            tags = []
-        }
-    ) {
-        assert.defined(command, 'command');
-
-        /**
-         * Name for the command, this is a localization key
-         * @type {string}
-         */
-        this.name = name;
-
-        /**
-         *
-         * @type {InteractionCommand}
-         */
-        this.command = command;
-
-        /**
-         *
-         * @type {Object}
-         */
-        this.style = style;
-
-        /**
-         *
-         * @type {SoundTrack}
-         */
-        this.actionSound = actionSound;
-
-        /**
-         *
-         * @type {SoundTrack}
-         */
-        this.hoverSound = hoverSound;
-
-        /**
-         * Localization key for the tooltip
-         * @type {string}
-         */
-        this.tooltip = tooltip;
-
-        /**
-         *
-         * @type {string[]}
-         */
-        this.tags = tags;
-    }
-
-    /**
-     *
-     * @param {InteractionCommand} command
-     * @param {Object} [style]
-     * @param {SoundTrack} [actionSound]
-     * @param {SoundTrack} [hoverSound]
-     * @param {string} [tooltip]
-     * @param {string[]} [tags]
-     * @returns {InterfaceCommand}
-     */
-    static form(
-        {
-            command,
-            style = {},
-            actionSound = null,
-            hoverSound = null,
-            tooltip,
-            tags = []
-        }
-    ) {
-
-        const r = new InterfaceCommand({
-            command,
-            style,
-            actionSound,
-            hoverSound,
-            tooltip,
-            tags
-        });
-
-        return r;
-    }
-
-    /**
-     *
-     * @param {string} tag
-     * @return {boolean}
-     */
-    hasTag(tag) {
-        return this.tags.indexOf(tag) !== -1;
-    }
-
-    /**
-     * @deprecated
-     * @return {string}
-     */
-    get id() {
-        return this.command.id;
-    }
-
-    /**
-     * @deprecated
-     * @return {ObservedBoolean|ReactiveExpression}
-     */
-    get enabled() {
-        return this.command.enabled;
-    }
-
-    /**
-     * @deprecated
-     * @return {List<String>}
-     */
-    get features() {
-        return this.command.features;
-    }
-
-    /**
-     * @deprecated
-     * @return {Function}
-     */
-    get action() {
-        return this.command.action;
-    }
-}
-
-export default InterfaceCommand;
+import { assert } from "../../core/assert.js";
+import { InteractionCommand } from "./InteractionCommand.js";
+
+class InterfaceCommand {
+    /**
+     * @param {InteractionCommand} command
+     * @param {string} [name]
+     * @param {Object} [style]
+     * @param {string} [tooltip]
+     * @param {EventDescription} [actionSound]
+     * @param {EventDescription} [hoverSound]
+     * @param {string[]} [tags]
+     * @constructor
+     */
+    constructor(
+        {
+            command,
+            style = {},
+            tooltip,
+            name = "",
+            actionSound = null,
+            hoverSound = null,
+            tags = []
+        }
+    ) {
+        assert.defined(command, 'command');
+
+        /**
+         * Name for the command, this is a localization key
+         * @type {string}
+         */
+        this.name = name;
+
+        /**
+         *
+         * @type {InteractionCommand}
+         */
+        this.command = command;
+
+        /**
+         *
+         * @type {Object}
+         */
+        this.style = style;
+
+        /**
+         *
+         * @type {EventDescription}
+         */
+        this.actionSound = actionSound;
+
+        /**
+         *
+         * @type {EventDescription}
+         */
+        this.hoverSound = hoverSound;
+
+        /**
+         * Localization key for the tooltip
+         * @type {string}
+         */
+        this.tooltip = tooltip;
+
+        /**
+         *
+         * @type {string[]}
+         */
+        this.tags = tags;
+    }
+
+    /**
+     *
+     * @param {InteractionCommand} command
+     * @param {Object} [style]
+     * @param {EventDescription} [actionSound]
+     * @param {EventDescription} [hoverSound]
+     * @param {string} [tooltip]
+     * @param {string[]} [tags]
+     * @returns {InterfaceCommand}
+     */
+    static form(
+        {
+            command,
+            style = {},
+            actionSound = null,
+            hoverSound = null,
+            tooltip,
+            tags = []
+        }
+    ) {
+
+        const r = new InterfaceCommand({
+            command,
+            style,
+            actionSound,
+            hoverSound,
+            tooltip,
+            tags
+        });
+
+        return r;
+    }
+
+    /**
+     *
+     * @param {string} tag
+     * @return {boolean}
+     */
+    hasTag(tag) {
+        return this.tags.indexOf(tag) !== -1;
+    }
+
+    /**
+     * @deprecated
+     * @return {string}
+     */
+    get id() {
+        return this.command.id;
+    }
+
+    /**
+     * @deprecated
+     * @return {ObservedBoolean|ReactiveExpression}
+     */
+    get enabled() {
+        return this.command.enabled;
+    }
+
+    /**
+     * @deprecated
+     * @return {List<String>}
+     */
+    get features() {
+        return this.command.features;
+    }
+
+    /**
+     * @deprecated
+     * @return {Function}
+     */
+    get action() {
+        return this.command.action;
+    }
+}
+
+export default InterfaceCommand;

package/src/view/interaction/createInterfaceCommandButton.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createInterfaceCommandButton.d.ts","sourceRoot":"","sources":["../../../../src/view/interaction/createInterfaceCommandButton.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH,4FA8GC"}
+{"version":3,"file":"createInterfaceCommandButton.d.ts","sourceRoot":"","sources":["../../../../src/view/interaction/createInterfaceCommandButton.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,4FAsGC"}