typegpu 0.10.2 → 0.11.0

package/std/numeric.d.ts

@@ -6,249 +6,195 @@ import { Infer } from "../shared/repr.js";
 type NumVec = AnyNumericVecInstance;
 declare function cpuAbs(value: number): number;
 declare function cpuAbs<T extends NumVec | number>(value: T): T;
-declare const abs: DualFn<typeof cpuAbs>;
+declare const abs: DualFn;
 declare function cpuAcos(value: number): number;
 declare function cpuAcos<T extends AnyFloatVecInstance>(value: T): T;
-declare const acos: DualFn<typeof cpuAcos>;
+declare const acos: DualFn;
 declare function cpuAcosh(value: number): number;
 declare function cpuAcosh<T extends AnyFloatVecInstance>(value: T): T;
-declare const acosh: DualFn<typeof cpuAcosh>;
+declare const acosh: DualFn;
 declare function cpuAsin(value: number): number;
 declare function cpuAsin<T extends AnyFloatVecInstance>(value: T): T;
-declare const asin: DualFn<typeof cpuAsin>;
+declare const asin: DualFn;
 declare function cpuAsinh(value: number): number;
 declare function cpuAsinh<T extends AnyFloatVecInstance>(value: T): T;
-declare const asinh: DualFn<typeof cpuAsinh>;
+declare const asinh: DualFn;
 declare function cpuAtan(value: number): number;
 declare function cpuAtan<T extends AnyFloatVecInstance>(value: T): T;
-declare const atan: DualFn<typeof cpuAtan>;
+declare const atan: DualFn;
 declare function cpuAtanh(value: number): number;
 declare function cpuAtanh<T extends AnyFloatVecInstance>(value: T): T;
-declare const atanh: DualFn<typeof cpuAtanh>;
+declare const atanh: DualFn;
 declare function cpuAtan2(y: number, x: number): number;
 declare function cpuAtan2<T extends AnyFloatVecInstance>(y: T, x: T): T;
-declare const atan2: DualFn<typeof cpuAtan2>;
+declare const atan2: DualFn;
 declare function cpuCeil(value: number): number;
 declare function cpuCeil<T extends AnyFloatVecInstance>(value: T): T;
-declare const ceil: DualFn<typeof cpuCeil>;
+declare const ceil: DualFn;
 declare function cpuClamp(value: number, low: number, high: number): number;
 declare function cpuClamp<T extends NumVec | number>(value: T, low: T, high: T): T;
-declare const clamp: DualFn<typeof cpuClamp>;
+declare const clamp: DualFn;
 declare function cpuCos(value: number): number;
 declare function cpuCos<T extends AnyFloatVecInstance>(value: T): T;
-declare const cos: DualFn<typeof cpuCos>;
+declare const cos: DualFn;
 declare function cpuCosh(value: number): number;
 declare function cpuCosh<T extends AnyFloatVecInstance>(value: T): T;
-declare const cosh: DualFn<typeof cpuCosh>;
+declare const cosh: DualFn;
 declare function cpuCountLeadingZeros(value: number): number;
 declare function cpuCountLeadingZeros<T extends AnyIntegerVecInstance>(value: T): T;
-declare const countLeadingZeros: DualFn<typeof cpuCountLeadingZeros>;
+declare const countLeadingZeros: DualFn;
 declare function cpuCountOneBits(value: number): number;
 declare function cpuCountOneBits<T extends AnyIntegerVecInstance>(value: T): T;
-declare const countOneBits: DualFn<typeof cpuCountOneBits>;
+declare const countOneBits: DualFn;
 declare function cpuCountTrailingZeros(value: number): number;
 declare function cpuCountTrailingZeros<T extends AnyIntegerVecInstance>(value: T): T;
-declare const countTrailingZeros: DualFn<typeof cpuCountTrailingZeros>;
-declare const cross: DualFn<(<T extends v3f | v3h>(a: T, b: T) => T)>;
+declare const countTrailingZeros: DualFn;
+declare const cross: DualFn;
 declare function cpuDegrees(value: number): number;
 declare function cpuDegrees<T extends AnyFloatVecInstance>(value: T): T;
-declare const degrees: DualFn<typeof cpuDegrees>;
-declare const determinant: DualFn<(value: AnyMatInstance) => number>;
+declare const degrees: DualFn;
+declare const determinant: DualFn;
 declare function cpuDistance(a: number, b: number): number;
 declare function cpuDistance<T extends AnyFloatVecInstance>(a: T, b: T): number;
-declare const distance: DualFn<typeof cpuDistance>;
-declare const dot: DualFn<(<T extends NumVec>(lhs: T, rhs: T) => number)>;
-declare const dot4U8Packed: DualFn<(e1: number, e2: number) => number>;
-declare const dot4I8Packed: DualFn<(e1: number, e2: number) => number>;
+declare const distance: DualFn;
+declare const dot: DualFn;
+declare const dot4U8Packed: DualFn;
+declare const dot4I8Packed: DualFn;
 declare function cpuExp(value: number): number;
 declare function cpuExp<T extends AnyFloatVecInstance>(value: T): T;
-declare const exp: DualFn<typeof cpuExp>;
+declare const exp: DualFn;
 declare function cpuExp2(value: number): number;
 declare function cpuExp2<T extends AnyFloatVecInstance>(value: T): T;
-declare const exp2: DualFn<typeof cpuExp2>;
+declare const exp2: DualFn;
 declare function cpuExtractBits(e: number, offset: number, count: number): number;
 declare function cpuExtractBits<T extends AnyIntegerVecInstance>(e: T, offset: number, count: number): T;
-declare const extractBits: DualFn<typeof cpuExtractBits>;
-declare const faceForward: DualFn<(<T extends AnyFloatVecInstance>(e1: T, e2: T, e3: T) => T)>;
+declare const extractBits: DualFn;
+declare const faceForward: DualFn;
 declare function cpuFirstLeadingBit(value: number): number;
 declare function cpuFirstLeadingBit<T extends AnyIntegerVecInstance>(value: T): T;
-declare const firstLeadingBit: DualFn<typeof cpuFirstLeadingBit>;
+declare const firstLeadingBit: DualFn;
 declare function cpuFirstTrailingBit(value: number): number;
 declare function cpuFirstTrailingBit<T extends AnyIntegerVecInstance>(value: T): T;
-declare const firstTrailingBit: DualFn<typeof cpuFirstTrailingBit>;
+declare const firstTrailingBit: DualFn;
 declare function cpuFloor(value: number): number;
 declare function cpuFloor<T extends AnyFloatVecInstance>(value: T): T;
-declare const floor: DualFn<typeof cpuFloor>;
+declare const floor: DualFn;
 declare function cpuFma(e1: number, e2: number, e3: number): number;
 declare function cpuFma<T extends AnyFloatVecInstance>(e1: T, e2: T, e3: T): T;
-declare const fma: DualFn<typeof cpuFma>;
+declare const fma: DualFn;
 declare function cpuFract(value: number): number;
 declare function cpuFract<T extends AnyFloatVecInstance>(value: T): T;
-declare const fract: DualFn<typeof cpuFract>;
+declare const fract: DualFn;
 declare const FrexpResults: {
-  readonly f32: WgslStruct<{
-    fract: F32;
-    exp: I32;
-  }>;
-  readonly f16: WgslStruct<{
-    fract: F16;
-    exp: I32;
-  }>;
-  readonly abstractFloat: WgslStruct<{
-    fract: AbstractFloat;
-    exp: AbstractInt;
-  }>;
-  readonly vec2f: WgslStruct<{
-    fract: Vec2f;
-    exp: Vec2i;
-  }>;
-  readonly vec3f: WgslStruct<{
-    fract: Vec3f;
-    exp: Vec3i;
-  }>;
-  readonly vec4f: WgslStruct<{
-    fract: Vec4f;
-    exp: Vec4i;
-  }>;
-  readonly vec2h: WgslStruct<{
-    fract: Vec2h;
-    exp: Vec2i;
-  }>;
-  readonly vec3h: WgslStruct<{
-    fract: Vec3h;
-    exp: Vec3i;
-  }>;
-  readonly vec4h: WgslStruct<{
-    fract: Vec4h;
-    exp: Vec4i;
-  }>;
+  readonly f32: WgslStruct;
+  readonly f16: WgslStruct;
+  readonly abstractFloat: WgslStruct;
+  readonly vec2f: WgslStruct;
+  readonly vec3f: WgslStruct;
+  readonly vec4f: WgslStruct;
+  readonly vec2h: WgslStruct;
+  readonly vec3h: WgslStruct;
+  readonly vec4h: WgslStruct;
 };
 type FrexpOverload = {
   (value: number): Infer<(typeof FrexpResults)['f32']>;
   <T extends AnyFloatVecInstance>(value: T): Infer<(typeof FrexpResults)[T['kind']]>;
 };
-declare const frexp: DualFn<FrexpOverload>;
+declare const frexp: DualFn;
 declare function cpuInsertBits(e: number, newbits: number, offset: number, count: number): number;
 declare function cpuInsertBits<T extends AnyIntegerVecInstance>(e: T, newbits: T, offset: number, count: number): T;
-declare const insertBits: DualFn<typeof cpuInsertBits>;
+declare const insertBits: DualFn;
 declare function cpuInverseSqrt(value: number): number;
 declare function cpuInverseSqrt<T extends AnyFloatVecInstance>(value: T): T;
-declare const inverseSqrt: DualFn<typeof cpuInverseSqrt>;
+declare const inverseSqrt: DualFn;
 declare function cpuLdexp(e1: number, e2: number): number;
 declare function cpuLdexp<T extends v2f | v2h>(e1: T, e2: v2i): T;
 declare function cpuLdexp<T extends v3f | v3h>(e1: T, e2: v3i): T;
 declare function cpuLdexp<T extends v4f | v4h>(e1: T, e2: v4i): T;
-declare const ldexp: DualFn<typeof cpuLdexp>;
+declare const ldexp: DualFn;
 declare function cpuLength(value: number): number;
 declare function cpuLength<T extends AnyFloatVecInstance>(value: T): number;
-declare const length: DualFn<typeof cpuLength>;
+declare const length: DualFn;
 declare function cpuLog(value: number): number;
 declare function cpuLog<T extends AnyFloatVecInstance>(value: T): T;
-declare const log: DualFn<typeof cpuLog>;
+declare const log: DualFn;
 declare function cpuLog2(value: number): number;
 declare function cpuLog2<T extends AnyFloatVecInstance>(value: T): T;
-declare const log2: DualFn<typeof cpuLog2>;
+declare const log2: DualFn;
 type VariadicOverload = {
   (fst: number, ...rest: number[]): number;
   <T extends NumVec>(fst: T, ...rest: T[]): T;
 };
-declare const max: DualFn<VariadicOverload>;
-declare const min: DualFn<VariadicOverload>;
+declare const max: DualFn;
+declare const min: DualFn;
 declare function cpuMix(e1: number, e2: number, e3: number): number;
 declare function cpuMix<T extends AnyFloatVecInstance>(e1: T, e2: T, e3: number): T;
 declare function cpuMix<T extends AnyFloatVecInstance>(e1: T, e2: T, e3: T): T;
-declare const mix: DualFn<typeof cpuMix>;
+declare const mix: DualFn;
 declare const ModfResult: {
-  readonly f32: WgslStruct<{
-    fract: F32;
-    whole: F32;
-  }>;
-  readonly f16: WgslStruct<{
-    fract: F16;
-    whole: F16;
-  }>;
-  readonly abstractFloat: WgslStruct<{
-    fract: AbstractFloat;
-    whole: AbstractFloat;
-  }>;
-  readonly vec2f: WgslStruct<{
-    fract: Vec2f;
-    whole: Vec2f;
-  }>;
-  readonly vec3f: WgslStruct<{
-    fract: Vec3f;
-    whole: Vec3f;
-  }>;
-  readonly vec4f: WgslStruct<{
-    fract: Vec4f;
-    whole: Vec4f;
-  }>;
-  readonly vec2h: WgslStruct<{
-    fract: Vec2h;
-    whole: Vec2h;
-  }>;
-  readonly vec3h: WgslStruct<{
-    fract: Vec3h;
-    whole: Vec3h;
-  }>;
-  readonly vec4h: WgslStruct<{
-    fract: Vec4h;
-    whole: Vec4h;
-  }>;
+  readonly f32: WgslStruct;
+  readonly f16: WgslStruct;
+  readonly abstractFloat: WgslStruct;
+  readonly vec2f: WgslStruct;
+  readonly vec3f: WgslStruct;
+  readonly vec4f: WgslStruct;
+  readonly vec2h: WgslStruct;
+  readonly vec3h: WgslStruct;
+  readonly vec4h: WgslStruct;
 };
 type ModfOverload = {
   (value: number): Infer<(typeof ModfResult)['f32']>;
   <T extends AnyFloatVecInstance>(value: T): Infer<(typeof ModfResult)[T['kind']]>;
 };
 declare const modf: ModfOverload;
-declare const normalize: DualFn<(<T extends AnyFloatVecInstance>(v: T) => T)>;
+declare const normalize: DualFn;
 declare function powCpu(base: number, exponent: number): number;
 declare function powCpu<T extends AnyFloatVecInstance>(base: T, exponent: T): T;
-declare const pow: DualFn<typeof powCpu>;
+declare const pow: DualFn;
 declare function cpuQuantizeToF16(value: number): number;
 declare function cpuQuantizeToF16<T extends AnyFloat32VecInstance>(value: T): T;
-declare const quantizeToF16: DualFn<typeof cpuQuantizeToF16>;
+declare const quantizeToF16: DualFn;
 declare function cpuRadians(value: number): number;
 declare function cpuRadians<T extends AnyFloatVecInstance | number>(value: T): T;
-declare const radians: DualFn<typeof cpuRadians>;
-declare const reflect: DualFn<(<T extends AnyFloatVecInstance>(e1: T, e2: T) => T)>;
-declare const refract: DualFn<(<T extends AnyFloatVecInstance>(e1: T, e2: T, e3: number) => T)>;
+declare const radians: DualFn;
+declare const reflect: DualFn;
+declare const refract: DualFn;
 declare function cpuReverseBits(value: number): number;
 declare function cpuReverseBits<T extends AnyIntegerVecInstance>(value: T): T;
-declare const reverseBits: DualFn<typeof cpuReverseBits>;
+declare const reverseBits: DualFn;
 declare function cpuRound(value: number): number;
 declare function cpuRound<T extends AnyFloatVecInstance>(value: T): T;
-declare const round: DualFn<typeof cpuRound>;
+declare const round: DualFn;
 declare function cpuSaturate(value: number): number;
 declare function cpuSaturate<T extends AnyFloatVecInstance>(value: T): T;
-declare const saturate: DualFn<typeof cpuSaturate>;
+declare const saturate: DualFn;
 declare function cpuSign(e: number): number;
 declare function cpuSign<T extends AnySignedVecInstance>(e: T): T;
-declare const sign: DualFn<typeof cpuSign>;
+declare const sign: DualFn;
 declare function cpuSin(value: number): number;
 declare function cpuSin<T extends AnyFloatVecInstance>(value: T): T;
-declare const sin: DualFn<typeof cpuSin>;
+declare const sin: DualFn;
 declare function cpuSinh(value: number): number;
 declare function cpuSinh<T extends AnyFloatVecInstance>(value: T): T;
-declare const sinh: DualFn<typeof cpuSinh>;
+declare const sinh: DualFn;
 declare function cpuSmoothstep(edge0: number, edge1: number, x: number): number;
 declare function cpuSmoothstep<T extends AnyFloatVecInstance>(edge0: T, edge1: T, x: T): T;
-declare const smoothstep: DualFn<typeof cpuSmoothstep>;
+declare const smoothstep: DualFn;
 declare function cpuSqrt(value: number): number;
 declare function cpuSqrt<T extends AnyFloatVecInstance>(value: T): T;
-declare const sqrt: DualFn<typeof cpuSqrt>;
+declare const sqrt: DualFn;
 declare function cpuStep(edge: number, x: number): number;
 declare function cpuStep<T extends AnyFloatVecInstance | number>(edge: T, x: T): T;
-declare const step: DualFn<typeof cpuStep>;
+declare const step: DualFn;
 declare function cpuTan(value: number): number;
 declare function cpuTan<T extends AnyFloatVecInstance>(value: T): T;
-declare const tan: DualFn<typeof cpuTan>;
+declare const tan: DualFn;
 declare function cpuTanh(value: number): number;
 declare function cpuTanh<T extends AnyFloatVecInstance>(value: T): T;
-declare const tanh: DualFn<typeof cpuTanh>;
-declare const transpose: DualFn<(<T extends AnyMatInstance>(e: T) => T)>;
+declare const tanh: DualFn;
+declare const transpose: DualFn;
 declare function cpuTrunc(value: number): number;
 declare function cpuTrunc<T extends AnyFloatVecInstance>(value: T): T;
-declare const trunc: DualFn<typeof cpuTrunc>;
+declare const trunc: DualFn;
 //#endregion
 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 };

package/std/numeric.js

@@ -10,7 +10,6 @@ import { mat2x2f, mat3x3f, mat4x4f } from "../data/matrix.js";
 import { smoothstepScalar } from "../data/numberOps.js";
 import { VectorOps } from "../data/vectorOps.js";
 import { mul, sub } from "./operators.js";
-
 //#region src/std/numeric.ts
 const unaryIdentitySignature = (arg) => {
 	return {
@@ -842,6 +841,5 @@ const trunc = dualImpl({
 	normalImpl: "CPU implementation for trunc not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
 	codegenImpl: (_ctx, [value]) => stitch`trunc(${value})`
 });
-
 //#endregion
-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 };
+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 };

package/std/operators.d.ts

@@ -1,5 +1,5 @@
 import { DualFn } from "../types.js";
-import { AnyMatInstance, AnyNumericVecInstance, mBaseForVec, vBaseForMat } from "../data/wgslTypes.js";
+import { AnyIntegerVecInstance, AnyMatInstance, AnyNumericVecInstance, mBaseForVec, vBaseForMat, vecIToVecU } from "../data/wgslTypes.js";
 
 //#region src/std/operators.d.ts
 type NumVec = AnyNumericVecInstance;
@@ -9,13 +9,13 @@ declare function cpuAdd<T extends NumVec>(lhs: number, rhs: T): T;
 declare function cpuAdd<T extends NumVec>(lhs: T, rhs: number): T;
 declare function cpuAdd<T extends NumVec | Mat>(lhs: T, rhs: T): T;
 declare function cpuAdd<Lhs extends number | NumVec | Mat, Rhs extends (Lhs extends number ? number | NumVec : Lhs extends NumVec ? number | Lhs : Lhs extends Mat ? Lhs : never)>(lhs: Lhs, rhs: Rhs): Lhs | Rhs;
-declare const add: DualFn<typeof cpuAdd>;
+declare const add: DualFn;
 declare function cpuSub(lhs: number, rhs: number): number;
 declare function cpuSub<T extends NumVec>(lhs: number, rhs: T): T;
 declare function cpuSub<T extends NumVec>(lhs: T, rhs: number): T;
 declare function cpuSub<T extends NumVec | Mat>(lhs: T, rhs: T): T;
 declare function cpuSub<Lhs extends number | NumVec | Mat, Rhs extends (Lhs extends number ? number | NumVec : Lhs extends NumVec ? number | Lhs : Lhs extends Mat ? Lhs : never)>(lhs: Lhs, rhs: Rhs): Lhs | Rhs;
-declare const sub: DualFn<typeof cpuSub>;
+declare const sub: DualFn;
 declare function cpuMul(lhs: number, rhs: number): number;
 declare function cpuMul<MV extends NumVec | Mat>(lhs: number, rhs: MV): MV;
 declare function cpuMul<MV extends NumVec | Mat>(lhs: MV, rhs: number): MV;
@@ -24,12 +24,12 @@ declare function cpuMul<M extends Mat, V extends vBaseForMat<M>>(lhs: V, rhs: M)
 declare function cpuMul<M extends Mat, V extends vBaseForMat<M>>(lhs: M, rhs: V): V;
 declare function cpuMul<M extends Mat>(lhs: M, rhs: M): M;
 declare function cpuMul<Lhs extends number | NumVec | Mat, Rhs extends (Lhs extends number ? number | NumVec | Mat : Lhs extends NumVec ? number | Lhs | mBaseForVec<Lhs> : Lhs extends Mat ? number | vBaseForMat<Lhs> | Lhs : never)>(lhs: Lhs, rhs: Rhs): Lhs | Rhs;
-declare const mul: DualFn<typeof cpuMul>;
+declare const mul: DualFn;
 declare function cpuDiv(lhs: number, rhs: number): number;
 declare function cpuDiv<T extends NumVec>(lhs: T, rhs: T): T;
 declare function cpuDiv<T extends NumVec>(lhs: number, rhs: T): T;
 declare function cpuDiv<T extends NumVec>(lhs: T, rhs: number): T;
-declare const div: DualFn<typeof cpuDiv>;
+declare const div: DualFn;
 type ModOverload = {
   (a: number, b: number): number;
   <T extends NumVec>(a: T, b: T): T;
@@ -40,9 +40,17 @@ type ModOverload = {
  * @privateRemarks
  * Both JS and WGSL implementations use truncated definition of modulo
  */
-declare const mod: DualFn<ModOverload>;
+declare const mod: DualFn;
 declare function cpuNeg(value: number): number;
 declare function cpuNeg<T extends NumVec>(value: T): T;
-declare const neg: DualFn<typeof cpuNeg>;
+declare const neg: DualFn;
+declare function cpuBitShiftLeft(lhs: number, rhs: number): number;
+declare function cpuBitShiftLeft<T extends AnyIntegerVecInstance>(lhs: T, rhs: number): T;
+declare function cpuBitShiftLeft<T extends AnyIntegerVecInstance>(lhs: T, rhs: vecIToVecU<T>): T;
+declare const bitShiftLeft: DualFn;
+declare function cpuBitShiftRight(lhs: number, rhs: number): number;
+declare function cpuBitShiftRight<T extends AnyIntegerVecInstance>(lhs: T, rhs: number): T;
+declare function cpuBitShiftRight<T extends AnyIntegerVecInstance>(lhs: T, rhs: vecIToVecU<T>): T;
+declare const bitShiftRight: DualFn;
 //#endregion
-export { add, div, mod, mul, neg, sub };
+export { add, bitShiftLeft, bitShiftRight, div, mod, mul, neg, sub };

package/std/operators.js

@@ -1,12 +1,11 @@
-import { isFloat32VecInstance, isMat, isMatInstance, isVec, isVecInstance } from "../data/wgslTypes.js";
+import { isFloat32VecInstance, isInteger32VecInstance, isMat, isMatInstance, isUint32VecInstance, isVec, isVecInstance } from "../data/wgslTypes.js";
 import { SignatureNotSupportedError } from "../errors.js";
 import { stitch } from "../core/resolve/stitch.js";
 import { unify } from "../tgsl/conversion.js";
-import { abstractFloat, f16, f32 } from "../data/numeric.js";
-import { vecTypeToConstructor } from "../data/vector.js";
+import { abstractFloat, f16, f32, i32, u32 } from "../data/numeric.js";
+import { vec2i, vec2u, vec3i, vec3u, vec4i, vec4u, vecTypeToConstructor } from "../data/vector.js";
 import { dualImpl } from "../core/function/dualImpl.js";
 import { VectorOps } from "../data/vectorOps.js";
-
 //#region src/std/operators.ts
 const getPrimitive = (t) => "primitive" in t ? t.primitive : t;
 const makeBinarySignature = (opts) => (lhs, rhs) => {
@@ -148,6 +147,81 @@ const neg = dualImpl({
 	normalImpl: cpuNeg,
 	codegenImpl: (_ctx, [arg]) => stitch`-(${arg})`
 });
-
+const anyConcreteInteger = [
+	i32,
+	u32,
+	vec2i,
+	vec3i,
+	vec4i,
+	vec2u,
+	vec3u,
+	vec4u
+];
+const intVecToUnsignedVec = {
+	vec2i: vec2u,
+	vec2u,
+	vec3i: vec3u,
+	vec3u,
+	vec4i: vec4u,
+	vec4u
+};
+const bitShiftSignature = (lhs, rhs) => {
+	const lhsUnified = unify([lhs], anyConcreteInteger)?.[0];
+	if (!lhsUnified) throw new SignatureNotSupportedError([lhs], anyConcreteInteger);
+	let rhsType;
+	if (isVec(lhsUnified)) {
+		const cc = lhsUnified.componentCount;
+		const vecU = cc === 2 ? vec2u : cc === 3 ? vec3u : vec4u;
+		const rhsUnified = unify([rhs], [u32, vecU])?.[0];
+		if (!rhsUnified) throw new SignatureNotSupportedError([rhs], [u32, vecU]);
+		rhsType = rhsUnified;
+	} else rhsType = u32;
+	return {
+		argTypes: [lhsUnified, rhsType],
+		returnType: lhsUnified
+	};
+};
+function cpuBitShiftLeft(lhs, rhs) {
+	if (typeof lhs === "number" && typeof rhs === "number") return lhs << rhs;
+	if (isInteger32VecInstance(lhs) && isUint32VecInstance(rhs) && lhs.length == rhs.length) return VectorOps.bitShiftLeft[lhs.kind](lhs, rhs);
+	if (isInteger32VecInstance(lhs) && typeof rhs === "number") {
+		const rhsVec = intVecToUnsignedVec[lhs.kind](rhs);
+		return VectorOps.bitShiftLeft[lhs.kind](lhs, rhsVec);
+	}
+	throw new Error("bitShiftLeft called with invalid arguments, expected types: number or integer vector (rhs must be the same arity as lhs).");
+}
+const bitShiftLeft = dualImpl({
+	name: "bitShiftLeft",
+	signature: bitShiftSignature,
+	normalImpl: cpuBitShiftLeft,
+	codegenImpl: (_ctx, [lhs, rhs]) => {
+		if (isVec(lhs.dataType) && !isVec(rhs.dataType)) {
+			const cc = lhs.dataType.componentCount;
+			return stitch`(${lhs} << ${cc === 2 ? "vec2u" : cc === 3 ? "vec3u" : "vec4u"}(${rhs}))`;
+		}
+		return stitch`(${lhs} << ${rhs})`;
+	}
+});
+function cpuBitShiftRight(lhs, rhs) {
+	if (typeof lhs === "number" && typeof rhs === "number") return lhs >> rhs;
+	if (isInteger32VecInstance(lhs) && isUint32VecInstance(rhs) && lhs.length == rhs.length) return VectorOps.bitShiftRight[lhs.kind](lhs, rhs);
+	if (isInteger32VecInstance(lhs) && typeof rhs === "number") {
+		const rhsVec = intVecToUnsignedVec[lhs.kind](rhs);
+		return VectorOps.bitShiftRight[lhs.kind](lhs, rhsVec);
+	}
+	throw new Error("bitShiftRight called with invalid arguments, expected types: number or integer vector (rhs must be the same arity as lhs).");
+}
+const bitShiftRight = dualImpl({
+	name: "bitShiftRight",
+	signature: bitShiftSignature,
+	normalImpl: cpuBitShiftRight,
+	codegenImpl: (_ctx, [lhs, rhs]) => {
+		if (isVec(lhs.dataType) && !isVec(rhs.dataType)) {
+			const cc = lhs.dataType.componentCount;
+			return stitch`(${lhs} >> ${cc === 2 ? "vec2u" : cc === 3 ? "vec3u" : "vec4u"}(${rhs}))`;
+		}
+		return stitch`(${lhs} >> ${rhs})`;
+	}
+});
 //#endregion
-export { add, div, mod, mul, neg, sub };
+export { add, bitShiftLeft, bitShiftRight, div, mod, mul, neg, sub };

package/std/packing.d.ts

@@ -6,21 +6,21 @@ import { v2f, v4f } from "../data/wgslTypes.js";
  * @privateRemarks
  * https://gpuweb.github.io/gpuweb/wgsl/#unpack2x16float-builtin
  */
-declare const unpack2x16float: DualFn<(e: number) => v2f>;
+declare const unpack2x16float: DualFn;
 /**
  * @privateRemarks
  * https://gpuweb.github.io/gpuweb/wgsl/#pack2x16float-builtin
  */
-declare const pack2x16float: DualFn<(e: v2f) => number>;
+declare const pack2x16float: DualFn;
 /**
  * @privateRemarks
  * https://gpuweb.github.io/gpuweb/wgsl/#unpack4x8unorm-builtin
  */
-declare const unpack4x8unorm: DualFn<(e: number) => v4f>;
+declare const unpack4x8unorm: DualFn;
 /**
  * @privateRemarks
  * https://gpuweb.github.io/gpuweb/wgsl/#pack4x8unorm-builtin
  */
-declare const pack4x8unorm: DualFn<(e: v4f) => number>;
+declare const pack4x8unorm: DualFn;
 //#endregion
 export { pack2x16float, pack4x8unorm, unpack2x16float, unpack4x8unorm };

package/std/packing.js

@@ -3,7 +3,6 @@ import { u32 } from "../data/numeric.js";
 import { vec2f, vec4f } from "../data/vector.js";
 import { dualImpl } from "../core/function/dualImpl.js";
 import * as TB from "typed-binary";
-
 //#region src/std/packing.ts
 /**
 * @privateRemarks
@@ -81,6 +80,5 @@ const pack4x8unorm = dualImpl({
 	},
 	codegenImpl: (_ctx, [e]) => stitch`pack4x8unorm(${e})`
 });
-
 //#endregion
-export { pack2x16float, pack4x8unorm, unpack2x16float, unpack4x8unorm };
+export { pack2x16float, pack4x8unorm, unpack2x16float, unpack4x8unorm };

package/std/range.d.ts

@@ -0,0 +1,24 @@
+import { TgpuComptime } from "../core/function/comptime.js";
+//#region src/std/range.d.ts
+interface TgpuRange extends Array<number> {
+  start: number;
+  end: number;
+  step: number;
+}
+/**
+ * Returns an array of values between `start` (inclusive) and `end` (exclusive) with the given `step`.
+ *
+ * If only one argument is provided, it is interpreted as `end`, with `start=0` and `step=1`.
+ *
+ * ```ts
+ * let result = d.f32(1);
+ * for (const i of std.range(5)) {
+ *   result *= i + 1;
+ * }
+ * ```
+ *
+ * Can also be combined with `tgpu.unroll` to unroll a specific number of iterations.
+ */
+declare const range: TgpuComptime;
+//#endregion
+export { range };

package/std/range.js

@@ -0,0 +1,38 @@
+import { comptime } from "../core/function/comptime.js";
+//#region src/std/range.ts
+/**
+* Returns an array of values between `start` (inclusive) and `end` (exclusive) with the given `step`.
+*
+* If only one argument is provided, it is interpreted as `end`, with `start=0` and `step=1`.
+*
+* ```ts
+* let result = d.f32(1);
+* for (const i of std.range(5)) {
+*   result *= i + 1;
+* }
+* ```
+*
+* Can also be combined with `tgpu.unroll` to unroll a specific number of iterations.
+*/
+const range = comptime((start, end, step = 1) => {
+	if (end === void 0) {
+		end = start;
+		start = 0;
+	}
+	if (!Number.isInteger(start)) throw new Error(`'start' must be an integer, got ${start}`);
+	if (!Number.isInteger(end)) throw new Error(`'end' must be an integer, got ${end}`);
+	if (!Number.isInteger(step) || step === 0) throw new Error(`'step' must be a non-zero integer, got ${step}`);
+	const result = [];
+	result.start = start;
+	result.end = end;
+	result.step = step;
+	if (Math.sign(step) !== Math.sign(end - start)) return result;
+	if (step > 0) for (let i = start; i < end; i += step) result.push(i);
+	if (step < 0) for (let i = start; i > end; i += step) result.push(i);
+	return result;
+});
+function isTgpuRange(value) {
+	return Array.isArray(value) && "start" in value && "end" in value && "step" in value;
+}
+//#endregion
+export { isTgpuRange, range };