typegpu 0.11.5 → 0.11.7

package/std/boolean.js

@@ -2,8 +2,8 @@ import { isBool, isNumericSchema, isVec, isVecBool, isVecInstance } from "../dat
 import { isSnippetNumeric, snip } from "../data/snippet.js";
 import { stitch } from "../core/resolve/stitch.js";
 import { unify } from "../tgsl/conversion.js";
-import { bool, f32 } from "../data/numeric.js";
-import { vec2b, vec3b, vec4b } from "../data/vector.js";
+import { bool, f16, f32, i32, u32 } from "../data/numeric.js";
+import { vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u } from "../data/vector.js";
 import { dualImpl } from "../core/function/dualImpl.js";
 import { VectorOps } from "../data/vectorOps.js";
 import { sub } from "./operators.js";
@@ -271,6 +271,28 @@ function cpuSelect(f, t, cond) {
 	if (typeof cond === "boolean") return cond ? t : f;
 	return VectorOps.select[f.kind](f, t, cond);
 }
+const validSelectBranchTypes = [
+	f32,
+	f16,
+	i32,
+	u32,
+	bool,
+	vec2f,
+	vec3f,
+	vec4f,
+	vec2h,
+	vec3h,
+	vec4h,
+	vec2i,
+	vec3i,
+	vec4i,
+	vec2u,
+	vec3u,
+	vec4u,
+	vec2b,
+	vec3b,
+	vec4b
+];
 /**
 * Returns `t` if `cond` is `true`, and `f` otherwise.
 * Component-wise if `cond` is a vector.
@@ -283,7 +305,7 @@ function cpuSelect(f, t, cond) {
 const select = dualImpl({
 	name: "select",
 	signature: (f, t, cond) => {
-		const [uf, ut] = unify([f, t]) ?? [f, t];
+		const [uf, ut] = unify([f, t], validSelectBranchTypes) ?? [f, t];
 		return {
 			argTypes: [
 				uf,
@@ -294,8 +316,17 @@ const select = dualImpl({
 		};
 	},
 	normalImpl: cpuSelect,
-	codegenImpl: (_ctx, [f, t, cond]) => stitch`select(${f}, ${t}, ${cond})`
+	codegenImpl: (ctx, [f, t, cond]) => {
+		const result = stitch`select(${f}, ${t}, ${cond})`;
+		if (!validSelectBranchTypes.includes(f.dataType) || !validSelectBranchTypes.includes(t.dataType)) throw new Error(`'${result}' is invalid, std.select requires both branches to be either scalars or vectors.`);
+		if (f.dataType !== t.dataType) {
+			const fStr = ctx.resolve(f.dataType);
+			const tStr = ctx.resolve(t.dataType);
+			throw new Error(`'${result}' is invalid, std.select requires both branches to be the same type, got [${fStr.value}, ${tStr.value}].`);
+		}
+		return result;
+	}
 });
 
 //#endregion
-export { all, allEq, and, any, eq, ge, gt, isCloseTo, le, lt, ne, not, or, select };
+export { all, allEq, and, any, eq, ge, gt, isCloseTo, le, lt, ne, not, or, select, validSelectBranchTypes };

package/std/environment.d.ts

@@ -0,0 +1,48 @@
+import { DualFn } from "../types.js";
+import { TgpuComptime } from "../core/function/comptime.js";
+import "../indexNamedExports.js";
+
+//#region src/std/environment.d.ts
+
+/**
+ * Returns `true` when the direct callee is being transpiled for GPU, otherwise `false`.
+ *
+ * @example
+ * const f = () => {
+ *   'use gpu';
+ *   return isBeingTranspiled() ? 1 : 0;
+ * };
+ *
+ * f(); // returns 0, but resolved WGSL looks like this:
+ *
+ * fn f() -> i32 {
+ *   return 1;
+ * }
+ *
+ * @note
+ * Inside `comptime`, `lazy` or `simulate`, it always returns `false`.
+ */
+declare const isBeingTranspiled: DualFn<() => boolean>;
+/**
+ * Returns `wgsl` if invoked during the resolution process; otherwise, returns `undefined`.
+ *
+ * @example
+ * const f = () => {
+ *   'use gpu';
+ *   return getTargetShaderLanguage() === 'wgsl';
+ * };
+ *
+ * f(); // returns false, but resolved WGSL looks like this:
+ *
+ * fn f() -> bool {
+ *   return true;
+ * }
+ *
+ * @note
+ * Inside `lazy`, it always returns `wgsl`.
+ * Inside `simulate`, it always returns `undefined`.
+ * Inside `comptime`, it returns `wgsl` if called during the resolution process; otherwise, `undefined`.
+ */
+declare const getTargetShaderLanguage: TgpuComptime<() => string | undefined>;
+//#endregion
+export { getTargetShaderLanguage, isBeingTranspiled };

package/std/environment.js

@@ -0,0 +1,57 @@
+import { $gpuCallable } from "../shared/symbols.js";
+import { getExecMode, getResolutionCtx } from "../execMode.js";
+import { coerceToSnippet } from "../tgsl/generationHelpers.js";
+import { comptime } from "../core/function/comptime.js";
+
+//#region src/std/environment.ts
+const impl = (() => false);
+impl.toString = () => "isBeingTranspiled";
+impl[$gpuCallable] = { call(_ctx, _args) {
+	return coerceToSnippet(true);
+} };
+/**
+* Returns `true` when the direct callee is being transpiled for GPU, otherwise `false`.
+*
+* @example
+* const f = () => {
+*   'use gpu';
+*   return isBeingTranspiled() ? 1 : 0;
+* };
+*
+* f(); // returns 0, but resolved WGSL looks like this:
+*
+* fn f() -> i32 {
+*   return 1;
+* }
+*
+* @note
+* Inside `comptime`, `lazy` or `simulate`, it always returns `false`.
+*/
+const isBeingTranspiled = impl;
+/**
+* Returns `wgsl` if invoked during the resolution process; otherwise, returns `undefined`.
+*
+* @example
+* const f = () => {
+*   'use gpu';
+*   return getTargetShaderLanguage() === 'wgsl';
+* };
+*
+* f(); // returns false, but resolved WGSL looks like this:
+*
+* fn f() -> bool {
+*   return true;
+* }
+*
+* @note
+* Inside `lazy`, it always returns `wgsl`.
+* Inside `simulate`, it always returns `undefined`.
+* Inside `comptime`, it returns `wgsl` if called during the resolution process; otherwise, `undefined`.
+*/
+const getTargetShaderLanguage = comptime((() => {
+	if (!getResolutionCtx()) return;
+	return getExecMode().type !== "simulate" ? "wgsl" : void 0;
+}));
+
+//#endregion
+export { getTargetShaderLanguage, isBeingTranspiled };

package/std/extensions.d.ts

@@ -1,8 +1,8 @@
-import { WgslExtension } from "../wgslExtensions.js";
+import { WgslEnableExtension } from "../wgslExtensions.js";
 import { TgpuComptime } from "../core/function/comptime.js";
 import "../indexNamedExports.js";
 
 //#region src/std/extensions.d.ts
-declare const extensionEnabled: TgpuComptime<(extensionName: WgslExtension) => boolean>;
+declare const extensionEnabled: TgpuComptime<(extensionName: WgslEnableExtension) => boolean>;
 //#endregion
 export { extensionEnabled };

package/std/extensions.js

@@ -1,12 +1,12 @@
 import { getResolutionCtx } from "../execMode.js";
 import { comptime } from "../core/function/comptime.js";
-import { wgslExtensions } from "../wgslExtensions.js";
+import { wgslEnableExtensions } 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}'`);
+	if (typeof extensionName !== "string" || !wgslEnableExtensions.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);
 });
 

package/std/index.d.ts

@@ -14,10 +14,11 @@ import { subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, sub
 import { extensionEnabled } from "./extensions.js";
 import { bitcastU32toF32, bitcastU32toI32 } from "./bitcast.js";
 import { range } from "./range.js";
+import { getTargetShaderLanguage, isBeingTranspiled } from "./environment.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, bitShiftLeft, bitShiftRight, bitcastU32toF32, bitcastU32toI32, ceil, clamp, copy, 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 };
+  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, copy, 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, getTargetShaderLanguage, gt, identity2, identity3, identity4, insertBits, inverseSqrt, isBeingTranspiled, 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, bitShiftLeft, bitShiftRight, bitcastU32toF32, bitcastU32toI32, ceil, clamp, copy, 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 };
+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, copy, 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, getTargetShaderLanguage, gt, identity2, identity3, identity4, index_d_exports, insertBits, inverseSqrt, isBeingTranspiled, 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

@@ -4,9 +4,9 @@ import { add, bitShiftLeft, bitShiftRight, div, mod, mul, neg, sub } from "./ope
 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 { all, allEq, and, any, eq, ge, gt, isCloseTo, le, lt, ne, not, or, select } from "./boolean.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 { copy } from "./copy.js";
 import { discard } from "./discard.js";
 import { rotateX4, rotateY4, rotateZ4, scale4, translate4 } from "./matrix.js";
@@ -15,6 +15,7 @@ import { dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, fwidth, fwidthC
 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 { getTargetShaderLanguage, isBeingTranspiled } from "./environment.js";
 
 //#region src/std/index.ts
 var std_exports = /* @__PURE__ */ __export({
@@ -84,12 +85,14 @@ var std_exports = /* @__PURE__ */ __export({
 	fwidthCoarse: () => fwidthCoarse,
 	fwidthFine: () => fwidthFine,
 	ge: () => ge,
+	getTargetShaderLanguage: () => getTargetShaderLanguage,
 	gt: () => gt,
 	identity2: () => identity2,
 	identity3: () => identity3,
 	identity4: () => identity4,
 	insertBits: () => insertBits,
 	inverseSqrt: () => inverseSqrt,
+	isBeingTranspiled: () => isBeingTranspiled,
 	isCloseTo: () => isCloseTo,
 	ldexp: () => ldexp,
 	le: () => le,
@@ -181,4 +184,4 @@ var std_exports = /* @__PURE__ */ __export({
 });
 
 //#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, bitShiftLeft, bitShiftRight, bitcastU32toF32, bitcastU32toI32, ceil, clamp, copy, 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 };
+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, copy, 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, getTargetShaderLanguage, gt, identity2, identity3, identity4, insertBits, inverseSqrt, isBeingTranspiled, 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/tgpuBindGroupLayout.js

@@ -1,7 +1,7 @@
 import { $gpuValueOf, $internal } from "./shared/symbols.js";
+import { safeStringify } from "./shared/stringify.js";
 import { getName, setName } from "./shared/meta.js";
 import { NotUniformError } from "./errors.js";
-import { safeStringify } from "./shared/stringify.js";
 import { f32, i32, u32 } from "./data/numeric.js";
 import { NotStorageError, isUsableAsStorage } from "./extension.js";
 import { TgpuLaidOutBufferImpl, isUsableAsUniform } from "./core/buffer/bufferUsage.js";

package/tgsl/accessIndex.js

@@ -1,6 +1,6 @@
-import { isNaturallyEphemeral, isPtr, isVec, isWgslArray, isWgslStruct } from "../data/wgslTypes.js";
+import { isPtr, isVec, isWgslArray, isWgslStruct } from "../data/wgslTypes.js";
 import { MatrixColumnsAccess, isDisarray } from "../data/dataTypes.js";
-import { isEphemeralSnippet, snip } from "../data/snippet.js";
+import { snip } from "../data/snippet.js";
 import { isKnownAtComptime } from "../types.js";
 import { stitch } from "../core/resolve/stitch.js";
 import { derefSnippet } from "../data/ref.js";
@@ -18,24 +18,18 @@ function accessIndex(target, indexArg) {
 	const index = typeof indexArg === "number" ? coerceToSnippet(indexArg) : indexArg;
 	if (isWgslArray(target.dataType) || isDisarray(target.dataType)) {
 		const elementType = target.dataType.elementType;
-		const isElementNatEph = isNaturallyEphemeral(elementType);
-		const isTargetEphemeral = isEphemeralSnippet(target);
-		const isIndexConstant = index.origin === "constant";
 		let origin;
-		if (target.origin === "constant-tgpu-const-ref") if (isIndexConstant) origin = isElementNatEph ? "constant" : "constant-tgpu-const-ref";
-		else origin = isElementNatEph ? "runtime" : "runtime-tgpu-const-ref";
-		else if (target.origin === "runtime-tgpu-const-ref") origin = isElementNatEph ? "runtime" : "runtime-tgpu-const-ref";
-		else if (!isTargetEphemeral && !isElementNatEph) origin = target.origin;
-		else if (isIndexConstant && target.origin === "constant") origin = "constant";
-		else origin = "runtime";
+		if (target.origin === "constant-immutable-def") origin = index.origin === "constant" || index.origin === "constant-immutable-def" ? "constant-immutable-def" : "runtime-immutable-def";
+		else if (target.origin === "constant") origin = index.origin === "constant" || index.origin === "constant-immutable-def" ? "constant" : "runtime";
+		else origin = target.origin;
 		if (target.value instanceof ArrayExpression && isKnownAtComptime(index)) return target.value.elements[index.value];
-		return snip(isKnownAtComptime(target) && isKnownAtComptime(index) ? target.value[index.value] : stitch`${target}[${index}]`, elementType, origin);
+		return snip(isKnownAtComptime(target) && isKnownAtComptime(index) ? target.value[index.value] : stitch`${target}[${index}]`, elementType, origin, target.possibleSideEffects || index.possibleSideEffects);
 	}
-	if (isVec(target.dataType)) return snip(isKnownAtComptime(target) && isKnownAtComptime(index) ? target.value[index.value] : stitch`${target}[${index}]`, target.dataType.primitive, target.origin === "constant" || target.origin === "constant-tgpu-const-ref" ? "constant" : "runtime");
+	if (isVec(target.dataType)) return snip(isKnownAtComptime(target) && isKnownAtComptime(index) ? target.value[index.value] : stitch`${target}[${index}]`, target.dataType.primitive, target.origin, target.possibleSideEffects || index.possibleSideEffects);
 	if (isPtr(target.dataType)) return accessIndex(derefSnippet(target), index);
 	if (target.value instanceof MatrixColumnsAccess) {
 		const propType = indexableTypeToResult[target.value.matrix.dataType.type];
-		return snip(stitch`${target.value.matrix}[${index}]`, propType, target.origin);
+		return snip(stitch`${target.value.matrix}[${index}]`, propType, target.origin, target.possibleSideEffects || index.possibleSideEffects);
 	}
 	if (target.dataType.type in indexableTypeToResult) throw new Error("The only way of accessing matrix elements in TypeGPU functions is through the 'columns' property.");
 	if (isKnownAtComptime(target) && isKnownAtComptime(index)) return coerceToSnippet(target.value[index.value]);

package/tgsl/accessProp.js

@@ -1,16 +1,15 @@
-import { $gpuCallable } from "../shared/symbols.js";
-import { isMat, isNaturallyEphemeral, isPtr, isVec, isWgslArray, isWgslStruct } from "../data/wgslTypes.js";
-import { InfixDispatch, MatrixColumnsAccess, UnknownData, isUnstruct, undecorate } from "../data/dataTypes.js";
-import { isEphemeralSnippet, isSnippet, snip } from "../data/snippet.js";
+import { isMat, isPtr, isVec, isWgslArray, isWgslStruct } from "../data/wgslTypes.js";
+import { MatrixColumnsAccess, UnknownData, isUnstruct, undecorate } from "../data/dataTypes.js";
+import { isSnippet, snip } from "../data/snippet.js";
 import { isKnownAtComptime } from "../types.js";
 import { stitch } from "../core/resolve/stitch.js";
 import { derefSnippet } from "../data/ref.js";
-import { abstractInt, bool, f16, f32, i32, u32 } from "../data/numeric.js";
-import { coerceToSnippet } from "./generationHelpers.js";
+import { bool, f16, f32, i32, u32 } from "../data/numeric.js";
+import { coerceToSnippet, numericLiteralToSnippet } from "./generationHelpers.js";
 import { vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u } from "../data/vector.js";
 import { AutoStruct } from "../data/autoStruct.js";
 import { EntryInputRouter } from "../core/function/entryInputRouter.js";
-import { add, bitShiftLeft, bitShiftRight, div, mod, mul, sub } from "../std/operators.js";
+import { InfixDispatch, infixOperators } from "./infixDispatch.js";
 
 //#region src/tgsl/accessProp.ts
 const infixKinds = [
@@ -30,15 +29,6 @@ const infixKinds = [
 	"mat3x3f",
 	"mat4x4f"
 ];
-const infixOperators = {
-	add,
-	sub,
-	mul,
-	div,
-	mod,
-	bitShiftLeft,
-	bitShiftRight
-};
 const swizzleLenToType = {
 	f: {
 		1: f32,
@@ -74,23 +64,23 @@ const swizzleLenToType = {
 function accessProp(target, propName) {
 	if (infixKinds.includes(target.dataType.type) && propName in infixOperators) {
 		const operator = infixOperators[propName];
-		return snip(new InfixDispatch(propName, target, operator[$gpuCallable].call.bind(operator)), UnknownData, target.origin);
+		return snip(new InfixDispatch(target, operator), UnknownData, target.origin, target.possibleSideEffects);
 	}
 	if (isWgslArray(target.dataType) && propName === "length") {
-		if (target.dataType.elementCount === 0) return snip(stitch`arrayLength(&${target})`, u32, "runtime");
-		return snip(target.dataType.elementCount, abstractInt, "constant");
+		if (target.dataType.elementCount === 0) return snip(stitch`arrayLength(&${target})`, u32, "runtime", target.possibleSideEffects);
+		return numericLiteralToSnippet(target.dataType.elementCount);
 	}
-	if (isMat(target.dataType) && propName === "columns") return snip(new MatrixColumnsAccess(target), UnknownData, target.origin);
+	if (isMat(target.dataType) && propName === "columns") return snip(new MatrixColumnsAccess(target), UnknownData, target.origin, target.possibleSideEffects);
 	if (isWgslStruct(target.dataType) || isUnstruct(target.dataType)) {
 		let propType = target.dataType.propTypes[propName];
 		if (!propType) return;
 		propType = undecorate(propType);
-		return snip(stitch`${target}.${propName}`, propType, target.origin === "argument" ? "argument" : !isEphemeralSnippet(target) && !isNaturallyEphemeral(propType) ? target.origin : target.origin === "constant" || target.origin === "constant-tgpu-const-ref" ? "constant" : "runtime");
+		return snip(stitch`${target}.${propName}`, propType, target.origin, target.possibleSideEffects);
 	}
 	if (target.dataType instanceof AutoStruct) {
 		const result = target.dataType.accessProp(propName);
 		if (!result) return;
-		return snip(stitch`${target}.${result.prop}`, result.type, "argument");
+		return snip(stitch`${target}.${result.prop}`, result.type, "argument", target.possibleSideEffects);
 	}
 	if (target.dataType instanceof EntryInputRouter) {
 		const result = target.dataType.accessProp(propName);
@@ -104,19 +94,16 @@ function accessProp(target, propName) {
 		return accessProp(derefed, propName);
 	}
 	if (isVec(target.dataType)) {
-		if (propName === "kind") return snip(target.dataType.type, UnknownData, "constant");
+		if (propName === "kind") return snip(target.dataType.type, UnknownData, "constant", false);
 	}
 	const propLength = propName.length;
-	if (isVec(target.dataType) && propLength >= 1 && propLength <= 4) {
-		const isXYZW = /^[xyzw]+$/.test(propName);
-		const isRGBA = /^[rgba]+$/.test(propName);
-		if (!isXYZW && !isRGBA) return;
+	if (isVec(target.dataType) && propLength >= 1 && propLength <= 4 && /^[xyzw]+$|^[rgba]+$/.test(propName)) {
 		const swizzleType = swizzleLenToType[target.dataType.type.includes("bool") ? "b" : target.dataType.type[4]][propLength];
 		if (!swizzleType) return;
-		return snip(isKnownAtComptime(target) ? target.value[propName] : stitch`${target}.${propName}`, swizzleType, target.origin === "argument" && propLength === 1 ? "argument" : target.origin === "constant" || target.origin === "constant-tgpu-const-ref" ? "constant" : "runtime");
+		return snip(isKnownAtComptime(target) ? target.value[propName] : stitch`${target}.${propName}`, swizzleType, propLength === 1 ? target.origin : target.origin === "constant" || target.origin === "constant-immutable-def" ? "constant" : "runtime", target.possibleSideEffects);
 	}
 	if (isKnownAtComptime(target) || target.dataType === UnknownData) return coerceToSnippet(target.value[propName]);
 }
 
 //#endregion
-export { accessProp, infixOperators };
+export { accessProp };

package/tgsl/consoleLog/serializers.js

@@ -1,5 +1,5 @@
-import { getName } from "../../shared/meta.js";
 import { isWgslArray, isWgslStruct } from "../../data/wgslTypes.js";
+import { getName } from "../../shared/meta.js";
 import { bool, f16, f32, i32, u32 } from "../../data/numeric.js";
 import { vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u } from "../../data/vector.js";
 import { sizeOf } from "../../data/sizeOf.js";

package/tgsl/conversion.js

@@ -1,12 +1,12 @@
 import { DEV, TEST } from "../shared/env.js";
 import { isMat, isPtr, isVec } from "../data/wgslTypes.js";
+import { safeStringify } from "../shared/stringify.js";
 import { UnknownData, undecorate } from "../data/dataTypes.js";
-import { snip } from "../data/snippet.js";
+import { snip, withDataType } from "../data/snippet.js";
 import { WgslTypeError, invariant } from "../errors.js";
 import { stitch } from "../core/resolve/stitch.js";
 import { RefOperator, derefSnippet } from "../data/ref.js";
 import { schemaCallWrapperGPU } from "../data/schemaCallWrapper.js";
-import { safeStringify } from "../shared/stringify.js";
 import { assertExhaustive } from "../shared/utilityTypes.js";
 
 //#region src/tgsl/conversion.ts
@@ -160,7 +160,7 @@ function getBestConversion(types, targetTypes) {
 function applyActionToSnippet(ctx, snippet, action, targetType) {
 	if (action.action === "none") {
 		if (targetType === snippet.dataType) return snippet;
-		return snip(snippet.value, targetType, snippet.origin);
+		return withDataType(targetType, snippet);
 	}
 	switch (action.action) {
 		case "ref": return snip(new RefOperator(snippet, targetType), targetType, snippet.origin);

package/tgsl/forOfUtils.js

@@ -1,7 +1,7 @@
 import { $gpuCallable } from "../shared/symbols.js";
-import { isPtr, isVec, isWgslArray } from "../data/wgslTypes.js";
+import { isNaturallyEphemeral, isPtr, isVec, isWgslArray } from "../data/wgslTypes.js";
 import { UnknownData } from "../data/dataTypes.js";
-import { isEphemeralSnippet, snip } from "../data/snippet.js";
+import { isAlias, snip } from "../data/snippet.js";
 import { WgslTypeError, invariant } from "../errors.js";
 import { stitch } from "../core/resolve/stitch.js";
 import { createPtrFromOrigin, implicitFrom } from "../data/ptr.js";
@@ -13,17 +13,20 @@ import { isTgpuRange } from "../std/range.js";
 
 //#region src/tgsl/forOfUtils.ts
 function getLoopVarKind(elementSnippet) {
-	return elementSnippet.origin === "constant-tgpu-const-ref" ? "const" : "let";
+	return elementSnippet.origin === "constant-immutable-def" ? "const" : "let";
 }
 function getElementSnippet(iterableSnippet, index) {
 	const elementSnippet = accessIndex(iterableSnippet, index);
 	if (!elementSnippet) throw new WgslTypeError("`for ... of ...` loops only support array or vector iterables");
 	return elementSnippet;
 }
+/**
+* Determines the type of the element as accessible inside of the `for .. of` loop body
+*/
 function getElementType(elementSnippet, iterableSnippet) {
 	let elementType = elementSnippet.dataType;
 	if (elementType === UnknownData) throw new WgslTypeError(stitch`The elements in iterable ${iterableSnippet} are of unknown type`);
-	if (isEphemeralSnippet(elementSnippet) || elementSnippet.origin === "constant-tgpu-const-ref" || elementSnippet.origin === "runtime-tgpu-const-ref") return elementType;
+	if (isNaturallyEphemeral(elementSnippet.dataType) || elementSnippet.origin === "runtime" || elementSnippet.origin === "constant" || elementSnippet.origin === "constant-immutable-def" || elementSnippet.origin === "runtime-immutable-def") return elementType;
 	if (!isPtr(elementType)) {
 		const ptrType = createPtrFromOrigin(elementSnippet.origin, concretize(elementType));
 		invariant(ptrType !== void 0, `Creating pointer type from origin ${elementSnippet.origin}`);
@@ -47,7 +50,7 @@ function getRangeSnippets(ctx, iterableSnippet, unroll = false) {
 			comparison: step < 0 ? ">" : "<"
 		};
 	}
-	if (!unroll && isEphemeralSnippet(iterableSnippet)) throw new Error(`\`for ... of ...\` loops only support std.range or iterables stored in variables.
+	if (!unroll && !isAlias(iterableSnippet)) throw new Error(`\`for ... of ...\` loops only support std.range or iterables stored in variables.
 -----
 You can wrap iterable with \`tgpu.unroll(...)\`. If iterable is known at comptime, the loop will be unrolled.
 -----`);

package/tgsl/generationHelpers.js

@@ -1,21 +1,20 @@
 import { $internal, $resolve } from "../shared/symbols.js";
 import { WORKAROUND_getSchema, isMatInstance, isNaturallyEphemeral, isVecInstance } from "../data/wgslTypes.js";
 import { UnknownData } from "../data/dataTypes.js";
-import { isEphemeralSnippet, isSnippet, snip } from "../data/snippet.js";
+import { isAlias, isSnippet, snip } from "../data/snippet.js";
 import { WgslTypeError } from "../errors.js";
 import { getOwnSnippet } from "../types.js";
-import { stitch } from "../core/resolve/stitch.js";
 import { isRef } from "../data/ref.js";
 import { abstractFloat, abstractInt, bool, f32, i32 } from "../data/numeric.js";
 
 //#region src/tgsl/generationHelpers.ts
 function numericLiteralToSnippet(value) {
-	if (value >= 2 ** 63 || value < -(2 ** 63)) return snip(value, abstractFloat, "constant");
+	if (value >= 2 ** 63 || value < -(2 ** 63)) return snip(value, abstractFloat, "constant", false);
 	if (Number.isInteger(value)) {
 		if (!Number.isSafeInteger(value)) console.warn(`The integer ${value} exceeds the safe integer range and may have lost precision.`);
-		return snip(value, abstractInt, "constant");
+		return snip(value, abstractInt, "constant", false);
 	}
-	return snip(value, abstractFloat, "constant");
+	return snip(value, abstractFloat, "constant", false);
 }
 function concretize(type) {
 	if (type.type === "abstractFloat") return f32;
@@ -30,11 +29,11 @@ function coerceToSnippet(value) {
 	if (isRef(value)) throw new Error("Cannot use refs (d.ref(...)) from the outer scope.");
 	const ownSnippet = getOwnSnippet(value);
 	if (ownSnippet) return ownSnippet;
-	if (isVecInstance(value) || isMatInstance(value)) return snip(value, WORKAROUND_getSchema(value), "constant");
-	if (typeof value === "string" || typeof value === "function" || typeof value === "object" || typeof value === "symbol" || typeof value === "undefined" || value === null) return snip(value, UnknownData, "constant");
+	if (isVecInstance(value) || isMatInstance(value)) return snip(value, WORKAROUND_getSchema(value), "constant", false);
+	if (typeof value === "string" || typeof value === "function" || typeof value === "object" || typeof value === "symbol" || typeof value === "undefined" || value === null) return snip(value, UnknownData, "constant", false);
 	if (typeof value === "number") return numericLiteralToSnippet(value);
-	if (typeof value === "boolean") return snip(value, bool, "constant");
-	return snip(value, UnknownData, "constant");
+	if (typeof value === "boolean") return snip(value, bool, "constant", false);
+	return snip(value, UnknownData, "constant", false);
 }
 /**
 * Intermediate representation for WGSL array expressions.
@@ -53,12 +52,12 @@ var ArrayExpression = class {
 		return "ArrayExpression";
 	}
 	[$resolve](ctx) {
-		for (const elem of this.elements) if (elem.origin === "argument" && !isNaturallyEphemeral(elem.dataType) || !isEphemeralSnippet(elem)) {
+		for (const elem of this.elements) if (isAlias(elem) && !isNaturallyEphemeral(elem.dataType)) {
 			const snippetStr = ctx.resolve(elem.value, elem.dataType).value;
 			const snippetType = ctx.resolve(concretize(elem.dataType)).value;
 			throw new WgslTypeError(`'${snippetStr}' reference cannot be used in an array constructor.\n-----\nTry '${snippetType}(${snippetStr})' or 'arrayOf(${snippetType}, count)([...])' to copy the value instead.\n-----`);
 		}
-		return snip(stitch`${`array<${ctx.resolve(this.type.elementType).value}, ${this.elements.length}>`}(${this.elements})`, this.type, "runtime");
+		return ctx.gen.typeInstantiation(this.type, this.elements);
 	}
 };
 

package/tgsl/infixDispatch.js

@@ -0,0 +1,53 @@
+import { inCodegenMode } from "../execMode.js";
+import { add, bitShiftLeft, bitShiftRight, div, mod, mul, sub } from "../std/operators.js";
+
+//#region src/tgsl/infixDispatch.ts
+const infixOperators = {
+	add,
+	sub,
+	mul,
+	div,
+	mod,
+	bitShiftLeft,
+	bitShiftRight
+};
+/**
+* InfixDispatch is only used in codegen mode.
+* `lhs` may either be Numeric or Snippet.
+* @example
+* const external = d.vec2u(1);
+* const fn = () => {
+*    'use gpu';
+*    external.mul(2); // lhs is Numeric
+*    d.vec2u(1).mul(2) // lhs is a snippet
+* }
+*/
+var InfixDispatch = class {
+	lhs;
+	operator;
+	constructor(lhs, operator) {
+		this.lhs = lhs;
+		this.operator = operator;
+	}
+};
+function isInfixDispatch(o) {
+	return o instanceof InfixDispatch;
+}
+/**
+* This function is used on vec/mat prototypes.
+* This is done in runtime in order to avoid a circular dependency.
+*/
+function assignInfixOperator(base, operator, operatorSymbol) {
+	const opImpl = infixOperators[operator];
+	Object.defineProperty(base.prototype, operatorSymbol, { value: opImpl });
+	function jsInfixDispatchFor(arg) {
+		return opImpl(this, arg);
+	}
+	Object.defineProperty(base.prototype, operator, { get() {
+		if (inCodegenMode()) return new InfixDispatch(this, opImpl);
+		return jsInfixDispatchFor;
+	} });
+}
+
+//#endregion
+export { InfixDispatch, assignInfixOperator, infixOperators, isInfixDispatch };

package/tgsl/shaderGenerator.d.ts

@@ -1,6 +1,6 @@
 import { ResolvedSnippet, Snippet } from "../data/snippet.js";
 import { GenerationCtx } from "./generationHelpers.js";
-import { FunctionDefinitionOptions } from "./shaderGenerator_members.js";
+import { ConstantDefinitionOptions, FunctionDefinitionOptions, VariableDefinitionOptions } from "./shaderGenerator_members.js";
 import { BaseData } from "../data/wgslTypes.js";
 
 //#region src/tgsl/shaderGenerator.d.ts
@@ -13,9 +13,12 @@ import { BaseData } from "../data/wgslTypes.js";
  */
 interface ShaderGenerator {
   initGenerator(ctx: GenerationCtx): void;
+  declareGlobalConst(options: ConstantDefinitionOptions): ResolvedSnippet;
+  declareGlobalVar(options: VariableDefinitionOptions): ResolvedSnippet;
   functionDefinition(options: FunctionDefinitionOptions): string;
   typeInstantiation(schema: BaseData, args: readonly Snippet[]): ResolvedSnippet;
   typeAnnotation(schema: BaseData): string;
+  numericLiteral(value: number, schema: BaseData): ResolvedSnippet;
 }
 //#endregion
 export { ShaderGenerator };