typegpu 0.10.1 → 0.11.0-rc.1

package/std/derivative.js

@@ -0,0 +1,87 @@
+import { stitch } from "../core/resolve/stitch.js";
+import { dualImpl } from "../core/function/dualImpl.js";
+//#region src/std/derivative.ts
+const derivativeNormalError = "Derivative builtins are not allowed on the CPU";
+const dpdx = dualImpl({
+	name: "dpdx",
+	normalImpl: derivativeNormalError,
+	signature: (value) => ({
+		argTypes: [value],
+		returnType: value
+	}),
+	codegenImpl: (_ctx, [value]) => stitch`dpdx(${value})`
+});
+const dpdxCoarse = dualImpl({
+	name: "dpdxCoarse",
+	normalImpl: derivativeNormalError,
+	signature: (value) => ({
+		argTypes: [value],
+		returnType: value
+	}),
+	codegenImpl: (_ctx, [value]) => stitch`dpdxCoarse(${value})`
+});
+const dpdxFine = dualImpl({
+	name: "dpdxFine",
+	normalImpl: derivativeNormalError,
+	signature: (value) => ({
+		argTypes: [value],
+		returnType: value
+	}),
+	codegenImpl: (_ctx, [value]) => stitch`dpdxFine(${value})`
+});
+const dpdy = dualImpl({
+	name: "dpdy",
+	normalImpl: derivativeNormalError,
+	signature: (value) => ({
+		argTypes: [value],
+		returnType: value
+	}),
+	codegenImpl: (_ctx, [value]) => stitch`dpdy(${value})`
+});
+const dpdyCoarse = dualImpl({
+	name: "dpdyCoarse",
+	normalImpl: derivativeNormalError,
+	signature: (value) => ({
+		argTypes: [value],
+		returnType: value
+	}),
+	codegenImpl: (_ctx, [value]) => stitch`dpdyCoarse(${value})`
+});
+const dpdyFine = dualImpl({
+	name: "dpdyFine",
+	normalImpl: derivativeNormalError,
+	signature: (value) => ({
+		argTypes: [value],
+		returnType: value
+	}),
+	codegenImpl: (_ctx, [value]) => stitch`dpdyFine(${value})`
+});
+const fwidth = dualImpl({
+	name: "fwidth",
+	normalImpl: derivativeNormalError,
+	signature: (value) => ({
+		argTypes: [value],
+		returnType: value
+	}),
+	codegenImpl: (_ctx, [value]) => stitch`fwidth(${value})`
+});
+const fwidthCoarse = dualImpl({
+	name: "fwidthCoarse",
+	normalImpl: derivativeNormalError,
+	signature: (value) => ({
+		argTypes: [value],
+		returnType: value
+	}),
+	codegenImpl: (_ctx, [value]) => stitch`fwidthCoarse(${value})`
+});
+const fwidthFine = dualImpl({
+	name: "fwidthFine",
+	normalImpl: derivativeNormalError,
+	signature: (value) => ({
+		argTypes: [value],
+		returnType: value
+	}),
+	codegenImpl: (_ctx, [value]) => stitch`fwidthFine(${value})`
+});
+//#endregion
+export { dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, fwidth, fwidthCoarse, fwidthFine };

package/std/discard.d.ts

@@ -0,0 +1,6 @@
+import { DualFn } from "../types.js";
+
+//#region src/std/discard.d.ts
+declare const discard: DualFn;
+//#endregion
+export { discard };

package/std/discard.js

@@ -0,0 +1,14 @@
+import { Void } from "../data/wgslTypes.js";
+import { dualImpl } from "../core/function/dualImpl.js";
+//#region src/std/discard.ts
+const discard = dualImpl({
+	name: "discard",
+	normalImpl: "`discard` relies on GPU resources and cannot be executed outside of a draw call",
+	signature: {
+		argTypes: [],
+		returnType: Void
+	},
+	codegenImpl: () => "discard;"
+});
+//#endregion
+export { discard };

package/std/extensions.d.ts

@@ -0,0 +1,6 @@
+import { WgslExtension } from "../wgslExtensions.js";
+import { TgpuComptime } from "../core/function/comptime.js";
+//#region src/std/extensions.d.ts
+declare const extensionEnabled: TgpuComptime;
+//#endregion
+export { extensionEnabled };

package/std/extensions.js

@@ -0,0 +1,12 @@
+import { getResolutionCtx } from "../execMode.js";
+import { comptime } from "../core/function/comptime.js";
+import { wgslExtensions } from "../wgslExtensions.js";
+//#region src/std/extensions.ts
+const extensionEnabled = comptime((extensionName) => {
+	const resolutionCtx = getResolutionCtx();
+	if (!resolutionCtx) throw new Error("Functions using `extensionEnabled` cannot be called directly. Either generate WGSL from them, or use tgpu['~unstable'].simulate(...)");
+	if (typeof extensionName !== "string" || !wgslExtensions.includes(extensionName)) throw new Error(`extensionEnabled has to be called with a string literal representing a valid WGSL extension name. Got: '${extensionName}'`);
+	return (resolutionCtx.enableExtensions ?? []).includes(extensionName);
+});
+//#endregion
+export { extensionEnabled };

package/std/index.d.ts

@@ -1,9 +1,22 @@
-import { $ as dpdyFine, $t as countOneBits, A as subgroupShuffleUp, An as quantizeToF16, At as rotateY4, B as textureSampleCompareLevel, Bn as smoothstep, Bt as abs, C as subgroupInclusiveMul, Cn as log2, Ct as le, D as subgroupOr, Dn as modf, Dt as or, E as subgroupMul, En as mix, Et as not, F as textureLoad, Fn as round, Ft as div, G as unpack2x16float, Gn as transpose, Gt as atan, H as textureStore, Hn as step, Ht as acosh, I as textureSample, In as saturate, It as mod, J as dpdx, Jt as ceil, K as unpack4x8unorm, Kn as trunc, Kt as atan2, L as textureSampleBaseClampToEdge, Ln as sign, Lt as mul, M as subgroupXor, Mn as reflect, Mt as scale4, N as textureDimensions, Nn as refract, Nt as translate4, O as subgroupShuffle, On as normalize, Ot as select, P as textureGather, Pn as reverseBits, Pt as add, Q as dpdyCoarse, Qt as countLeadingZeros, R as textureSampleBias, Rn as sin, Rt as neg, S as subgroupInclusiveAdd, Sn as log, St as isCloseTo, T as subgroupMin, Tn as min, Tt as ne, U as pack2x16float, Un as tan, Ut as asin, V as textureSampleLevel, Vn as sqrt, Vt as acos, W as pack4x8unorm, Wn as tanh, Wt as asinh, X as dpdxFine, Xt as cos, Y as dpdxCoarse, Yt as clamp, Z as dpdy, Zt as cosh, _ as subgroupBroadcast, _n as frexp, _t as and, an as dot, at as atomicLoad, b as subgroupExclusiveAdd, bn as ldexp, bt as ge, cn as exp, cr as rotationY4, ct as atomicOr, d as extensionEnabled, dn as faceForward, dr as translation4, dt as atomicXor, en as countTrailingZeros, er as identity2, et as fwidth, f as subgroupAdd, fn as firstLeadingBit, ft as storageBarrier, g as subgroupBallot, gn as fract, gt as allEq, h as subgroupAny, hn as fma, ht as all, in as distance, it as atomicAnd, j as subgroupShuffleXor, jn as radians, jt as rotateZ4, k as subgroupShuffleDown, kn as pow, kt as rotateX4, l as bitcastU32toF32, ln as exp2, lr as rotationZ4, lt as atomicStore, m as subgroupAnd, mn as floor, mt as workgroupBarrier, nn as degrees, nr as identity4, nt as fwidthFine, on as dot4I8Packed, ot as atomicMax, p as subgroupAll, pn as firstTrailingBit, pt as textureBarrier, q as arrayLength, qn as discard, qt as atanh, rn as determinant, rt as atomicAdd, sn as dot4U8Packed, sr as rotationX4, st as atomicMin, tn as cross, tr as identity3, tt as fwidthCoarse, u as bitcastU32toI32, un as extractBits, ur as scaling4, ut as atomicSub, v as subgroupBroadcastFirst, vn as insertBits, vt as any, w as subgroupMax, wn as max, wt as lt, x as subgroupExclusiveMul, xn as length, xt as gt, y as subgroupElect, yn as inverseSqrt, yt as eq, z as textureSampleCompare, zn as sinh, zt as sub } from "../indexNamedExports-oL6tyaJ9.js";
+import { identity2, identity3, identity4, rotationX4, rotationY4, rotationZ4, scaling4, translation4 } from "../data/matrix.js";
+import { discard } from "./discard.js";
+import { 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";
+import { add, bitShiftLeft, bitShiftRight, div, mod, mul, neg, sub } from "./operators.js";
+import { rotateX4, rotateY4, rotateZ4, scale4, translate4 } from "./matrix.js";
+import { all, allEq, and, any, eq, ge, gt, isCloseTo, le, lt, ne, not, or, select } from "./boolean.js";
+import { atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, storageBarrier, textureBarrier, workgroupBarrier } from "./atomic.js";
+import { dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, fwidth, fwidthCoarse, fwidthFine } from "./derivative.js";
+import { arrayLength } from "./array.js";
+import { pack2x16float, pack4x8unorm, unpack2x16float, unpack4x8unorm } from "./packing.js";
+import { textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore } from "./texture.js";
+import { subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor } from "./subgroup.js";
+import { extensionEnabled } from "./extensions.js";
+import { bitcastU32toF32, bitcastU32toI32 } from "./bitcast.js";
+import { range } from "./range.js";
 
 //#region src/std/index.d.ts
 declare namespace index_d_exports {
-  export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, bitcastU32toF32, bitcastU32toI32, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extensionEnabled, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, gt, identity2, identity3, identity4, insertBits, inverseSqrt, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, rotationX4, rotationY4, rotationZ4, round, saturate, scale4, scaling4, select, sign, sin, sinh, smoothstep, sqrt, step, storageBarrier, sub, subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, tan, tanh, textureBarrier, textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleLevel, textureStore, translate4, translation4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };
+  export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, bitShiftLeft, bitShiftRight, bitcastU32toF32, bitcastU32toI32, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extensionEnabled, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, gt, identity2, identity3, identity4, insertBits, inverseSqrt, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, range, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, rotationX4, rotationY4, rotationZ4, round, saturate, scale4, scaling4, select, sign, sin, sinh, smoothstep, sqrt, step, storageBarrier, sub, subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, tan, tanh, textureBarrier, textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore, translate4, translation4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };
 }
 //#endregion
-export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, bitcastU32toF32, bitcastU32toI32, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extensionEnabled, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, gt, identity2, identity3, identity4, insertBits, inverseSqrt, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, rotationX4, rotationY4, rotationZ4, round, saturate, scale4, scaling4, select, sign, sin, sinh, smoothstep, sqrt, step, storageBarrier, sub, subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, index_d_exports as t, tan, tanh, textureBarrier, textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleLevel, textureStore, translate4, translation4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };
-//# sourceMappingURL=index.d.ts.map
+export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, bitShiftLeft, bitShiftRight, bitcastU32toF32, bitcastU32toI32, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extensionEnabled, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, gt, identity2, identity3, identity4, index_d_exports, insertBits, inverseSqrt, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, range, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, rotationX4, rotationY4, rotationZ4, round, saturate, scale4, scaling4, select, sign, sin, sinh, smoothstep, sqrt, step, storageBarrier, sub, subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, tan, tanh, textureBarrier, textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore, translate4, translation4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };

package/std/index.js

@@ -1,7 +1,19 @@
-import { t as __exportAll } from "../chunk-BYypO7fO.js";
-import { C as translation4, S as scaling4, a as neg, b as rotationY4, f as identity2, i as mul, m as identity4, n as div, o as sub, p as identity3, r as mod, t as add, x as rotationZ4, y as rotationX4 } from "../operators-d-PMVTo7.js";
-import { $ as workgroupBarrier, $t as extractBits, A as textureSampleCompareLevel, An as sqrt, At as acos, B as fwidthCoarse, Bt as cosh, C as textureDimensions, Cn as reverseBits, Ct as pack4x8unorm, D as textureSampleBaseClampToEdge, Dn as sin, Dt as bitcastU32toI32, E as textureSample, En as sign, Et as bitcastU32toF32, F as dpdxFine, Fn as trunc, Ft as atan2, G as atomicMax, Gt as degrees, H as atomicAdd, Ht as countOneBits, I as dpdy, It as atanh, J as atomicStore, Jt as dot, K as atomicMin, Kt as determinant, L as dpdyCoarse, Lt as ceil, M as textureStore, Mn as tan, Mt as asin, N as dpdx, Nn as tanh, Nt as asinh, O as textureSampleBias, On as sinh, Ot as arrayLength, P as dpdxCoarse, Pn as transpose, Pt as atan, Q as textureBarrier, Qt as exp2, R as dpdyFine, Rt as clamp, S as subgroupXor, Sn as refract, St as pack2x16float, T as textureLoad, Tn as saturate, Tt as unpack4x8unorm, U as atomicAnd, Ut as countTrailingZeros, V as fwidthFine, Vt as countLeadingZeros, W as atomicLoad, Wt as cross, X as atomicXor, Xt as dot4U8Packed, Y as atomicSub, Yt as dot4I8Packed, Z as storageBarrier, Zt as exp, _ as subgroupOr, _n as normalize, _t as not, a as subgroupAny, an as fract, at as discard, b as subgroupShuffleUp, bn as radians, c as subgroupBroadcastFirst, cn as inverseSqrt, ct as and, d as subgroupExclusiveMul, dn as log, dt as ge, en as faceForward, et as rotateX4, f as subgroupInclusiveAdd, fn as log2, ft as gt, g as subgroupMul, gn as modf, gt as ne, h as subgroupMin, hn as mix, ht as lt, i as subgroupAnd, in as fma, it as translate4, j as textureSampleLevel, jn as step, jt as acosh, k as textureSampleCompare, kn as smoothstep, kt as abs, l as subgroupElect, ln as ldexp, lt as any, m as subgroupMax, mn as min, mt as le, n as subgroupAdd, nn as firstTrailingBit, nt as rotateZ4, o as subgroupBallot, on as frexp, ot as all, p as subgroupInclusiveMul, pn as max, pt as isCloseTo, q as atomicOr, qt as distance, r as subgroupAll, rn as floor, rt as scale4, s as subgroupBroadcast, sn as insertBits, st as allEq, t as extensionEnabled, tn as firstLeadingBit, tt as rotateY4, u as subgroupExclusiveAdd, un as length, ut as eq, v as subgroupShuffle, vn as pow, vt as or, w as textureGather, wn as round, wt as unpack2x16float, x as subgroupShuffleXor, xn as reflect, y as subgroupShuffleDown, yn as quantizeToF16, yt as select, z as fwidth, zt as cos } from "../extensions-DIVuAfBM.js";
-
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { identity2, identity3, identity4, rotationX4, rotationY4, rotationZ4, scaling4, translation4 } from "../data/matrix.js";
+import { add, bitShiftLeft, bitShiftRight, div, mod, mul, neg, sub } from "./operators.js";
+import { 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";
+import { arrayLength } from "./array.js";
+import { range } from "./range.js";
+import { bitcastU32toF32, bitcastU32toI32 } from "./bitcast.js";
+import { pack2x16float, pack4x8unorm, unpack2x16float, unpack4x8unorm } from "./packing.js";
+import { all, allEq, and, any, eq, ge, gt, isCloseTo, le, lt, ne, not, or, select } from "./boolean.js";
+import { discard } from "./discard.js";
+import { rotateX4, rotateY4, rotateZ4, scale4, translate4 } from "./matrix.js";
+import { atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, storageBarrier, textureBarrier, workgroupBarrier } from "./atomic.js";
+import { dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, fwidth, fwidthCoarse, fwidthFine } from "./derivative.js";
+import { textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore } from "./texture.js";
+import { subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor } from "./subgroup.js";
+import { extensionEnabled } from "./extensions.js";
 //#region src/std/index.ts
 var std_exports = /* @__PURE__ */ __exportAll({
 	abs: () => abs,
@@ -27,6 +39,8 @@ var std_exports = /* @__PURE__ */ __exportAll({
 	atomicStore: () => atomicStore,
 	atomicSub: () => atomicSub,
 	atomicXor: () => atomicXor,
+	bitShiftLeft: () => bitShiftLeft,
+	bitShiftRight: () => bitShiftRight,
 	bitcastU32toF32: () => bitcastU32toF32,
 	bitcastU32toI32: () => bitcastU32toI32,
 	ceil: () => ceil,
@@ -96,6 +110,7 @@ var std_exports = /* @__PURE__ */ __exportAll({
 	pow: () => pow,
 	quantizeToF16: () => quantizeToF16,
 	radians: () => radians,
+	range: () => range,
 	reflect: () => reflect,
 	refract: () => refract,
 	reverseBits: () => reverseBits,
@@ -150,6 +165,7 @@ var std_exports = /* @__PURE__ */ __exportAll({
 	textureSampleBias: () => textureSampleBias,
 	textureSampleCompare: () => textureSampleCompare,
 	textureSampleCompareLevel: () => textureSampleCompareLevel,
+	textureSampleGrad: () => textureSampleGrad,
 	textureSampleLevel: () => textureSampleLevel,
 	textureStore: () => textureStore,
 	translate4: () => translate4,
@@ -160,7 +176,5 @@ var std_exports = /* @__PURE__ */ __exportAll({
 	unpack4x8unorm: () => unpack4x8unorm,
 	workgroupBarrier: () => workgroupBarrier
 });
-
 //#endregion
-export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, bitcastU32toF32, bitcastU32toI32, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extensionEnabled, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, gt, identity2, identity3, identity4, insertBits, inverseSqrt, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, rotationX4, rotationY4, rotationZ4, round, saturate, scale4, scaling4, select, sign, sin, sinh, smoothstep, sqrt, step, storageBarrier, sub, subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, std_exports as t, tan, tanh, textureBarrier, textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleLevel, textureStore, translate4, translation4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };
-//# sourceMappingURL=index.js.map
+export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, bitShiftLeft, bitShiftRight, bitcastU32toF32, bitcastU32toI32, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extensionEnabled, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, gt, identity2, identity3, identity4, insertBits, inverseSqrt, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, range, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, rotationX4, rotationY4, rotationZ4, round, saturate, scale4, scaling4, select, sign, sin, sinh, smoothstep, sqrt, std_exports, step, storageBarrier, sub, subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, tan, tanh, textureBarrier, textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore, translate4, translation4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };

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;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * 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;
+//#endregion
+export { rotateX4, rotateY4, rotateZ4, scale4, translate4 };

package/std/matrix.js

@@ -0,0 +1,85 @@
+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,200 @@
+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;
+declare function cpuAcos(value: number): number;
+declare function cpuAcos<T extends AnyFloatVecInstance>(value: T): T;
+declare const acos: DualFn;
+declare function cpuAcosh(value: number): number;
+declare function cpuAcosh<T extends AnyFloatVecInstance>(value: T): T;
+declare const acosh: DualFn;
+declare function cpuAsin(value: number): number;
+declare function cpuAsin<T extends AnyFloatVecInstance>(value: T): T;
+declare const asin: DualFn;
+declare function cpuAsinh(value: number): number;
+declare function cpuAsinh<T extends AnyFloatVecInstance>(value: T): T;
+declare const asinh: DualFn;
+declare function cpuAtan(value: number): number;
+declare function cpuAtan<T extends AnyFloatVecInstance>(value: T): T;
+declare const atan: DualFn;
+declare function cpuAtanh(value: number): number;
+declare function cpuAtanh<T extends AnyFloatVecInstance>(value: T): T;
+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;
+declare function cpuCeil(value: number): number;
+declare function cpuCeil<T extends AnyFloatVecInstance>(value: T): T;
+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;
+declare function cpuCos(value: number): number;
+declare function cpuCos<T extends AnyFloatVecInstance>(value: T): T;
+declare const cos: DualFn;
+declare function cpuCosh(value: number): number;
+declare function cpuCosh<T extends AnyFloatVecInstance>(value: T): T;
+declare const cosh: DualFn;
+declare function cpuCountLeadingZeros(value: number): number;
+declare function cpuCountLeadingZeros<T extends AnyIntegerVecInstance>(value: T): T;
+declare const countLeadingZeros: DualFn;
+declare function cpuCountOneBits(value: number): number;
+declare function cpuCountOneBits<T extends AnyIntegerVecInstance>(value: T): T;
+declare const countOneBits: DualFn;
+declare function cpuCountTrailingZeros(value: number): number;
+declare function cpuCountTrailingZeros<T extends AnyIntegerVecInstance>(value: 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;
+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;
+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;
+declare function cpuExp2(value: number): number;
+declare function cpuExp2<T extends AnyFloatVecInstance>(value: T): T;
+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;
+declare const faceForward: DualFn;
+declare function cpuFirstLeadingBit(value: number): number;
+declare function cpuFirstLeadingBit<T extends AnyIntegerVecInstance>(value: T): T;
+declare const firstLeadingBit: DualFn;
+declare function cpuFirstTrailingBit(value: number): number;
+declare function cpuFirstTrailingBit<T extends AnyIntegerVecInstance>(value: T): T;
+declare const firstTrailingBit: DualFn;
+declare function cpuFloor(value: number): number;
+declare function cpuFloor<T extends AnyFloatVecInstance>(value: T): T;
+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;
+declare function cpuFract(value: number): number;
+declare function cpuFract<T extends AnyFloatVecInstance>(value: T): T;
+declare const fract: DualFn;
+declare const FrexpResults: {
+  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;
+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;
+declare function cpuInverseSqrt(value: number): number;
+declare function cpuInverseSqrt<T extends AnyFloatVecInstance>(value: T): T;
+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;
+declare function cpuLength(value: number): number;
+declare function cpuLength<T extends AnyFloatVecInstance>(value: T): number;
+declare const length: DualFn;
+declare function cpuLog(value: number): number;
+declare function cpuLog<T extends AnyFloatVecInstance>(value: T): T;
+declare const log: DualFn;
+declare function cpuLog2(value: number): number;
+declare function cpuLog2<T extends AnyFloatVecInstance>(value: T): T;
+declare const log2: DualFn;
+type VariadicOverload = {
+  (fst: number, ...rest: number[]): number;
+  <T extends NumVec>(fst: T, ...rest: T[]): T;
+};
+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;
+declare const ModfResult: {
+  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;
+declare function powCpu(base: number, exponent: number): number;
+declare function powCpu<T extends AnyFloatVecInstance>(base: T, exponent: T): T;
+declare const pow: DualFn;
+declare function cpuQuantizeToF16(value: number): number;
+declare function cpuQuantizeToF16<T extends AnyFloat32VecInstance>(value: T): T;
+declare const quantizeToF16: DualFn;
+declare function cpuRadians(value: number): number;
+declare function cpuRadians<T extends AnyFloatVecInstance | number>(value: T): 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;
+declare function cpuRound(value: number): number;
+declare function cpuRound<T extends AnyFloatVecInstance>(value: T): T;
+declare const round: DualFn;
+declare function cpuSaturate(value: number): number;
+declare function cpuSaturate<T extends AnyFloatVecInstance>(value: T): T;
+declare const saturate: DualFn;
+declare function cpuSign(e: number): number;
+declare function cpuSign<T extends AnySignedVecInstance>(e: T): T;
+declare const sign: DualFn;
+declare function cpuSin(value: number): number;
+declare function cpuSin<T extends AnyFloatVecInstance>(value: T): T;
+declare const sin: DualFn;
+declare function cpuSinh(value: number): number;
+declare function cpuSinh<T extends AnyFloatVecInstance>(value: T): T;
+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;
+declare function cpuSqrt(value: number): number;
+declare function cpuSqrt<T extends AnyFloatVecInstance>(value: T): T;
+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;
+declare function cpuTan(value: number): number;
+declare function cpuTan<T extends AnyFloatVecInstance>(value: T): T;
+declare const tan: DualFn;
+declare function cpuTanh(value: number): number;
+declare function cpuTanh<T extends AnyFloatVecInstance>(value: 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;
+//#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 };