typegpu 0.12.0 → 0.12.2

package/std/operators.js

@@ -1,8 +1,9 @@
 import { dualImpl } from "../core/function/dualImpl.js";
 import { stitch } from "../core/resolve/stitch.js";
 import { abstractFloat, f16, f32, u32 } from "../data/numeric.js";
-import { vec2i, vec2u, vec3i, vec3u, vec4i, vec4u, vecTypeToConstructor } from "../data/vector.js";
+import { vec2i, vec2u, vec3i, vec3u, vec4i, vec4u } from "../data/vector.js";
 import { VectorOps } from "../data/vectorOps.js";
+import { generalizeFn, upCast } from "../data/generalizeFn.js";
 import { isFloat32VecInstance, isInteger32VecInstance, isMat, isMatInstance, isUint32VecInstance, isVec, isVecInstance, } from "../data/wgslTypes.js";
 import { SignatureNotSupportedError } from "../errors.js";
 import { unify } from "../tgsl/conversion.js";
@@ -59,13 +60,13 @@ function cpuAdd(lhs, rhs) {
         return lhs + rhs; // default addition
     }
     if (typeof lhs === 'number' && isVecInstance(rhs)) {
-        return VectorOps.addMixed[rhs.kind](rhs, lhs); // mixed addition
+        return generalizeFn((e) => lhs + e, [rhs]); // mixed addition
     }
     if (isVecInstance(lhs) && typeof rhs === 'number') {
-        return VectorOps.addMixed[lhs.kind](lhs, rhs); // mixed addition
+        return generalizeFn((e) => e + rhs, [lhs]); // mixed addition
     }
     if ((isVecInstance(lhs) && isVecInstance(rhs)) || (isMatInstance(lhs) && isMatInstance(rhs))) {
-        return VectorOps.add[lhs.kind](lhs, rhs); // component-wise addition
+        return generalizeFn((a, b) => a + b, [lhs, rhs]); // component-wise addition
     }
     throw new Error('Add/Sub called with invalid arguments.');
 }
@@ -92,13 +93,13 @@ function cpuMul(lhs, rhs) {
         return lhs * rhs; // default multiplication
     }
     if (typeof lhs === 'number' && (isVecInstance(rhs) || isMatInstance(rhs))) {
-        return VectorOps.mulSxV[rhs.kind](lhs, rhs); // scale
+        return generalizeFn((e) => lhs * e, [rhs]); // scale
     }
     if ((isVecInstance(lhs) || isMatInstance(lhs)) && typeof rhs === 'number') {
-        return VectorOps.mulSxV[lhs.kind](rhs, lhs); // scale
+        return generalizeFn((e) => e * rhs, [lhs]); // scale
     }
     if (isVecInstance(lhs) && isVecInstance(rhs)) {
-        return VectorOps.mulVxV[lhs.kind](lhs, rhs); // component-wise
+        return generalizeFn((a, b) => a * b, [lhs, rhs]); // component-wise
     }
     if (isFloat32VecInstance(lhs) && isMatInstance(rhs)) {
         return VectorOps.mulVxM[rhs.kind](lhs, rhs); // row-vector-matrix
@@ -107,7 +108,7 @@ function cpuMul(lhs, rhs) {
         return VectorOps.mulMxV[lhs.kind](lhs, rhs); // matrix-column-vector
     }
     if (isMatInstance(lhs) && isMatInstance(rhs)) {
-        return VectorOps.mulVxV[lhs.kind](lhs, rhs); // matrix multiplication
+        return VectorOps.mulMxM[lhs.kind](lhs, rhs); // matrix multiplication
     }
     throw new Error('Mul called with invalid arguments.');
 }
@@ -119,21 +120,7 @@ export const mul = dualImpl({
     sideEffects: false,
 });
 function cpuDiv(lhs, rhs) {
-    if (typeof lhs === 'number' && typeof rhs === 'number') {
-        return lhs / rhs;
-    }
-    if (typeof lhs === 'number' && isVecInstance(rhs)) {
-        const schema = vecTypeToConstructor[rhs.kind];
-        return VectorOps.div[rhs.kind](schema(lhs), rhs);
-    }
-    if (isVecInstance(lhs) && typeof rhs === 'number') {
-        const schema = vecTypeToConstructor[lhs.kind];
-        return VectorOps.div[lhs.kind](lhs, schema(rhs));
-    }
-    if (isVecInstance(lhs) && isVecInstance(rhs)) {
-        return VectorOps.div[lhs.kind](lhs, rhs);
-    }
-    throw new Error('Div called with invalid arguments.');
+    return generalizeFn((a, b) => a / b, upCast([lhs, rhs]));
 }
 export const div = dualImpl({
     name: 'div',
@@ -151,33 +138,13 @@ export const mod = dualImpl({
     name: 'mod',
     signature: binaryDivSignature,
     normalImpl: ((a, b) => {
-        if (typeof a === 'number' && typeof b === 'number') {
-            return (a % b); // scalar % scalar
-        }
-        if (typeof a === 'number' && isVecInstance(b)) {
-            // scalar % vector
-            const schema = vecTypeToConstructor[b.kind];
-            return VectorOps.mod[b.kind](schema(a), b);
-        }
-        if (isVecInstance(a) && typeof b === 'number') {
-            const schema = vecTypeToConstructor[a.kind];
-            // vector % scalar
-            return VectorOps.mod[a.kind](a, schema(b));
-        }
-        if (isVecInstance(a) && isVecInstance(b)) {
-            // vector % vector
-            return VectorOps.mod[a.kind](a, b);
-        }
-        throw new Error('Mod called with invalid arguments, expected types: number or vector.');
+        return generalizeFn((a, b) => a % b, upCast([a, b]));
     }),
     codegenImpl: (ctx, [lhs, rhs]) => ctx.gen.emitBinaryOp(lhs, '%', rhs),
     sideEffects: false,
 });
 function cpuNeg(value) {
-    if (typeof value === 'number') {
-        return -value;
-    }
-    return VectorOps.neg[value.kind](value);
+    return generalizeFn((value) => -value, [value]);
 }
 export const neg = dualImpl({
     name: 'neg',

package/std/texture.js

@@ -5,13 +5,16 @@ import { f32, i32, u32 } from "../data/numeric.js";
 import { vec2u, vec3u, vec4f, vec4i, vec4u } from "../data/vector.js";
 import { Void, } from "../data/wgslTypes.js";
 import { getTextureFormatInfo, } from "../core/texture/textureFormats.js";
+function compactSnippetArgs(args) {
+    return args.filter((arg) => arg !== undefined);
+}
 function sampleCpu(_texture, _sampler, _coords, _offsetOrArrayIndex, _maybeOffset) {
     throw new MissingCpuImplError('Texture sampling relies on GPU resources and cannot be executed outside of a draw call');
 }
 export const textureSample = dualImpl({
     name: 'textureSample',
     normalImpl: sampleCpu,
-    codegenImpl: (_ctx, args) => stitch `textureSample(${args})`,
+    codegenImpl: (ctx, args) => ctx.gen.emitCall('textureSample', [], compactSnippetArgs(args)),
     signature: (...args) => {
         const isDepth = args[0].type.startsWith('texture_depth');
         return {
@@ -27,7 +30,7 @@ function sampleBiasCpu(_texture, _sampler, _coords, _biasOrArrayIndex, _biasOrOf
 export const textureSampleBias = dualImpl({
     name: 'textureSampleBias',
     normalImpl: sampleBiasCpu,
-    codegenImpl: (_ctx, args) => stitch `textureSampleBias(${args})`,
+    codegenImpl: (ctx, args) => ctx.gen.emitCall('textureSampleBias', [], compactSnippetArgs(args)),
     signature: (...args) => ({
         argTypes: args,
         returnType: vec4f,
@@ -40,7 +43,7 @@ function sampleLevelCpu(_texture, _sampler, _coords, _level, _offsetOrArrayIndex
 export const textureSampleLevel = dualImpl({
     name: 'textureSampleLevel',
     normalImpl: sampleLevelCpu,
-    codegenImpl: (_ctx, args) => stitch `textureSampleLevel(${args})`,
+    codegenImpl: (ctx, args) => ctx.gen.emitCall('textureSampleLevel', [], compactSnippetArgs(args)),
     signature: (...args) => {
         const isDepth = args[0].type.startsWith('texture_depth');
         return {
@@ -56,7 +59,7 @@ function textureLoadCpu(_texture, _coords, _levelOrArrayIndex) {
 export const textureLoad = dualImpl({
     name: 'textureLoad',
     normalImpl: textureLoadCpu,
-    codegenImpl: (_ctx, args) => stitch `textureLoad(${args})`,
+    codegenImpl: (ctx, args) => ctx.gen.emitCall('textureLoad', [], compactSnippetArgs(args)),
     signature: (...args) => {
         const texture = args[0];
         if (isWgslTexture(texture)) {
@@ -104,7 +107,7 @@ function textureDimensionsCpu(_texture, _level) {
 export const textureDimensions = dualImpl({
     name: 'textureDimensions',
     normalImpl: textureDimensionsCpu,
-    codegenImpl: (_ctx, args) => stitch `textureDimensions(${args})`,
+    codegenImpl: (ctx, args) => ctx.gen.emitCall('textureDimensions', [], compactSnippetArgs(args)),
     signature: (...args) => {
         const dim = args[0].dimension;
         if (dim === '1d') {

package/tgpuLogger.d.ts

@@ -1,4 +1,4 @@
-declare const warningTypes: readonly ["deprecated", "suspicious", "fallback", "precision-loss", "implicit-conversion", "webgpu-feature-missing", "webgpu-limits-exceeded", "locations-mismatched", "log-limit-exceeded", "external-omitted"];
+declare const warningTypes: readonly ["deprecated", "suspicious", "fallback", "precision-loss", "implicit-conversion", "webgpu-feature-missing", "webgpu-limits-exceeded", "locations-mismatched", "log-limit-exceeded", "external-omitted", "uniform-schema-misaligned"];
 type WarningType = (typeof warningTypes)[number];
 interface Logger {
     warn(type: WarningType, ...args: unknown[]): void;

package/tgpuLogger.js

@@ -10,6 +10,7 @@ const warningTypes = [
     'locations-mismatched',
     'log-limit-exceeded',
     'external-omitted',
+    'uniform-schema-misaligned',
 ];
 export class TgpuLogger {
     #initialEnabledWarnings;

package/tgsl/wgslGenerator.js

@@ -699,8 +699,9 @@ export class WgslGenerator {
                 elemType = concretize(values[0]?.dataType);
             }
             const arrayType = arrayOf(elemType, values.length);
+            const allConstant = values.every((value) => value.origin === 'constant');
             return snip(new ArrayExpression(arrayType, values), arrayType, 
-            /* origin */ 'runtime', values.some((v) => v.possibleSideEffects));
+            /* origin */ allConstant ? 'constant' : 'runtime', values.some((v) => v.possibleSideEffects));
         }
         if (expression[0] === NODE.conditionalExpr) {
             // ternary operator

package/core/pipeline/limitsOverflow.d.ts

@@ -1,2 +0,0 @@
-import type { TgpuBindGroupLayout } from '../../tgpuBindGroupLayout.ts';
-export declare function warnIfOverflow(layouts: TgpuBindGroupLayout[], limits: GPUSupportedLimits): void;

package/core/pipeline/limitsOverflow.js

@@ -1,16 +0,0 @@
-import { logger } from "../../tgpuLogger.js";
-export function warnIfOverflow(layouts, limits) {
-    const entries = Object.values(layouts)
-        .flatMap((layout) => Object.values(layout.entries))
-        .filter((entry) => entry !== null);
-    const uniform = entries.filter((entry) => 'uniform' in entry).length;
-    const storage = entries.filter((entry) => 'storage' in entry).length;
-    if (uniform > limits.maxUniformBuffersPerShaderStage) {
-        logger.warn('webgpu-limits-exceeded', `Total number of uniform buffers (${uniform}) exceeds maxUniformBuffersPerShaderStage (${limits.maxUniformBuffersPerShaderStage}). Consider:
-1. Grouping some of the uniforms into one using 'd.struct',
-2. Increasing the limit when requesting a device or creating a root.`);
-    }
-    if (storage > limits.maxStorageBuffersPerShaderStage) {
-        logger.warn('webgpu-limits-exceeded', `Total number of storage buffers (${storage}) exceeds maxStorageBuffersPerShaderStage (${limits.maxStorageBuffersPerShaderStage}).`);
-    }
-}