@woosh/meep-engine 3.42.0 → 3.43.0

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

@@ -1491,7 +1491,8 @@ function emitVariableUpdatingStatement(c, node) {
             || isScalarUnsigned(lhs_compiled.type)
             || isScalarUnsigned(rhs_compiled.type)
         )) {
-            c.out.add(emitWriteStatement(lhs_compiled, `wgsl.${bitwise_helper}(${lhs_compiled.code}, ${rhs_compiled.code})`));
+            c.out.add(emitWriteStatement(lhs_compiled,
+                `wgsl.${shiftHelperFor(bitwise_helper, lhs_compiled.type)}(${lhs_compiled.code}, ${rhs_compiled.code})`));
             return;
         }
         c.out.add(`${lhs_compiled.code} ${op_text} ${rhs_compiled.code};`);
@@ -2155,14 +2156,15 @@ function compileBinaryExpression(c, node, op_type, mode) {
     // bit set was negative too. The helpers normalise with `>>> 0`, which is what WGSL u32 means.
     //
     // Deliberately not extended to i32: `bit_and` and friends return an unsigned result, and a
-    // signed operand is exactly the case raw JS already gets right.
+    // signed operand is exactly the case raw JS already gets right. A shift is the exception: WGSL
+    // makes its amount a u32 whatever it shifts, so an i32 shift lands here and takes the signed helper.
     const bitwise_helper = BITWISE_HELPER[op_text];
     if (bitwise_helper !== undefined) {
         if (isContainerType(left.type) || isContainerType(right.type)
             || isScalarBool(left.type) || isScalarBool(right.type)
             || isScalarUnsigned(left.type) || isScalarUnsigned(right.type)) {
             return {
-                code: `wgsl.${bitwise_helper}(${left.code}, ${right.code})`,
+                code: `wgsl.${shiftHelperFor(bitwise_helper, left.type)}(${left.code}, ${right.code})`,
                 type: inferRawBinaryResultType(left.type, right.type, op_text),
             };
         }
@@ -2193,6 +2195,12 @@ const BITWISE_HELPER = {
     '>>': 'shr',
 };
 
+/** The helper for a bitwise operator on a value of type `t`: a shift of an i32 (scalar or vector) keeps its sign. */
+function shiftHelperFor(helper, t) {
+    if ((helper === 'shl' || helper === 'shr') && isIntegerType(t) && integerScalarName(t) === 'i32') { return `${helper}_i32`; }
+    return helper;
+}
+
 /** Map WGSL comparison operators to language-core element-wise helper names. */
 const COMPARISON_HELPER = {
     '==': 'eq',

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":";IAs/CA;;;;;;;;;;;;;;OAcG;IACH,+DAmDC"}
+{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":";IAy/CA;;;;;;;;;;;;;;OAcG;IACH,+DAmDC"}

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

@@ -586,6 +586,9 @@ export const WGSLLanguageCore = {
     bit_xor: (a, b) => binop(a, b, (x, y) => typeof x === 'boolean' ? x !== y : (x ^ y) >>> 0),
     shl:     (a, b) => binop(a, b, (x, y) => (x << y) >>> 0),
     shr:     (a, b) => binop(a, b, (x, y) => x >>> y),
+    // The same on an i32, whose shift amount WGSL still makes a u32: `>>` sign-extends, and both stay signed.
+    shl_i32: (a, b) => binop(a, b, (x, y) => (x << y) | 0),
+    shr_i32: (a, b) => binop(a, b, (x, y) => x >> y),
 
     neg: (a) => unop(a, x => -x),
     not: (a) => unop(a, x => (~x) >>> 0),