typegpu 0.12.0 → 0.12.2

package/std/boolean.d.ts

@@ -16,7 +16,7 @@ export declare const allEq: import("../types.ts").DualFn<(<T extends AnyVecInsta
  * all(eq(vec4i(4, 3, 2, 1), vec4i(4, 3, 2, 1))) // returns true
  * allEq(vec4i(4, 3, 2, 1), vec4i(4, 3, 2, 1)) // returns true
  */
-export declare const eq: import("../types.ts").DualFn<(<T extends AnyVecInstance>(lhs: T, rhs: T) => T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : v4b)>;
+export declare const eq: import("../types.ts").DualFn<(<T extends AnyVecInstance>(lhs: T, rhs: T) => import("../data/generalizeFn.ts").ToBool<T>)>;
 /**
  * Checks **component-wise** whether `lhs != rhs`.
  * This function does **not** return `bool`, for that use-case, wrap the result in `any`.
@@ -25,7 +25,7 @@ export declare const eq: import("../types.ts").DualFn<(<T extends AnyVecInstance
  * ne(vec3u(0, 1, 2), vec3u(2, 1, 0)) // returns vec3b(true, false, true)
  * any(ne(vec4i(4, 3, 2, 1), vec4i(4, 2, 2, 1))) // returns true
  */
-export declare const ne: import("../types.ts").DualFn<(<T extends AnyVecInstance>(lhs: T, rhs: T) => T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : v4b)>;
+export declare const ne: import("../types.ts").DualFn<(<T extends AnyVecInstance>(lhs: T, rhs: T) => import("../data/generalizeFn.ts").ToBool<T>)>;
 /**
  * Checks **component-wise** whether `lhs < rhs`.
  * This function does **not** return `bool`, for that use-case, wrap the result in `all`.
@@ -34,7 +34,7 @@ export declare const ne: import("../types.ts").DualFn<(<T extends AnyVecInstance
  * lt(vec3u(0, 1, 2), vec3u(2, 1, 0)) // returns vec3b(true, false, false)
  * all(lt(vec4i(1, 2, 3, 4), vec4i(2, 3, 4, 5))) // returns true
  */
-export declare const lt: import("../types.ts").DualFn<(<T extends AnyNumericVecInstance>(lhs: T, rhs: T) => T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : v4b)>;
+export declare const lt: import("../types.ts").DualFn<(<T extends AnyNumericVecInstance>(lhs: T, rhs: T) => import("../data/generalizeFn.ts").ToBool<T>)>;
 /**
  * Checks **component-wise** whether `lhs <= rhs`.
  * This function does **not** return `bool`, for that use-case, wrap the result in `all`.
@@ -43,7 +43,7 @@ export declare const lt: import("../types.ts").DualFn<(<T extends AnyNumericVecI
  * le(vec3u(0, 1, 2), vec3u(2, 1, 0)) // returns vec3b(true, true, false)
  * all(le(vec4i(1, 2, 3, 4), vec4i(2, 3, 3, 5))) // returns true
  */
-export declare const le: import("../types.ts").DualFn<(<T extends AnyNumericVecInstance>(lhs: T, rhs: T) => T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : v4b)>;
+export declare const le: import("../types.ts").DualFn<(<T extends AnyNumericVecInstance>(lhs: T, rhs: T) => import("../data/generalizeFn.ts").ToBool<import("../data/generalizeFn.ts").ToBool<T>>)>;
 /**
  * Checks **component-wise** whether `lhs > rhs`.
  * This function does **not** return `bool`, for that use-case, wrap the result in `all`.
@@ -52,7 +52,7 @@ export declare const le: import("../types.ts").DualFn<(<T extends AnyNumericVecI
  * gt(vec3u(0, 1, 2), vec3u(2, 1, 0)) // returns vec3b(false, false, true)
  * all(gt(vec4i(2, 3, 4, 5), vec4i(1, 2, 3, 4))) // returns true
  */
-export declare const gt: import("../types.ts").DualFn<(<T extends AnyNumericVecInstance>(lhs: T, rhs: T) => T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : v4b)>;
+export declare const gt: import("../types.ts").DualFn<(<T extends AnyNumericVecInstance>(lhs: T, rhs: T) => import("../data/generalizeFn.ts").ToBool<import("../data/generalizeFn.ts").ToBool<T>>)>;
 /**
  * Checks **component-wise** whether `lhs >= rhs`.
  * This function does **not** return `bool`, for that use-case, wrap the result in `all`.
@@ -61,7 +61,7 @@ export declare const gt: import("../types.ts").DualFn<(<T extends AnyNumericVecI
  * ge(vec3u(0, 1, 2), vec3u(2, 1, 0)) // returns vec3b(false, true, true)
  * all(ge(vec4i(2, 2, 4, 5), vec4i(1, 2, 3, 4))) // returns true
  */
-export declare const ge: import("../types.ts").DualFn<(<T extends AnyNumericVecInstance>(lhs: T, rhs: T) => T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : v4b)>;
+export declare const ge: import("../types.ts").DualFn<(<T extends AnyNumericVecInstance>(lhs: T, rhs: T) => import("../data/generalizeFn.ts").ToBool<T>)>;
 declare function cpuNot(value: boolean): boolean;
 declare function cpuNot<T extends AnyBooleanVecInstance>(value: T): T;
 /**
@@ -79,14 +79,14 @@ export declare const not: import("../types.ts").DualFn<typeof cpuNot>;
  * or(vec2b(false, true), vec2b(false, false)) // returns vec2b(false, true)
  * or(vec3b(true, true, false), vec3b(false, true, false)) // returns vec3b(true, true, false)
  */
-export declare const or: import("../types.ts").DualFn<(<T extends AnyBooleanVecInstance>(lhs: T, rhs: T) => T)>;
+export declare const or: import("../types.ts").DualFn<(<T extends AnyBooleanVecInstance>(lhs: T, rhs: T) => import("../data/generalizeFn.ts").ToBool<T>)>;
 /**
  * Returns **component-wise** logical `and` result.
  * @example
  * and(vec2b(false, true), vec2b(true, true)) // returns vec2b(false, true)
  * and(vec3b(true, true, false), vec3b(false, true, false)) // returns vec3b(false, true, false)
  */
-export declare const and: import("../types.ts").DualFn<(<T extends AnyBooleanVecInstance>(lhs: T, rhs: T) => T)>;
+export declare const and: import("../types.ts").DualFn<(<T extends AnyBooleanVecInstance>(lhs: T, rhs: T) => import("../data/generalizeFn.ts").ToBool<T>)>;
 /**
  * Returns `true` if each component of `value` is true.
  * @example

package/std/boolean.js

@@ -4,11 +4,11 @@ import { bool, f16, f32, i32, u32 } from "../data/numeric.js";
 import { isSnippetNumeric, snip } from "../data/snippet.js";
 import { vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u, } from "../data/vector.js";
 import { VectorOps } from "../data/vectorOps.js";
-import { isBool, isVecBool, isVecBoolInstance, isVecInstance, } from "../data/wgslTypes.js";
+import { generalizeBoolFn, generalizeFn } from "../data/generalizeFn.js";
+import { isBool, isVecBool, isVecBoolInstance, } from "../data/wgslTypes.js";
 import { SignatureNotSupportedError } from "../errors.js";
 import { unify } from "../tgsl/conversion.js";
 import { cpuCopy } from "./copy.js";
-import { sub } from "./operators.js";
 function correspondingBooleanVectorSchema(dataType) {
     if (dataType.type.includes('2')) {
         return vec2b;
@@ -33,7 +33,7 @@ export const allEq = dualImpl({
     codegenImpl: (_ctx, [lhs, rhs]) => stitch `all(${lhs} == ${rhs})`,
     sideEffects: false,
 });
-const cpuEq = (lhs, rhs) => VectorOps.eq[lhs.kind](lhs, rhs);
+const cpuEq = (lhs, rhs) => generalizeBoolFn((a, b) => a === b, [lhs, rhs]);
 /**
  * Checks **component-wise** whether `lhs == rhs`.
  * This function does **not** return `bool`, for that use-case, wrap the result in `all`, or use `allEq`.
@@ -71,7 +71,7 @@ export const ne = dualImpl({
     codegenImpl: (_ctx, [lhs, rhs]) => stitch `(${lhs} != ${rhs})`,
     sideEffects: false,
 });
-const cpuLt = (lhs, rhs) => VectorOps.lt[lhs.kind](lhs, rhs);
+const cpuLt = (lhs, rhs) => generalizeBoolFn((a, b) => a < b, [lhs, rhs]);
 /**
  * Checks **component-wise** whether `lhs < rhs`.
  * This function does **not** return `bool`, for that use-case, wrap the result in `all`.
@@ -183,7 +183,7 @@ export const not = dualImpl({
     codegenImpl: (_ctx, [arg]) => stitch `!(${arg})`,
     sideEffects: false,
 });
-const cpuOr = (lhs, rhs) => VectorOps.or[lhs.kind](lhs, rhs);
+const cpuOr = (lhs, rhs) => generalizeBoolFn((a, b) => a || b, [lhs, rhs]);
 /**
  * Returns **component-wise** logical `or` result.
  * @example
@@ -257,13 +257,8 @@ export const isCloseTo = dualImpl({
     }),
     // CPU implementation
     normalImpl: (lhs, rhs, precision = 0.01) => {
-        if (typeof lhs === 'number' && typeof rhs === 'number') {
-            return Math.abs(lhs - rhs) < precision;
-        }
-        if (isVecInstance(lhs) && isVecInstance(rhs)) {
-            return VectorOps.isCloseToZero[lhs.kind](sub(lhs, rhs), precision);
-        }
-        return false;
+        const componentResult = generalizeBoolFn((lhs, rhs) => Math.abs(lhs - rhs) < precision, [lhs, rhs]);
+        return typeof componentResult === 'boolean' ? componentResult : all(componentResult);
     },
     // GPU implementation
     codegenImpl: (_ctx, [lhs, rhs, precision = snip(0.01, f32, /* origin */ 'constant', false)]) => {
@@ -283,7 +278,8 @@ function cpuSelect(f, t, cond) {
     if (typeof cond === 'boolean') {
         return cpuCopy(cond ? t : f);
     }
-    return VectorOps.select[f.kind](f, t, cond);
+    // generalizeFn will handle this fine, it just has no mixed type overload.
+    return generalizeFn((f, t, c) => (c ? t : f), [f, t, cond]);
 }
 export const validSelectBranchTypes = [
     f32,

package/std/index.d.ts

@@ -3,7 +3,7 @@
  */
 export { copy } from './copy.ts';
 export { discard } from './discard.ts';
-export { abs, acos, acosh, asin, asinh, atan, atan2, atanh, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, distance, dot, dot4I8Packed, dot4U8Packed, exp, exp2, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, insertBits, inverseSqrt, ldexp, length, log, log2, max, min, mix, modf, normalize, pow, quantizeToF16, radians, reflect, refract, reverseBits, round, saturate, sign, sin, sinh, smoothstep, sqrt, step, tan, tanh, transpose, trunc, } from './numeric.ts';
+export { abs, acos, acosh, asin, asinh, atan, atan2, atanh, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, distance, dot, dot4I8Packed, dot4U8Packed, exp, exp2, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, insertBits, inverseSqrt, ldexp, length, log, log2, max, min, mix, modf, normalize, pow, quantizeToF16, radians, reflect, refract, reverseBits, round, saturate, sign, sin, sinh, smoothstep, sqrt, step, tan, tanh, transpose, trunc, intdiv, } from './numeric.ts';
 export { add, bitShiftLeft, bitShiftRight, div, mod, mul, neg, sub } from './operators.ts';
 export { rotateX4, rotateY4, rotateZ4, scale4, translate4 } from './matrix.ts';
 export { identity2, identity3, identity4, rotationX4, rotationY4, rotationZ4, scaling4, translation4, } from '../data/matrix.ts';

package/std/index.js

@@ -4,7 +4,7 @@
 // NOTE: This is a barrel file, internal files should not import things from this file
 export { copy } from "./copy.js";
 export { discard } from "./discard.js";
-export { abs, acos, acosh, asin, asinh, atan, atan2, atanh, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, distance, dot, dot4I8Packed, dot4U8Packed, exp, exp2, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, insertBits, inverseSqrt, ldexp, length, log, log2, max, min, mix, modf, normalize, pow, quantizeToF16, radians, reflect, refract, reverseBits, round, saturate, sign, sin, sinh, smoothstep, sqrt, step, tan, tanh, transpose, trunc, } from "./numeric.js";
+export { abs, acos, acosh, asin, asinh, atan, atan2, atanh, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, distance, dot, dot4I8Packed, dot4U8Packed, exp, exp2, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, insertBits, inverseSqrt, ldexp, length, log, log2, max, min, mix, modf, normalize, pow, quantizeToF16, radians, reflect, refract, reverseBits, round, saturate, sign, sin, sinh, smoothstep, sqrt, step, tan, tanh, transpose, trunc, intdiv, } from "./numeric.js";
 export { add, bitShiftLeft, bitShiftRight, div, mod, mul, neg, sub } from "./operators.js";
 export { rotateX4, rotateY4, rotateZ4, scale4, translate4 } from "./matrix.js";
 export { identity2, identity3, identity4, rotationX4, rotationY4, rotationZ4, scaling4, translation4, } from "../data/matrix.js";

package/std/numeric.d.ts

@@ -248,4 +248,11 @@ export declare const transpose: import("../types.ts").DualFn<typeof cpuTranspose
 declare function cpuTrunc(value: number): number;
 declare function cpuTrunc<T extends AnyFloatVecInstance>(value: T): T;
 export declare const trunc: import("../types.ts").DualFn<typeof cpuTrunc>;
+declare function cpuIntdiv(lhs: number, rhs: number): number;
+/**
+ * Performs integer division on the passed in scalars.
+ * Equivalent to `trunc(trunc(lhs) / trunc(rhs))`. Coerces both
+ * arguments to integers if they're floating point.
+ */
+export declare const intdiv: import("../types.ts").DualFn<typeof cpuIntdiv>;
 export {};

package/std/numeric.js

@@ -1,12 +1,13 @@
 import { dualImpl, MissingCpuImplError } from "../core/function/dualImpl.js";
 import { stitch } from "../core/resolve/stitch.js";
 import { mat2x2f, mat3x3f, mat4x4f } from "../data/matrix.js";
-import { smoothstepScalar } from "../data/numberOps.js";
+import { clampScalar, smoothstepScalar } from "../data/numberOps.js";
 import { abstractFloat, abstractInt, f16, f32, i32, u32 } from "../data/numeric.js";
 import { abstruct } from "../data/struct.js";
 import { vec2f, vec2h, vec2i, vec2u, vec3f, vec3h, vec3i, vec3u, vec4f, vec4h, vec4i, vec4u, } from "../data/vector.js";
 import { VectorOps } from "../data/vectorOps.js";
-import { isHalfPrecisionSchema, isVecInstance, WORKAROUND_getSchema, } from "../data/wgslTypes.js";
+import { generalizeFn, upCast } from "../data/generalizeFn.js";
+import { isHalfPrecisionSchema, WORKAROUND_getSchema, } from "../data/wgslTypes.js";
 import { SignatureNotSupportedError } from "../errors.js";
 import { assertExhaustive } from "../shared/utilityTypes.js";
 import { unify } from "../tgsl/conversion.js";
@@ -60,10 +61,7 @@ const anyConcreteIntegerPrimitive = [i32, u32];
 const anyConcreteIntegerVec = [vec2i, vec3i, vec4i, vec2u, vec3u, vec4u];
 const anyConcreteInteger = [...anyConcreteIntegerPrimitive, ...anyConcreteIntegerVec];
 function cpuAbs(value) {
-    if (typeof value === 'number') {
-        return Math.abs(value);
-    }
-    return VectorOps.abs[value.kind](value);
+    return generalizeFn(Math.abs, [value]);
 }
 export const abs = dualImpl({
     name: 'abs',
@@ -73,10 +71,7 @@ export const abs = dualImpl({
     sideEffects: false,
 });
 function cpuAcos(value) {
-    if (typeof value === 'number') {
-        return Math.acos(value);
-    }
-    return VectorOps.acos[value.kind](value);
+    return generalizeFn(Math.acos, [value]);
 }
 export const acos = dualImpl({
     name: 'acos',
@@ -86,10 +81,7 @@ export const acos = dualImpl({
     sideEffects: false,
 });
 function cpuAcosh(value) {
-    if (typeof value === 'number') {
-        return Math.acosh(value);
-    }
-    return VectorOps.acosh[value.kind](value);
+    return generalizeFn(Math.acosh, [value]);
 }
 export const acosh = dualImpl({
     name: 'acosh',
@@ -99,10 +91,7 @@ export const acosh = dualImpl({
     sideEffects: false,
 });
 function cpuAsin(value) {
-    if (typeof value === 'number') {
-        return Math.asin(value);
-    }
-    return VectorOps.asin[value.kind](value);
+    return generalizeFn(Math.asin, [value]);
 }
 export const asin = dualImpl({
     name: 'asin',
@@ -112,10 +101,7 @@ export const asin = dualImpl({
     sideEffects: false,
 });
 function cpuAsinh(value) {
-    if (typeof value === 'number') {
-        return Math.asinh(value);
-    }
-    return VectorOps.asinh[value.kind](value);
+    return generalizeFn(Math.asinh, [value]);
 }
 export const asinh = dualImpl({
     name: 'asinh',
@@ -125,10 +111,7 @@ export const asinh = dualImpl({
     sideEffects: false,
 });
 function cpuAtan(value) {
-    if (typeof value === 'number') {
-        return Math.atan(value);
-    }
-    return VectorOps.atan[value.kind](value);
+    return generalizeFn(Math.atan, [value]);
 }
 export const atan = dualImpl({
     name: 'atan',
@@ -138,10 +121,7 @@ export const atan = dualImpl({
     sideEffects: false,
 });
 function cpuAtanh(value) {
-    if (typeof value === 'number') {
-        return Math.atanh(value);
-    }
-    return VectorOps.atanh[value.kind](value);
+    return generalizeFn(Math.atanh, [value]);
 }
 export const atanh = dualImpl({
     name: 'atanh',
@@ -151,10 +131,7 @@ export const atanh = dualImpl({
     sideEffects: false,
 });
 function cpuAtan2(y, x) {
-    if (typeof y === 'number' && typeof x === 'number') {
-        return Math.atan2(y, x);
-    }
-    return VectorOps.atan2[y.kind](y, x);
+    return generalizeFn(Math.atan2, [y, x]);
 }
 export const atan2 = dualImpl({
     name: 'atan2',
@@ -164,10 +141,7 @@ export const atan2 = dualImpl({
     sideEffects: false,
 });
 function cpuCeil(value) {
-    if (typeof value === 'number') {
-        return Math.ceil(value);
-    }
-    return VectorOps.ceil[value.kind](value);
+    return generalizeFn(Math.ceil, [value]);
 }
 export const ceil = dualImpl({
     name: 'ceil',
@@ -177,10 +151,7 @@ export const ceil = dualImpl({
     sideEffects: false,
 });
 function cpuClamp(value, low, high) {
-    if (typeof value === 'number') {
-        return Math.min(Math.max(low, value), high);
-    }
-    return VectorOps.clamp[value.kind](value, low, high);
+    return generalizeFn(clampScalar, [value, low, high]);
 }
 export const clamp = dualImpl({
     name: 'clamp',
@@ -190,10 +161,7 @@ export const clamp = dualImpl({
     sideEffects: false,
 });
 function cpuCos(value) {
-    if (typeof value === 'number') {
-        return Math.cos(value);
-    }
-    return VectorOps.cos[value.kind](value);
+    return generalizeFn(Math.cos, [value]);
 }
 export const cos = dualImpl({
     name: 'cos',
@@ -203,10 +171,7 @@ export const cos = dualImpl({
     sideEffects: false,
 });
 function cpuCosh(value) {
-    if (typeof value === 'number') {
-        return Math.cosh(value);
-    }
-    return VectorOps.cosh[value.kind](value);
+    return generalizeFn(Math.cosh, [value]);
 }
 export const cosh = dualImpl({
     name: 'cosh',
@@ -324,10 +289,7 @@ export const dot4I8Packed = dualImpl({
     sideEffects: false,
 });
 function cpuExp(value) {
-    if (typeof value === 'number') {
-        return Math.exp(value);
-    }
-    return VectorOps.exp[value.kind](value);
+    return generalizeFn(Math.exp, [value]);
 }
 export const exp = dualImpl({
     name: 'exp',
@@ -337,10 +299,7 @@ export const exp = dualImpl({
     sideEffects: false,
 });
 function cpuExp2(value) {
-    if (typeof value === 'number') {
-        return (2 ** value);
-    }
-    return VectorOps.exp2[value.kind](value);
+    return generalizeFn((val) => 2 ** val, [value]);
 }
 export const exp2 = dualImpl({
     name: 'exp2',
@@ -396,10 +355,7 @@ export const firstTrailingBit = dualImpl({
     sideEffects: false,
 });
 function cpuFloor(value) {
-    if (typeof value === 'number') {
-        return Math.floor(value);
-    }
-    return VectorOps.floor[value.kind](value);
+    return generalizeFn(Math.floor, [value]);
 }
 export const floor = dualImpl({
     name: 'floor',
@@ -422,10 +378,7 @@ export const fma = dualImpl({
     sideEffects: false,
 });
 function cpuFract(value) {
-    if (typeof value === 'number') {
-        return (value - Math.floor(value));
-    }
-    return VectorOps.fract[value.kind](value);
+    return generalizeFn((value) => value - Math.floor(value), [value]);
 }
 export const fract = dualImpl({
     name: 'fract',
@@ -542,10 +495,7 @@ export const length = dualImpl({
     sideEffects: false,
 });
 function cpuLog(value) {
-    if (typeof value === 'number') {
-        return Math.log(value);
-    }
-    return VectorOps.log[value.kind](value);
+    return generalizeFn(Math.log, [value]);
 }
 export const log = dualImpl({
     name: 'log',
@@ -555,10 +505,7 @@ export const log = dualImpl({
     sideEffects: false,
 });
 function cpuLog2(value) {
-    if (typeof value === 'number') {
-        return Math.log2(value);
-    }
-    return VectorOps.log2[value.kind](value);
+    return generalizeFn(Math.log2, [value]);
 }
 export const log2 = dualImpl({
     name: 'log2',
@@ -568,10 +515,7 @@ export const log2 = dualImpl({
     sideEffects: false,
 });
 function cpuMax(a, b) {
-    if (typeof a === 'number') {
-        return Math.max(a, b);
-    }
-    return VectorOps.max[a.kind](a, b);
+    return generalizeFn(Math.max, [a, b]);
 }
 export const max = dualImpl({
     name: 'max',
@@ -581,10 +525,7 @@ export const max = dualImpl({
     sideEffects: false,
 });
 function cpuMin(a, b) {
-    if (typeof a === 'number') {
-        return Math.min(a, b);
-    }
-    return VectorOps.min[a.kind](a, b);
+    return generalizeFn(Math.min, [a, b]);
 }
 export const min = dualImpl({
     name: 'min',
@@ -594,16 +535,7 @@ export const min = dualImpl({
     sideEffects: false,
 });
 function cpuMix(e1, e2, e3) {
-    if (typeof e1 === 'number') {
-        if (typeof e3 !== 'number' || typeof e2 !== 'number') {
-            throw new Error('When e1 and e2 are numbers, the blend factor must be a number.');
-        }
-        return (e1 * (1 - e3) + e2 * e3);
-    }
-    if (typeof e1 === 'number' || typeof e2 === 'number') {
-        throw new Error('e1 and e2 need to both be vectors of the same kind.');
-    }
-    return VectorOps.mix[e1.kind](e1, e2, e3);
+    return generalizeFn((e1, e2, e3) => e1 * (1 - e3) + e2 * e3, [e1, ...upCast([e2, e3])]);
 }
 export const mix = dualImpl({
     name: 'mix',
@@ -655,18 +587,15 @@ export const modf = dualImpl({
 export const normalize = dualImpl({
     name: 'normalize',
     signature: unifyRestrictedSignature(anyFloatVec),
-    normalImpl: (v) => VectorOps.normalize[v.kind](v),
+    normalImpl: (v) => {
+        const len = length(v);
+        return generalizeFn((e) => e / len, [v]);
+    },
     codegenImpl: (_ctx, [value]) => stitch `normalize(${value})`,
     sideEffects: false,
 });
 function powCpu(base, exponent) {
-    if (typeof base === 'number' && typeof exponent === 'number') {
-        return (base ** exponent);
-    }
-    if (isVecInstance(base) && isVecInstance(exponent)) {
-        return VectorOps.pow[base.kind](base, exponent);
-    }
-    throw new Error(`Invalid arguments to pow(): '${base}' '${exponent}'`);
+    return generalizeFn((a, b) => a ** b, [base, exponent]);
 }
 export const pow = dualImpl({
     name: 'pow',
@@ -775,10 +704,7 @@ export const saturate = dualImpl({
     sideEffects: false,
 });
 function cpuSign(e) {
-    if (typeof e === 'number') {
-        return Math.sign(e);
-    }
-    return VectorOps.sign[e.kind](e);
+    return generalizeFn(Math.sign, [e]);
 }
 export const sign = dualImpl({
     name: 'sign',
@@ -795,10 +721,7 @@ export const sign = dualImpl({
     sideEffects: false,
 });
 function cpuSin(value) {
-    if (typeof value === 'number') {
-        return Math.sin(value);
-    }
-    return VectorOps.sin[value.kind](value);
+    return generalizeFn(Math.sin, [value]);
 }
 export const sin = dualImpl({
     name: 'sin',
@@ -808,10 +731,7 @@ export const sin = dualImpl({
     sideEffects: false,
 });
 function cpuSinh(value) {
-    if (typeof value === 'number') {
-        return Math.sinh(value);
-    }
-    throw new MissingCpuImplError('CPU implementation for sinh on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues');
+    return generalizeFn(Math.sinh, [value]);
 }
 export const sinh = dualImpl({
     name: 'sinh',
@@ -821,10 +741,7 @@ export const sinh = dualImpl({
     sideEffects: false,
 });
 function cpuSmoothstep(edge0, edge1, x) {
-    if (typeof x === 'number') {
-        return smoothstepScalar(edge0, edge1, x);
-    }
-    return VectorOps.smoothstep[x.kind](edge0, edge1, x);
+    return generalizeFn(smoothstepScalar, [edge0, edge1, x]);
 }
 export const smoothstep = dualImpl({
     name: 'smoothstep',
@@ -834,10 +751,7 @@ export const smoothstep = dualImpl({
     sideEffects: false,
 });
 function cpuSqrt(value) {
-    if (typeof value === 'number') {
-        return Math.sqrt(value);
-    }
-    return VectorOps.sqrt[value.kind](value);
+    return generalizeFn(Math.sqrt, [value]);
 }
 export const sqrt = dualImpl({
     name: 'sqrt',
@@ -873,10 +787,7 @@ export const tan = dualImpl({
     sideEffects: false,
 });
 function cpuTanh(value) {
-    if (typeof value === 'number') {
-        return Math.tanh(value);
-    }
-    return VectorOps.tanh[value.kind](value);
+    return generalizeFn(Math.tanh, [value]);
 }
 export const tanh = dualImpl({
     name: 'tanh',
@@ -954,3 +865,27 @@ export const trunc = dualImpl({
     codegenImpl: (_ctx, [value]) => stitch `trunc(${value})`,
     sideEffects: false,
 });
+function cpuIntdiv(lhs, rhs) {
+    if (typeof lhs !== 'number' || typeof rhs !== 'number') {
+        throw new Error('std.intdiv called with invalid arguments.');
+    }
+    return Math.trunc(Math.trunc(lhs) / Math.trunc(rhs));
+}
+/**
+ * Performs integer division on the passed in scalars.
+ * Equivalent to `trunc(trunc(lhs) / trunc(rhs))`. Coerces both
+ * arguments to integers if they're floating point.
+ */
+export const intdiv = dualImpl({
+    name: 'intdiv',
+    signature: (lhs, rhs) => {
+        const unified = unify([lhs, rhs], [u32, i32]);
+        if (!unified) {
+            throw new SignatureNotSupportedError([lhs, rhs], [u32, i32, abstractInt]);
+        }
+        return { argTypes: unified, returnType: unified[0] };
+    },
+    normalImpl: cpuIntdiv,
+    codegenImpl: (ctx, [lhs, rhs]) => ctx.gen.emitBinaryOp(lhs, '/', rhs),
+    sideEffects: false,
+});