typegpu 0.12.0 → 0.12.2

package/bin.mjs

@@ -21,8 +21,11 @@ if (major === undefined || minor === undefined) {
  */
 const semver = `^${major}.${minor}.0`;
 
+/**
+ * @returns {Promise<number | undefined>}
+ */
 function asyncSpawn(...args) {
-  return new Promise((resolve, _reject) => {
+  return new Promise((resolve, reject) => {
     const child = spawn(...args);
 
     child.on('exit', (code, signal) => {
@@ -34,22 +37,41 @@ function asyncSpawn(...args) {
 
       resolve(code);
     });
+
+    child.on('error', (err) => {
+      reject(err);
+    });
   });
 }
 
+/**
+ * @param {string} label
+ */
+function failedToRunErrHandler(label) {
+  return (err) => {
+    console.error(`Failed to run '${label}':`, err);
+    process.exit(1);
+  };
+}
+
 (async () => {
-  const code = await asyncSpawn('npx', [`@typegpu/cli@${semver}`, ...process.argv.slice(2)], {
-    stdio: ['inherit', 'inherit', 'ignore'],
-  });
+  const windows = process.platform === 'win32';
+  const npxCommand = windows ? 'npx.cmd' : 'npx';
+
+  const code = await asyncSpawn(npxCommand, [`@typegpu/cli@${semver}`, ...process.argv.slice(2)], {
+    stdio: 'inherit',
+    shell: windows, // needs to be ran through the shell on Windows
+  }).catch(failedToRunErrHandler(`npx @typegpu/cli@${semver}`));
 
   if (code !== 0) {
     console.warn(
       `Couldn't find @typegpu/cli version matching ${semver}, falling back to latest...`,
     );
     // Fallback to latest
-    const code = await asyncSpawn('npx', [`@typegpu/cli@latest`, ...process.argv.slice(2)], {
+    const code = await asyncSpawn(npxCommand, [`@typegpu/cli@latest`, ...process.argv.slice(2)], {
       stdio: 'inherit',
-    });
+      shell: windows, // needs to be ran through the shell on Windows
+    }).catch(failedToRunErrHandler('npx @typegpu/cli@latest'));
     process.exit(code ?? 0);
   }
 

package/core/buffer/buffer.js

@@ -8,6 +8,7 @@ import { isGPUBuffer } from "../../types.js";
 import { calculateOffsets, readFromArrayBuffer, writeToArrayBuffer } from "../../data/dataIO.js";
 import { patchArrayBuffer } from "../../data/partialIO.js";
 import { mutable, readonly, uniform, } from "./bufferBinding.js";
+import { warnIfNotUniformAligned } from "../pipeline/webgpuLimitations.js";
 const usageToUsageConstructor = { uniform, mutable, readonly };
 export function INTERNAL_createBuffer(group, typeSchema, initialOrBuffer) {
     if (!isWgslData(typeSchema)) {
@@ -145,6 +146,9 @@ class TgpuBufferImpl {
             if (this.#disallowedUsages?.includes(usage)) {
                 throw new Error(`Buffer of type ${this.dataType.type} cannot be used as ${usage}`);
             }
+            if (usage === 'uniform') {
+                warnIfNotUniformAligned(this.dataType);
+            }
             this.flags |= usage === 'uniform' ? GPUBufferUsage.UNIFORM : 0;
             this.flags |= usage === 'storage' ? GPUBufferUsage.STORAGE : 0;
             this.flags |= usage === 'vertex' ? GPUBufferUsage.VERTEX : 0;

package/core/pipeline/computePipeline.js

@@ -11,7 +11,7 @@ import { isGPUCommandEncoder, isGPUComputePassEncoder, isTgpuCommandEncoder, isT
 import { isGPUBuffer } from "../../types.js";
 import { wgslEnableExtensions, wgslEnableExtensionToFeatureName } from "../../wgslExtensions.js";
 import { namespace } from "../resolve/namespace.js";
-import { warnIfOverflow } from "./limitsOverflow.js";
+import { warnIfOverflow } from "./webgpuLimitations.js";
 import { collectBindGroupPairs, DISPATCH_INDIRECT_SIZE, resolveIndirectOffset, restoreTimestampPriors, } from "./pipelineUtils.js";
 import { invariant } from "../../errors.js";
 import { createWithPerformanceCallback, createWithTimestampWrites, } from "./timeable.js";

package/core/pipeline/renderPipeline.js

@@ -24,7 +24,7 @@ import { isGPUCommandEncoder, isGPURenderBundleEncoder, isGPURenderPassEncoder,
 import { createWithPerformanceCallback, createWithTimestampWrites, } from "./timeable.js";
 import { nonTransferablePriorsOf } from "./priors.js";
 import {} from "../../data/offsetUtils.js";
-import { warnIfOverflow } from "./limitsOverflow.js";
+import { warnIfOverflow } from "./webgpuLimitations.js";
 import { collectBindGroupPairs, collectVertexBufferPairs, DRAW_INDEXED_INDIRECT_SIZE, DRAW_INDIRECT_SIZE, resolveIndirectOffset, restoreTimestampPriors, } from "./pipelineUtils.js";
 import { NullPerformanceTracker, PerformanceTrackerImpl, } from "./performanceTracker.js";
 import { logger } from "../../tgpuLogger.js";

package/core/pipeline/webgpuLimitations.d.ts

@@ -0,0 +1,10 @@
+import { type BaseData } from '../../data/wgslTypes.ts';
+import type { TgpuBindGroupLayout } from '../../tgpuBindGroupLayout.ts';
+/**
+ * Warns if layout exceeds supported buffer count limits.
+ */
+export declare function warnIfOverflow(layouts: TgpuBindGroupLayout[], limits: GPUSupportedLimits): void;
+/**
+ * See https://www.w3.org/TR/WGSL/#address-space-layout-constraints
+ */
+export declare function warnIfNotUniformAligned(schema: BaseData): void;

package/core/pipeline/webgpuLimitations.js

@@ -0,0 +1,81 @@
+import { alignmentOf } from "../../data/alignmentOf.js";
+import { memoryLayoutOf } from "../../data/offsetUtils.js";
+import { sizeOf } from "../../data/sizeOf.js";
+import { isWgslArray, isWgslStruct } from "../../data/wgslTypes.js";
+import { invariant } from "../../errors.js";
+import { roundUp } from "../../mathUtils.js";
+import { getName } from "../../shared/meta.js";
+import { logger } from "../../tgpuLogger.js";
+/**
+ * Warns if layout exceeds supported buffer count limits.
+ */
+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}).`);
+    }
+}
+function requiredAlignOf(schema) {
+    if (isWgslStruct(schema) || isWgslArray(schema)) {
+        return roundUp(alignmentOf(schema), 16);
+    }
+    return alignmentOf(schema);
+}
+/**
+ * See https://www.w3.org/TR/WGSL/#address-space-layout-constraints
+ */
+export function warnIfNotUniformAligned(schema) {
+    if (isWgslArray(schema)) {
+        warnIfNotUniformAligned(schema.elementType);
+        const stride = roundUp(sizeOf(schema.elementType), alignmentOf(schema.elementType));
+        if (stride % 16 !== 0) {
+            logger.warn('uniform-schema-misaligned', `\
+Schema '${getName(schema.elementType) ?? '<unnamed>'}' is used in an array in a uniform buffer, and its stride (${stride}) is not a multiple of 16.
+This is not portable (see https://www.w3.org/TR/WGSL/#address-space-layout-constraints), and will break on some devices.
+To address this, put the element schema in a struct and wrap the prop in 'd.align(16, ...)', or use a different schema like 'vec4f'.`);
+        }
+    }
+    if (isWgslStruct(schema)) {
+        Object.values(schema.propTypes).forEach(warnIfNotUniformAligned);
+        Object.entries(schema.propTypes).forEach(([key, value]) => {
+            const offset = memoryLayoutOf(schema, (schema) => schema[key]).offset;
+            const requiredAlignment = requiredAlignOf(value);
+            if (offset % requiredAlignment) {
+                logger.warn('uniform-schema-misaligned', `\
+Schema '${getName(schema) ?? '<unnamed>'}' is used in a uniform buffer, and its property '${key}' does not meet required alignment (offset is ${offset}, required alignment is ${requiredAlignment}).
+This is not portable (see https://www.w3.org/TR/WGSL/#address-space-layout-constraints), and will break on some devices.
+To address this, wrap the property '${key}' in 'd.align(${requiredAlignment}, ...)'.`);
+            }
+        });
+        const keys = Object.keys(schema.propTypes);
+        for (let i = 0; i < keys.length - 1; i++) {
+            const thisKey = keys[i];
+            const nextKey = keys[i + 1];
+            invariant(thisKey && nextKey);
+            const thisValue = schema.propTypes[thisKey];
+            invariant(thisValue);
+            if (!isWgslStruct(thisValue)) {
+                continue;
+            }
+            const minimumDifference = roundUp(sizeOf(thisValue), 16);
+            const thisKeyOffset = memoryLayoutOf(schema, (schema) => schema[thisKey]).offset;
+            const nextKeyOffset = memoryLayoutOf(schema, (schema) => schema[nextKey]).offset;
+            const difference = nextKeyOffset - thisKeyOffset;
+            if (minimumDifference > difference) {
+                logger.warn('uniform-schema-misaligned', `\
+Schema '${getName(schema) ?? '<unnamed>'}' is used in a uniform buffer, and the difference between memory offsets of '${thisKey}' and '${nextKey}' props (${difference}) is less than recommended (${minimumDifference}).
+This is not portable (see https://www.w3.org/TR/WGSL/#address-space-layout-constraints), and will break on some devices.
+To address this, wrap the '${thisKey}' prop in 'd.size(${minimumDifference}, ...)'.`);
+            }
+        }
+    }
+}

package/data/array.d.ts

@@ -1,6 +1,12 @@
 import { type TgpuComptime } from '../core/function/comptime.ts';
-import type { AnyWgslData, WgslArray } from './wgslTypes.ts';
+import type { AnyWgslData, Decorated, Location, WgslArray } from './wgslTypes.ts';
+type ForbiddenDecoratedArrayElement<T> = T extends Decorated<infer _, infer Attribs> ? Attribs[number] extends Location ? never : T : never;
 interface WgslArrayConstructor {
+    /**
+     * @deprecated Error: Arrays cannot hold decorated types other than @location.
+     * Wrap align/size in a struct instead, e.g. d.arrayOf(d.struct({ value: d.align(16, d.u32) }), n).
+     */
+    <TElement extends AnyWgslData>(elementType: ForbiddenDecoratedArrayElement<TElement>, elementCount?: number): 'Error: Arrays cannot hold decorated types other than @location. Wrap it in a struct instead, e.g. d.arrayOf(d.struct({ value: d.align(16, d.u32) }), n).';
     <TElement extends AnyWgslData>(elementType: TElement): (elementCount: number) => WgslArray<TElement>;
     <TElement extends AnyWgslData>(elementType: TElement, elementCount: number): WgslArray<TElement>;
 }
@@ -8,6 +14,10 @@ interface WgslArrayConstructor {
  * Creates an array schema that can be used to construct gpu buffers.
  * Describes arrays with fixed-size length, storing elements of the same type.
  *
+ * The only decoration allowed on element types is `d.location`. Decorators like
+ * `d.align` and `d.size` cannot be applied directly — wrap them in a struct instead,
+ * e.g. `d.arrayOf(d.struct({ value: d.align(16, d.u32) }), n)`.
+ *
  * @example
  * const LENGTH = 3;
  * const array = d.arrayOf(d.u32, LENGTH);
@@ -19,6 +29,7 @@ interface WgslArrayConstructor {
  *
  * @param elementType The type of elements in the array.
  * @param elementCount The number of elements in the array.
+ * @throws If `elementType` is decorated with anything other than `d.location`.
  */
 export declare const arrayOf: TgpuComptime<WgslArrayConstructor>;
 export {};

package/data/array.js

@@ -2,10 +2,15 @@ import { comptime } from "../core/function/comptime.js";
 import { $internal } from "../shared/symbols.js";
 import { schemaCallWrapper } from "./schemaCallWrapper.js";
 import { sizeOf } from "./sizeOf.js";
+import { isDecorated, isLocationAttrib } from "./wgslTypes.js";
 /**
  * Creates an array schema that can be used to construct gpu buffers.
  * Describes arrays with fixed-size length, storing elements of the same type.
  *
+ * The only decoration allowed on element types is `d.location`. Decorators like
+ * `d.align` and `d.size` cannot be applied directly — wrap them in a struct instead,
+ * e.g. `d.arrayOf(d.struct({ value: d.align(16, d.u32) }), n)`.
+ *
  * @example
  * const LENGTH = 3;
  * const array = d.arrayOf(d.u32, LENGTH);
@@ -17,8 +22,12 @@ import { sizeOf } from "./sizeOf.js";
  *
  * @param elementType The type of elements in the array.
  * @param elementCount The number of elements in the array.
+ * @throws If `elementType` is decorated with anything other than `d.location`.
  */
 export const arrayOf = comptime(((elementType, elementCount) => {
+    if (isDecorated(elementType) && !elementType.attribs.every(isLocationAttrib)) {
+        throw new Error('Arrays cannot hold decorated types other than @location. Wrap it in a struct instead, e.g. d.arrayOf(d.struct({ value: d.align(16, d.u32) }), n).');
+    }
     if (elementCount === undefined) {
         return comptime((count) => cpu_arrayOf(elementType, count));
     }

package/data/assignInfixOperators.d.ts

@@ -0,0 +1 @@
+export {};

package/data/assignInfixOperators.js

@@ -0,0 +1,14 @@
+import { Operator } from 'tsover-runtime';
+import { MatBase } from "./matrix.js";
+import { VecBase } from "./vectorImpl.js";
+import { assignInfixOperator } from "../tgsl/infixDispatch.js";
+assignInfixOperator(VecBase, 'add', Operator.plus);
+assignInfixOperator(MatBase, 'add', Operator.plus);
+assignInfixOperator(VecBase, 'sub', Operator.minus);
+assignInfixOperator(MatBase, 'sub', Operator.minus);
+assignInfixOperator(VecBase, 'mul', Operator.star);
+assignInfixOperator(MatBase, 'mul', Operator.star);
+assignInfixOperator(VecBase, 'div', Operator.slash);
+assignInfixOperator(VecBase, 'mod', Operator.percent);
+assignInfixOperator(VecBase, 'bitShiftLeft', Symbol()); // bitShift does not yet have tsover operator symbol
+assignInfixOperator(VecBase, 'bitShiftRight', Symbol()); // bitShift does not yet have tsover operator symbol

package/data/generalizeFn.d.ts

@@ -0,0 +1,25 @@
+import { type AnyBooleanVecInstance, type AnyMatInstance, type AnyVec2Instance, type AnyVec3Instance, type AnyVec4Instance, type AnyVecInstance, type v2b, type v3b, type v4b } from './wgslTypes.ts';
+type Vec = AnyVecInstance;
+type Mat = AnyMatInstance;
+type Algebraic = number | boolean | Vec | Mat;
+export type ToBool<T extends Algebraic> = T extends number | boolean ? boolean : T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : T extends AnyVec4Instance ? v4b : never;
+/**
+ * Generalizes function of 1 to 3 arguments to work component-wise on vectors and matrices.
+ * Assumes the types are already correct (in particular, that they have the same length),
+ * and performs no additional checks.
+ * The return type is the same as the first argument's type.
+ */
+export declare function generalizeFn<T extends Algebraic>(fn: (a: number) => number, args: [T]): T;
+export declare function generalizeFn<T extends Algebraic>(fn: (a: number, b: number) => number, args: [T, T]): T;
+export declare function generalizeFn<T extends Algebraic>(fn: (a: number, b: number, c: number) => number, args: [T, T, T]): T;
+/**
+ * Analogous to `generalizeFn`, but the return type is a boolean vector instead.
+ */
+export declare function generalizeBoolFn<T extends Algebraic>(fn: (a: number, b: number) => boolean, args: [T, T]): ToBool<T>;
+export declare function generalizeBoolFn<T extends boolean | AnyBooleanVecInstance>(fn: (a: boolean, b: boolean) => boolean, args: [T, T]): ToBool<T>;
+/**
+ * If one of the arguments is a vector and other is a number,
+ * the number is up-cased to a vector.
+ */
+export declare function upCast<T extends number | Vec>(args: [T, T]): [Exclude<T, number>, Exclude<T, number>];
+export {};

package/data/generalizeFn.js

@@ -0,0 +1,89 @@
+import { vec2b, vec3b, vec4b, vecTypeToConstructor } from "./vector.js";
+import { mat2x2f, mat3x3f, mat4x4f } from "./matrix.js";
+import { isVecInstance, } from "./wgslTypes.js";
+import { invariant } from "../errors.js";
+const booleanFor = {
+    vec2f: vec2b,
+    vec2h: vec2b,
+    vec2i: vec2b,
+    vec2u: vec2b,
+    'vec2<bool>': vec2b,
+    vec3f: vec3b,
+    vec3h: vec3b,
+    vec3i: vec3b,
+    vec3u: vec3b,
+    'vec3<bool>': vec3b,
+    vec4f: vec4b,
+    vec4h: vec4b,
+    vec4i: vec4b,
+    vec4u: vec4b,
+    'vec4<bool>': vec4b,
+};
+const constructorFor = {
+    ...vecTypeToConstructor,
+    mat2x2f,
+    mat3x3f,
+    mat4x4f,
+};
+function getConstructorFor(mode, kind) {
+    const map = mode === 'boolean' ? booleanFor : constructorFor;
+    if (kind in map) {
+        return map[kind];
+    }
+    throw new Error(`No corresponding vector/matrix type for '${kind}' kind in '${mode}' mode.`);
+}
+function makeIterable(item) {
+    if (item.kind.startsWith('vec')) {
+        return item;
+    }
+    return item.columns.flat();
+}
+function applyArgs(fn, args, mode) {
+    // I'm sorry, TypeScript, I swear I won't lie to you no more ;-;
+    const kinds = args.map(kindOf);
+    if (kinds.every((type) => type === 'boolean' || type === 'number')) {
+        return fn(...args);
+    }
+    const kind = kinds[0];
+    invariant(kind, `Expected kind of the first argument to be present.`);
+    const constructor = getConstructorFor(mode, kind);
+    const iterableArgs = args.map(makeIterable);
+    const length = iterableArgs[0]?.length;
+    invariant(length !== undefined, `Expected constructor to have at least one argument.`);
+    const constructorArgs = Array.from({ length }, (_, i) => {
+        const args = iterableArgs.map((arg) => arg[i]);
+        return fn(...args);
+    });
+    return constructor(...constructorArgs);
+}
+export function generalizeFn(fn, args) {
+    return applyArgs(fn, args, 'first');
+}
+export function generalizeBoolFn(fn, args) {
+    return applyArgs(fn, args, 'boolean');
+}
+function kindOf(v) {
+    if (typeof v === 'number') {
+        return 'number';
+    }
+    if (typeof v === 'boolean') {
+        return 'boolean';
+    }
+    return v.kind;
+}
+/**
+ * If one of the arguments is a vector and other is a number,
+ * the number is up-cased to a vector.
+ */
+export function upCast(args) {
+    const [lhs, rhs] = args;
+    if (typeof lhs === 'number' && isVecInstance(rhs)) {
+        const schema = constructorFor[rhs.kind];
+        return [schema(lhs), rhs];
+    }
+    else if (isVecInstance(lhs) && typeof rhs === 'number') {
+        const schema = constructorFor[lhs.kind];
+        return [lhs, schema(rhs)];
+    }
+    return [lhs, rhs];
+}

package/data/index.d.ts

@@ -1,6 +1,7 @@
 /**
  * @module typegpu/data
  */
+import './assignInfixOperators.ts';
 export { bool, f16, f32, i32, u16, u32 } from './numeric.ts';
 export { isAlignAttrib, isAtomic, isBuiltinAttrib, isDecorated, isInterpolateAttrib, isInvariantAttrib, isLocationAttrib, isPtr, isSizeAttrib, isWgslArray, isWgslData, isWgslStruct, Void, } from './wgslTypes.ts';
 export type { Align, AnyVecInstance, AnyWgslData, AnyWgslStruct, Atomic, atomicI32, atomicU32, BaseData, BaseData as BaseWgslData, Bool, Builtin, Decorated, F16, F32, I32, Interpolate, Invariant, Location, m2x2f, m3x3f, m4x4f, Mat2x2f, Mat3x3f, Mat4x4f, matBase, Ptr, Size, StorableData, U16, U32, v2b, v2f, v2h, v2i, v2u, v3b, v3f, v3h, v3i, v3u, v4b, v4f, v4h, v4i, v4u, Vec2b, Vec2f, Vec2h, Vec2i, Vec2u, Vec3b, Vec3f, Vec3h, Vec3i, Vec3u, Vec4b, Vec4f, Vec4h, Vec4i, Vec4u, vecBase, WgslArray, WgslStruct, } from './wgslTypes.ts';

package/data/index.js

@@ -2,20 +2,8 @@
  * @module typegpu/data
  */
 // NOTE: This is a barrel file, internal files should not import things from this file
-import { Operator } from 'tsover-runtime';
-import { MatBase } from "./matrix.js";
-import { VecBase } from "./vectorImpl.js";
-import { assignInfixOperator } from "../tgsl/infixDispatch.js";
-assignInfixOperator(VecBase, 'add', Operator.plus);
-assignInfixOperator(MatBase, 'add', Operator.plus);
-assignInfixOperator(VecBase, 'sub', Operator.minus);
-assignInfixOperator(MatBase, 'sub', Operator.minus);
-assignInfixOperator(VecBase, 'mul', Operator.star);
-assignInfixOperator(MatBase, 'mul', Operator.star);
-assignInfixOperator(VecBase, 'div', Operator.slash);
-assignInfixOperator(VecBase, 'mod', Operator.percent);
-assignInfixOperator(VecBase, 'bitShiftLeft', Symbol()); // bitShift does not yet have tsover operator symbol
-assignInfixOperator(VecBase, 'bitShiftRight', Symbol()); // bitShift does not yet have tsover operator symbol
+// oxlint-disable-next-line import/no-unassigned-import -- this import has side effects
+import "./assignInfixOperators.js";
 export { bool, f16, f32, i32, u16, u32 } from "./numeric.js";
 export { isAlignAttrib, isAtomic, isBuiltinAttrib, isDecorated, isInterpolateAttrib, isInvariantAttrib, isLocationAttrib, isPtr, isSizeAttrib, isWgslArray, isWgslData, isWgslStruct, Void, } from "./wgslTypes.js";
 export { struct } from "./struct.js";

package/data/numberOps.d.ts

@@ -1,6 +1,5 @@
 export declare const smoothstepScalar: (edge0: number, edge1: number, x: number) => number;
-export declare const clamp: (value: number, low: number, high: number) => number;
-export declare const divInteger: (lhs: number, rhs: number) => number;
+export declare const clampScalar: (value: number, low: number, high: number) => number;
 export declare function bitcastU32toF32Impl(n: number): number;
 export declare function bitcastU32toI32Impl(n: number): number;
 export declare function bitcastF32toU32Impl(n: number): number;

package/data/numberOps.js

@@ -2,16 +2,10 @@ export const smoothstepScalar = (edge0, edge1, x) => {
     if (edge0 === edge1) {
         return 0; // WGSL spec says this is an indeterminate value
     }
-    const t = clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);
+    const t = clampScalar((x - edge0) / (edge1 - edge0), 0.0, 1.0);
     return t * t * (3 - 2 * t);
 };
-export const clamp = (value, low, high) => Math.min(Math.max(low, value), high);
-export const divInteger = (lhs, rhs) => {
-    if (rhs === 0) {
-        return lhs;
-    }
-    return Math.trunc(lhs / rhs);
-};
+export const clampScalar = (value, low, high) => Math.min(Math.max(low, value), high);
 const buf32 = new ArrayBuffer(4);
 const f32arr = new Float32Array(buf32);
 const u32arr = new Uint32Array(buf32);

package/data/vectorOps.d.ts

@@ -3,57 +3,19 @@ import type { VecKind } from './wgslTypes.ts';
 type vBase = {
     kind: VecKind;
 };
-type mBase = {
-    kind: MatKind;
-};
 type MatKind = 'mat2x2f' | 'mat3x3f' | 'mat4x4f';
+/**
+ * Functions that cannot be simply generalized via `generalizeFn`
+ * have their overloads listed explicitly here.
+ */
 export declare const VectorOps: {
-    eq: Record<VecKind, <T extends wgsl.AnyVecInstance>(e1: T, e2: T) => T extends wgsl.AnyVec2Instance ? wgsl.v2b : T extends wgsl.AnyVec3Instance ? wgsl.v3b : wgsl.v4b>;
-    lt: Record<VecKind, <T extends wgsl.AnyNumericVecInstance>(e1: T, e2: T) => T extends wgsl.AnyVec2Instance ? wgsl.v2b : T extends wgsl.AnyVec3Instance ? wgsl.v3b : wgsl.v4b>;
-    or: Record<VecKind, <T extends wgsl.AnyBooleanVecInstance>(e1: T, e2: T) => T>;
     all: Record<VecKind, (v: wgsl.AnyBooleanVecInstance) => boolean>;
-    abs: Record<VecKind, <T extends vBase>(v: T) => T>;
-    atan2: Record<VecKind, <T extends vBase>(a: T, b: T) => T>;
-    acos: Record<VecKind, <T extends vBase>(v: T) => T>;
-    acosh: Record<VecKind, <T extends vBase>(v: T) => T>;
-    asin: Record<VecKind, <T extends vBase>(v: T) => T>;
-    asinh: Record<VecKind, <T extends vBase>(v: T) => T>;
-    atan: Record<VecKind, <T extends vBase>(v: T) => T>;
-    atanh: Record<VecKind, <T extends vBase>(v: T) => T>;
-    ceil: Record<VecKind, <T extends vBase>(v: T) => T>;
-    clamp: Record<VecKind, <T extends vBase>(v: T, low: T, high: T) => T>;
     length: Record<VecKind, (v: vBase) => number>;
-    add: Record<VecKind | MatKind, <T extends vBase | mBase>(lhs: T, rhs: T) => T>;
-    smoothstep: Record<VecKind, <T extends vBase>(edge0: T, edge1: T, x: T) => T extends wgsl.AnyVec2Instance ? wgsl.v2f : T extends wgsl.AnyVec3Instance ? wgsl.v3f : T extends wgsl.AnyVec4Instance ? wgsl.v4f : wgsl.AnyVecInstance>;
-    addMixed: Record<VecKind | MatKind, <T extends vBase | mBase>(lhs: T, rhs: number) => T>;
-    mulSxV: Record<VecKind | MatKind, <T extends vBase | wgsl.AnyMatInstance>(s: number, v: T) => T>;
-    mulVxV: Record<VecKind | MatKind, <T extends vBase | wgsl.AnyMatInstance>(lhs: T, rhs: T) => T>;
+    mulMxM: Record<VecKind | MatKind, <T extends vBase | wgsl.AnyMatInstance>(lhs: T, rhs: T) => T>;
     mulMxV: Record<MatKind, <T extends wgsl.AnyMatInstance>(m: T, v: wgsl.vBaseForMat<T>) => wgsl.vBaseForMat<T>>;
     mulVxM: Record<MatKind, <T extends wgsl.AnyMatInstance>(v: wgsl.vBaseForMat<T>, m: T) => wgsl.vBaseForMat<T>>;
-    div: Record<VecKind, <T extends vBase>(a: T, b: T) => T>;
     dot: Record<VecKind, <T extends vBase>(lhs: T, rhs: T) => number>;
-    normalize: Record<VecKind, <T extends vBase>(v: T) => T>;
     cross: Record<"vec3f" | "vec3h", <T extends wgsl.v3f | wgsl.v3h>(a: T, b: T) => T>;
-    mod: Record<VecKind, <T extends vBase>(a: T, b: T) => T>;
-    floor: Record<VecKind, <T extends vBase>(v: T) => T>;
-    max: Record<VecKind, <T extends vBase>(a: T, b: T) => T>;
-    min: Record<VecKind, <T extends vBase>(a: T, b: T) => T>;
-    pow: Record<"vec2f" | "vec3f" | "vec4f" | "vec2h" | "vec3h" | "vec4h" | "number", <T extends wgsl.AnyFloatVecInstance | number>(a: T, b: T) => T>;
-    sign: Record<VecKind, <T extends vBase>(e: T) => T>;
-    sqrt: Record<VecKind, <T extends vBase>(v: T) => T>;
-    mix: Record<"vec2f" | "vec3f" | "vec4f" | "vec2h" | "vec3h" | "vec4h", <T extends wgsl.v2f | wgsl.v3f | wgsl.v4f | wgsl.v2h | wgsl.v3h | wgsl.v4h>(a: T, b: T, c: T | number) => T>;
-    sin: Record<VecKind, <T extends vBase>(v: T) => T>;
-    cos: Record<VecKind, <T extends vBase>(v: T) => T>;
-    cosh: Record<VecKind, <T extends vBase>(v: T) => T>;
-    exp: Record<VecKind, <T extends vBase>(v: T) => T>;
-    exp2: Record<VecKind, <T extends vBase>(v: T) => T>;
-    log: Record<VecKind, <T extends vBase>(v: T) => T>;
-    log2: Record<VecKind, <T extends vBase>(v: T) => T>;
-    fract: Record<VecKind, <T extends vBase>(v: T) => T>;
-    isCloseToZero: Record<VecKind, <T extends vBase>(v: T, n: number) => boolean>;
-    neg: Record<VecKind, <T extends vBase>(v: T) => T>;
-    select: Record<VecKind, <T extends wgsl.AnyVecInstance>(f: T, t: T, c: T extends wgsl.AnyVec2Instance ? wgsl.v2b : T extends wgsl.AnyVec3Instance ? wgsl.v3b : wgsl.v4b) => T>;
-    tanh: Record<VecKind, <T extends vBase>(v: T) => T>;
     bitShiftLeft: Record<VecKind, <T extends wgsl.AnyIntegerVecInstance, U extends wgsl.AnyUnsignedVecInstance>(a: T, b: U) => T>;
     bitShiftRight: Record<VecKind, <T extends wgsl.AnyIntegerVecInstance, U extends wgsl.AnyUnsignedVecInstance>(a: T, b: U) => T>;
     bitcastU32toF32: Record<VecKind, <T extends wgsl.AnyUnsignedVecInstance>(v: T) => T extends wgsl.v2u ? wgsl.v2f : T extends wgsl.v3u ? wgsl.v3f : wgsl.v4f>;