typegpu 0.10.0 → 0.10.2

package/std/matrix.d.ts

@@ -0,0 +1,41 @@
+import { DualFn } from "../types.js";
+import { m4x4f, v3f } from "../data/wgslTypes.js";
+
+//#region src/std/matrix.d.ts
+/**
+ * Translates the given 4-by-4 matrix by the given vector.
+ * @param {m4x4f} matrix - The matrix to be modified.
+ * @param {v3f} vector - The vector by which to translate the matrix.
+ * @returns {m4x4f} The translated matrix.
+ */
+declare const translate4: DualFn<(matrix: m4x4f, vector: v3f) => m4x4f>;
+/**
+ * Scales the given 4-by-4 matrix in each dimension by an amount given by the corresponding entry in the given vector.
+ * @param {m4x4f} matrix - The matrix to be modified.
+ * @param {v3f} vector - A vector of three entries specifying the factor by which to scale in each dimension.
+ * @returns {m4x4f} The scaled matrix.
+ */
+declare const scale4: DualFn<(matrix: m4x4f, vector: v3f) => m4x4f>;
+/**
+ * Rotates the given 4-by-4 matrix around the x-axis by the given angle.
+ * @param {m4x4f} matrix - The matrix to be modified.
+ * @param {number} angle - The angle by which to rotate (in radians).
+ * @returns {m4x4f} The rotated matrix.
+ */
+declare const rotateX4: DualFn<(matrix: m4x4f, angle: number) => m4x4f>;
+/**
+ * Rotates the given 4-by-4 matrix around the y-axis by the given angle.
+ * @param {m4x4f} matrix - The matrix to be modified.
+ * @param {number} angle - The angle by which to rotate (in radians).
+ * @returns {m4x4f} The rotated matrix.
+ */
+declare const rotateY4: DualFn<(matrix: m4x4f, angle: number) => m4x4f>;
+/**
+ * Rotates the given 4-by-4 matrix around the z-axis by the given angle.
+ * @param {m4x4f} matrix - The matrix to be modified.
+ * @param {number} angle - The angle by which to rotate (in radians).
+ * @returns {m4x4f} The rotated matrix.
+ */
+declare const rotateZ4: DualFn<(matrix: m4x4f, angle: number) => m4x4f>;
+//#endregion
+export { rotateX4, rotateY4, rotateZ4, scale4, translate4 };

package/std/matrix.js

@@ -0,0 +1,87 @@
+import { $gpuCallable } from "../shared/symbols.js";
+import { stitch } from "../core/resolve/stitch.js";
+import { f32 } from "../data/numeric.js";
+import { vec3f } from "../data/vector.js";
+import { dualImpl } from "../core/function/dualImpl.js";
+import { mat4x4f, rotationX4, rotationY4, rotationZ4, scaling4, translation4 } from "../data/matrix.js";
+import { mul } from "./operators.js";
+
+//#region src/std/matrix.ts
+const gpuTranslation4 = translation4[$gpuCallable].call.bind(translation4);
+const gpuScaling4 = scaling4[$gpuCallable].call.bind(scaling4);
+const gpuRotationX4 = rotationX4[$gpuCallable].call.bind(rotationX4);
+const gpuRotationY4 = rotationY4[$gpuCallable].call.bind(rotationY4);
+const gpuRotationZ4 = rotationZ4[$gpuCallable].call.bind(rotationZ4);
+/**
+* Translates the given 4-by-4 matrix by the given vector.
+* @param {m4x4f} matrix - The matrix to be modified.
+* @param {v3f} vector - The vector by which to translate the matrix.
+* @returns {m4x4f} The translated matrix.
+*/
+const translate4 = dualImpl({
+	name: "translate4",
+	normalImpl: (matrix, vector) => mul(translation4(vector), matrix),
+	signature: {
+		argTypes: [mat4x4f, vec3f],
+		returnType: mat4x4f
+	},
+	codegenImpl: (ctx, [matrix, vector]) => stitch`(${gpuTranslation4(ctx, [vector])} * ${matrix})`
+});
+/**
+* Scales the given 4-by-4 matrix in each dimension by an amount given by the corresponding entry in the given vector.
+* @param {m4x4f} matrix - The matrix to be modified.
+* @param {v3f} vector - A vector of three entries specifying the factor by which to scale in each dimension.
+* @returns {m4x4f} The scaled matrix.
+*/
+const scale4 = dualImpl({
+	name: "scale4",
+	normalImpl: (matrix, vector) => mul(scaling4(vector), matrix),
+	signature: {
+		argTypes: [mat4x4f, vec3f],
+		returnType: mat4x4f
+	},
+	codegenImpl: (ctx, [matrix, vector]) => stitch`(${gpuScaling4(ctx, [vector])} * ${matrix})`
+});
+const rotateSignature = {
+	argTypes: [mat4x4f, f32],
+	returnType: mat4x4f
+};
+/**
+* Rotates the given 4-by-4 matrix around the x-axis by the given angle.
+* @param {m4x4f} matrix - The matrix to be modified.
+* @param {number} angle - The angle by which to rotate (in radians).
+* @returns {m4x4f} The rotated matrix.
+*/
+const rotateX4 = dualImpl({
+	name: "rotateX4",
+	normalImpl: (matrix, angle) => mul(rotationX4(angle), matrix),
+	signature: rotateSignature,
+	codegenImpl: (ctx, [matrix, angle]) => stitch`(${gpuRotationX4(ctx, [angle])} * ${matrix})`
+});
+/**
+* Rotates the given 4-by-4 matrix around the y-axis by the given angle.
+* @param {m4x4f} matrix - The matrix to be modified.
+* @param {number} angle - The angle by which to rotate (in radians).
+* @returns {m4x4f} The rotated matrix.
+*/
+const rotateY4 = dualImpl({
+	name: "rotateY4",
+	normalImpl: (matrix, angle) => mul(rotationY4(angle), matrix),
+	signature: rotateSignature,
+	codegenImpl: (ctx, [matrix, angle]) => stitch`(${gpuRotationY4(ctx, [angle])} * ${matrix})`
+});
+/**
+* Rotates the given 4-by-4 matrix around the z-axis by the given angle.
+* @param {m4x4f} matrix - The matrix to be modified.
+* @param {number} angle - The angle by which to rotate (in radians).
+* @returns {m4x4f} The rotated matrix.
+*/
+const rotateZ4 = dualImpl({
+	name: "rotateZ4",
+	normalImpl: (matrix, angle) => mul(rotationZ4(angle), matrix),
+	signature: rotateSignature,
+	codegenImpl: (ctx, [matrix, angle]) => stitch`(${gpuRotationZ4(ctx, [angle])} * ${matrix})`
+});
+
+//#endregion
+export { rotateX4, rotateY4, rotateZ4, scale4, translate4 };

package/std/numeric.d.ts

@@ -0,0 +1,254 @@
+import { DualFn } from "../types.js";
+import { AbstractFloat, AbstractInt, AnyFloat32VecInstance, AnyFloatVecInstance, AnyIntegerVecInstance, AnyMatInstance, AnyNumericVecInstance, AnySignedVecInstance, F16, F32, I32, Vec2f, Vec2h, Vec2i, Vec3f, Vec3h, Vec3i, Vec4f, Vec4h, Vec4i, WgslStruct, v2f, v2h, v2i, v3f, v3h, v3i, v4f, v4h, v4i } from "../data/wgslTypes.js";
+import { Infer } from "../shared/repr.js";
+
+//#region src/std/numeric.d.ts
+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 function cpuAcos(value: number): number;
+declare function cpuAcos<T extends AnyFloatVecInstance>(value: T): T;
+declare const acos: DualFn<typeof cpuAcos>;
+declare function cpuAcosh(value: number): number;
+declare function cpuAcosh<T extends AnyFloatVecInstance>(value: T): T;
+declare const acosh: DualFn<typeof cpuAcosh>;
+declare function cpuAsin(value: number): number;
+declare function cpuAsin<T extends AnyFloatVecInstance>(value: T): T;
+declare const asin: DualFn<typeof cpuAsin>;
+declare function cpuAsinh(value: number): number;
+declare function cpuAsinh<T extends AnyFloatVecInstance>(value: T): T;
+declare const asinh: DualFn<typeof cpuAsinh>;
+declare function cpuAtan(value: number): number;
+declare function cpuAtan<T extends AnyFloatVecInstance>(value: T): T;
+declare const atan: DualFn<typeof cpuAtan>;
+declare function cpuAtanh(value: number): number;
+declare function cpuAtanh<T extends AnyFloatVecInstance>(value: T): T;
+declare const atanh: DualFn<typeof cpuAtanh>;
+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 function cpuCeil(value: number): number;
+declare function cpuCeil<T extends AnyFloatVecInstance>(value: T): T;
+declare const ceil: DualFn<typeof cpuCeil>;
+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 function cpuCos(value: number): number;
+declare function cpuCos<T extends AnyFloatVecInstance>(value: T): T;
+declare const cos: DualFn<typeof cpuCos>;
+declare function cpuCosh(value: number): number;
+declare function cpuCosh<T extends AnyFloatVecInstance>(value: T): T;
+declare const cosh: DualFn<typeof cpuCosh>;
+declare function cpuCountLeadingZeros(value: number): number;
+declare function cpuCountLeadingZeros<T extends AnyIntegerVecInstance>(value: T): T;
+declare const countLeadingZeros: DualFn<typeof cpuCountLeadingZeros>;
+declare function cpuCountOneBits(value: number): number;
+declare function cpuCountOneBits<T extends AnyIntegerVecInstance>(value: T): T;
+declare const countOneBits: DualFn<typeof cpuCountOneBits>;
+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 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 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 function cpuExp(value: number): number;
+declare function cpuExp<T extends AnyFloatVecInstance>(value: T): T;
+declare const exp: DualFn<typeof cpuExp>;
+declare function cpuExp2(value: number): number;
+declare function cpuExp2<T extends AnyFloatVecInstance>(value: T): T;
+declare const exp2: DualFn<typeof cpuExp2>;
+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 function cpuFirstLeadingBit(value: number): number;
+declare function cpuFirstLeadingBit<T extends AnyIntegerVecInstance>(value: T): T;
+declare const firstLeadingBit: DualFn<typeof cpuFirstLeadingBit>;
+declare function cpuFirstTrailingBit(value: number): number;
+declare function cpuFirstTrailingBit<T extends AnyIntegerVecInstance>(value: T): T;
+declare const firstTrailingBit: DualFn<typeof cpuFirstTrailingBit>;
+declare function cpuFloor(value: number): number;
+declare function cpuFloor<T extends AnyFloatVecInstance>(value: T): T;
+declare const floor: DualFn<typeof cpuFloor>;
+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 function cpuFract(value: number): number;
+declare function cpuFract<T extends AnyFloatVecInstance>(value: T): T;
+declare const fract: DualFn<typeof cpuFract>;
+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;
+  }>;
+};
+type FrexpOverload = {
+  (value: number): Infer<(typeof FrexpResults)['f32']>;
+  <T extends AnyFloatVecInstance>(value: T): Infer<(typeof FrexpResults)[T['kind']]>;
+};
+declare const frexp: DualFn<FrexpOverload>;
+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 function cpuInverseSqrt(value: number): number;
+declare function cpuInverseSqrt<T extends AnyFloatVecInstance>(value: T): T;
+declare const inverseSqrt: DualFn<typeof cpuInverseSqrt>;
+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 function cpuLength(value: number): number;
+declare function cpuLength<T extends AnyFloatVecInstance>(value: T): number;
+declare const length: DualFn<typeof cpuLength>;
+declare function cpuLog(value: number): number;
+declare function cpuLog<T extends AnyFloatVecInstance>(value: T): T;
+declare const log: DualFn<typeof cpuLog>;
+declare function cpuLog2(value: number): number;
+declare function cpuLog2<T extends AnyFloatVecInstance>(value: T): T;
+declare const log2: DualFn<typeof cpuLog2>;
+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 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 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;
+  }>;
+};
+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 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 function cpuQuantizeToF16(value: number): number;
+declare function cpuQuantizeToF16<T extends AnyFloat32VecInstance>(value: T): T;
+declare const quantizeToF16: DualFn<typeof cpuQuantizeToF16>;
+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 function cpuReverseBits(value: number): number;
+declare function cpuReverseBits<T extends AnyIntegerVecInstance>(value: T): T;
+declare const reverseBits: DualFn<typeof cpuReverseBits>;
+declare function cpuRound(value: number): number;
+declare function cpuRound<T extends AnyFloatVecInstance>(value: T): T;
+declare const round: DualFn<typeof cpuRound>;
+declare function cpuSaturate(value: number): number;
+declare function cpuSaturate<T extends AnyFloatVecInstance>(value: T): T;
+declare const saturate: DualFn<typeof cpuSaturate>;
+declare function cpuSign(e: number): number;
+declare function cpuSign<T extends AnySignedVecInstance>(e: T): T;
+declare const sign: DualFn<typeof cpuSign>;
+declare function cpuSin(value: number): number;
+declare function cpuSin<T extends AnyFloatVecInstance>(value: T): T;
+declare const sin: DualFn<typeof cpuSin>;
+declare function cpuSinh(value: number): number;
+declare function cpuSinh<T extends AnyFloatVecInstance>(value: T): T;
+declare const sinh: DualFn<typeof cpuSinh>;
+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 function cpuSqrt(value: number): number;
+declare function cpuSqrt<T extends AnyFloatVecInstance>(value: T): T;
+declare const sqrt: DualFn<typeof cpuSqrt>;
+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 function cpuTan(value: number): number;
+declare function cpuTan<T extends AnyFloatVecInstance>(value: T): T;
+declare const tan: DualFn<typeof cpuTan>;
+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 function cpuTrunc(value: number): number;
+declare function cpuTrunc<T extends AnyFloatVecInstance>(value: T): T;
+declare const trunc: DualFn<typeof cpuTrunc>;
+//#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 };