typegpu 0.10.1 → 0.11.0-rc.1

package/std/subgroup.js

@@ -0,0 +1,218 @@
+import { stitch } from "../core/resolve/stitch.js";
+import { unify } from "../tgsl/conversion.js";
+import { bool, i32, u32 } from "../data/numeric.js";
+import { vec4u } from "../data/vector.js";
+import { dualImpl } from "../core/function/dualImpl.js";
+//#region src/std/subgroup.ts
+const errorMessage = "Subgroup operations can only be used in the GPU context.";
+const subgroupAdd = dualImpl({
+	name: "subgroupAdd",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [arg]) => stitch`subgroupAdd(${arg})`
+});
+const subgroupExclusiveAdd = dualImpl({
+	name: "subgroupExclusiveAdd",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [arg]) => stitch`subgroupExclusiveAdd(${arg})`
+});
+const subgroupInclusiveAdd = dualImpl({
+	name: "subgroupInclusiveAdd",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [arg]) => stitch`subgroupInclusiveAdd(${arg})`
+});
+const subgroupAll = dualImpl({
+	name: "subgroupAll",
+	signature: {
+		argTypes: [bool],
+		returnType: bool
+	},
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e]) => stitch`subgroupAll(${e})`
+});
+const subgroupAnd = dualImpl({
+	name: "subgroupAnd",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e]) => stitch`subgroupAnd(${e})`
+});
+const subgroupAny = dualImpl({
+	name: "subgroupAny",
+	signature: {
+		argTypes: [bool],
+		returnType: bool
+	},
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e]) => stitch`subgroupAny(${e})`
+});
+const subgroupBallot = dualImpl({
+	name: "subgroupBallot",
+	signature: {
+		argTypes: [bool],
+		returnType: vec4u
+	},
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e]) => stitch`subgroupBallot(${e})`
+});
+const subgroupBroadcast = dualImpl({
+	name: "subgroupBroadcast",
+	signature: (...args) => {
+		const id = unify([args[1]], [i32, u32]);
+		if (!id) throw new Error(`subgroupBroadcast's second argument has to be compatible with i32 or u32. Got: ${args[1].type}`);
+		return {
+			argTypes: [args[0], id[0]],
+			returnType: args[0]
+		};
+	},
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e, index]) => stitch`subgroupBroadcast(${e}, ${index})`
+});
+const subgroupBroadcastFirst = dualImpl({
+	name: "subgroupBroadcastFirst",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e]) => stitch`subgroupBroadcastFirst(${e})`
+});
+const subgroupElect = dualImpl({
+	name: "subgroupElect",
+	signature: {
+		argTypes: [],
+		returnType: bool
+	},
+	normalImpl: errorMessage,
+	codegenImpl: () => stitch`subgroupElect()`
+});
+const subgroupMax = dualImpl({
+	name: "subgroupMax",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [arg]) => stitch`subgroupMax(${arg})`
+});
+const subgroupMin = dualImpl({
+	name: "subgroupMin",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [arg]) => stitch`subgroupMin(${arg})`
+});
+const subgroupMul = dualImpl({
+	name: "subgroupMul",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [arg]) => stitch`subgroupMul(${arg})`
+});
+const subgroupExclusiveMul = dualImpl({
+	name: "subgroupExclusiveMul",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [arg]) => stitch`subgroupExclusiveMul(${arg})`
+});
+const subgroupInclusiveMul = dualImpl({
+	name: "subgroupInclusiveMul",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [arg]) => stitch`subgroupInclusiveMul(${arg})`
+});
+const subgroupOr = dualImpl({
+	name: "subgroupOr",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e]) => stitch`subgroupOr(${e})`
+});
+const subgroupShuffle = dualImpl({
+	name: "subgroupShuffle",
+	signature: (...args) => {
+		const id = unify([args[1]], [i32, u32]);
+		if (!id) throw new Error(`subgroupShuffle's second argument has to be compatible with i32 or u32. Got: ${args[1].type}`);
+		return {
+			argTypes: [args[0], id[0]],
+			returnType: args[0]
+		};
+	},
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e, index]) => stitch`subgroupShuffle(${e}, ${index})`
+});
+const subgroupShuffleDown = dualImpl({
+	name: "subgroupShuffleDown",
+	signature: (...args) => {
+		const delta = unify([args[1]], [u32]);
+		if (!delta) throw new Error(`subgroupShuffleDown's second argument has to be compatible with u32. Got: ${args[1].type}`);
+		return {
+			argTypes: [args[0], delta[0]],
+			returnType: args[0]
+		};
+	},
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e, delta]) => stitch`subgroupShuffleDown(${e}, ${delta})`
+});
+const subgroupShuffleUp = dualImpl({
+	name: "subgroupShuffleUp",
+	signature: (...args) => {
+		const delta = unify([args[1]], [u32]);
+		if (!delta) throw new Error(`subgroupShuffleUp's second argument has to be compatible with u32. Got: ${args[1].type}`);
+		return {
+			argTypes: [args[0], delta[0]],
+			returnType: args[0]
+		};
+	},
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e, delta]) => stitch`subgroupShuffleUp(${e}, ${delta})`
+});
+const subgroupShuffleXor = dualImpl({
+	name: "subgroupShuffleXor",
+	signature: (...args) => {
+		const mask = unify([args[1]], [u32]);
+		if (!mask) throw new Error(`subgroupShuffleXor's second argument has to be compatible with u32. Got: ${args[1].type}`);
+		return {
+			argTypes: [args[0], mask[0]],
+			returnType: args[0]
+		};
+	},
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e, mask]) => stitch`subgroupShuffleXor(${e}, ${mask})`
+});
+const subgroupXor = dualImpl({
+	name: "subgroupXor",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e]) => stitch`subgroupXor(${e})`
+});
+//#endregion
+export { subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor };

package/std/texture.d.ts

@@ -0,0 +1,117 @@
+import { $internal, $repr } from "../shared/symbols.js";
+import { comparisonSampler, sampler } from "../data/sampler.js";
+import { DualFn } from "../types.js";
+import { v2f, v2i, v2u, v3f, v3i, v3u, v4f, v4i, v4u } from "../data/wgslTypes.js";
+import { StorageTextureFormats, TextureFormats } from "../core/texture/textureFormats.js";
+import { texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d } from "../data/texture.js";
+
+//#region src/std/texture.d.ts
+declare function sampleCpu<T extends texture1d>(texture: T, sampler: sampler, coords: number): v4f;
+declare function sampleCpu<T extends texture2d>(texture: T, sampler: sampler, coords: v2f, offset?: v2i): v4f;
+declare function sampleCpu<T extends texture2dArray>(texture: T, sampler: sampler, coords: v2f, arrayIndex: number, offset?: v2i): v4f;
+declare function sampleCpu<T extends texture3d | textureCube>(texture: T, sampler: sampler, coords: v3f): v4f;
+declare function sampleCpu<T extends texture3d>(texture: T, sampler: sampler, coords: v3f, offset: v3i): v4f;
+declare function sampleCpu<T extends textureCubeArray>(texture: T, sampler: sampler, coords: v3f, arrayIndex: number): v4f;
+declare function sampleCpu<T extends textureDepth2d>(texture: T, sampler: sampler, coords: v2f, offset?: v2i): number;
+declare function sampleCpu<T extends textureDepth2dArray>(texture: T, sampler: sampler, coords: v2f, arrayIndex: number, offset?: v2i): number;
+declare function sampleCpu<T extends textureDepthCube>(texture: T, sampler: sampler, coords: v3f, arrayIndex?: number): number;
+declare const textureSample: DualFn;
+declare function sampleBiasCpu<T extends texture1d>(texture: T, sampler: sampler, coords: number, bias: number): v4f;
+declare function sampleBiasCpu<T extends texture2d>(texture: T, sampler: sampler, coords: v2f, bias: number, offset?: v2i): v4f;
+declare function sampleBiasCpu<T extends texture2dArray>(texture: T, sampler: sampler, coords: v2f, arrayIndex: number, bias: number, offset?: v2i): v4f;
+declare function sampleBiasCpu<T extends texture3d | textureCube>(texture: T, sampler: sampler, coords: v3f, bias: number, offset?: v3i): v4f;
+declare function sampleBiasCpu<T extends textureCubeArray>(texture: T, sampler: sampler, coords: v3f, arrayIndex: number, bias: number): v4f;
+declare const textureSampleBias: DualFn;
+declare function sampleLevelCpu<T extends texture1d>(texture: T, sampler: sampler, coords: number, level: number): v4f;
+declare function sampleLevelCpu<T extends texture2d>(texture: T, sampler: sampler, coords: v2f, level: number): v4f;
+declare function sampleLevelCpu<T extends texture2d>(texture: T, sampler: sampler, coords: v2f, level: number, offset: v2i): v4f;
+declare function sampleLevelCpu<T extends texture2dArray>(texture: T, sampler: sampler, coords: v2f, arrayIndex: number, level: number): v4f;
+declare function sampleLevelCpu<T extends texture2dArray>(texture: T, sampler: sampler, coords: v2f, arrayIndex: number, level: number, offset: v2i): v4f;
+declare function sampleLevelCpu<T extends texture3d | textureCube>(texture: T, sampler: sampler, coords: v3f, level: number): v4f;
+declare function sampleLevelCpu<T extends texture3d>(texture: T, sampler: sampler, coords: v3f, level: number, offset: v3i): v4f;
+declare function sampleLevelCpu<T extends textureCubeArray>(texture: T, sampler: sampler, coords: v3f, arrayIndex: number, level: number): v4f;
+declare function sampleLevelCpu<T extends textureDepth2d>(texture: T, sampler: sampler, coords: v2f, level: number): number;
+declare function sampleLevelCpu<T extends textureDepth2d>(texture: T, sampler: sampler, coords: v2f, level: number, offset: v2i): number;
+declare function sampleLevelCpu<T extends textureDepth2dArray>(texture: T, sampler: sampler, coords: v2f, arrayIndex: number, level: number): number;
+declare function sampleLevelCpu<T extends textureDepth2dArray>(texture: T, sampler: sampler, coords: v2f, arrayIndex: number, level: number, offset: v2i): number;
+declare function sampleLevelCpu<T extends textureDepthCube>(texture: T, sampler: sampler, coords: v3f, level: number): number;
+declare function sampleLevelCpu<T extends textureCubeArray>(texture: T, sampler: sampler, coords: v3f, arrayIndex: number, level: number): number;
+declare const textureSampleLevel: DualFn;
+type PrimitiveToLoadedType = {
+  f32: v4f;
+  i32: v4i;
+  u32: v4u;
+};
+type TexelFormatToInstanceType<T extends StorageTextureFormats> = TextureFormats[T]['vectorType'][typeof $repr];
+declare function textureLoadCpu<T extends texture1d>(texture: T, coords: number, level: number): PrimitiveToLoadedType[T[typeof $internal]['type']];
+declare function textureLoadCpu<T extends texture2d>(texture: T, coords: v2i | v2u, level: number): PrimitiveToLoadedType[T[typeof $internal]['type']];
+declare function textureLoadCpu<T extends texture2dArray>(texture: T, coords: v2i | v2u, arrayIndex: number, level: number): PrimitiveToLoadedType[T[typeof $internal]['type']];
+declare function textureLoadCpu<T extends texture3d>(texture: T, coords: v3i | v3u, level: number): PrimitiveToLoadedType[T[typeof $internal]['type']];
+declare function textureLoadCpu<T extends textureMultisampled2d>(texture: T, coords: v2i | v2u, sampleIndex: number): PrimitiveToLoadedType[T[typeof $internal]['type']];
+declare function textureLoadCpu<T extends textureDepth2d>(texture: T, coords: v2i | v2u, level: number): number;
+declare function textureLoadCpu<T extends textureDepth2dArray>(texture: T, coords: v2i | v2u, arrayIndex: number, level: number): number;
+declare function textureLoadCpu<T extends textureDepthMultisampled2d>(texture: T, coords: v2i | v2u, sampleIndex: number): number;
+declare function textureLoadCpu<T extends textureExternal>(texture: T, coords: v2i | v2u): v4f;
+declare function textureLoadCpu<T extends textureStorage1d>(texture: T, coords: number): TexelFormatToInstanceType<T[typeof $internal][0]>;
+declare function textureLoadCpu<T extends textureStorage2d>(texture: T, coords: v2i | v2u): TexelFormatToInstanceType<T[typeof $internal][0]>;
+declare function textureLoadCpu<T extends textureStorage2dArray>(texture: T, coords: v2i | v2u, arrayIndex: number): TexelFormatToInstanceType<T[typeof $internal][0]>;
+declare function textureLoadCpu<T extends textureStorage3d>(texture: T, coords: v3i | v3u): TexelFormatToInstanceType<T[typeof $internal][0]>;
+declare const textureLoad: DualFn;
+declare function textureStoreCpu<T extends textureStorage1d>(texture: T, coords: number, value: TexelFormatToInstanceType<T[typeof $internal][0]>): void;
+declare function textureStoreCpu<T extends textureStorage2d>(texture: T, coords: v2i | v2u, value: TexelFormatToInstanceType<T[typeof $internal][0]>): void;
+declare function textureStoreCpu<T extends textureStorage2dArray>(texture: T, coords: v2i | v2u, arrayIndex: number, value: TexelFormatToInstanceType<T[typeof $internal][0]>): void;
+declare function textureStoreCpu<T extends textureStorage3d>(texture: T, coords: v3i | v3u, value: TexelFormatToInstanceType<T[typeof $internal][0]>): void;
+declare const textureStore: DualFn;
+declare function textureDimensionsCpu<T extends texture1d | textureStorage1d>(texture: T): number;
+declare function textureDimensionsCpu<T extends texture1d>(texture: T, level: number): number;
+declare function textureDimensionsCpu<T extends texture2d | texture2dArray | textureCube | textureCubeArray | textureStorage2d | textureStorage2dArray | textureExternal>(texture: T): v2u;
+declare function textureDimensionsCpu<T extends texture2d | texture2dArray | textureCube | textureCubeArray>(texture: T, level: number): v2u;
+declare function textureDimensionsCpu<T extends texture3d | textureStorage3d>(texture: T): v3u;
+declare function textureDimensionsCpu<T extends texture3d>(texture: T, level: number): v3u;
+declare const textureDimensions: DualFn;
+type Gather2dArgs<T extends texture2d = texture2d> = [component: number, texture: T, sampler: sampler, coords: v2f, offset?: v2i];
+type Gather2dArrayArgs<T extends texture2dArray = texture2dArray> = [component: number, texture: T, sampler: sampler, coords: v2f, arrayIndex: number, offset?: v2i];
+type GatherCubeArgs<T extends textureCube = textureCube> = [component: number, texture: T, sampler: sampler, coords: v3f];
+type GatherCubeArrayArgs<T extends textureCubeArray = textureCubeArray> = [component: number, texture: T, sampler: sampler, coords: v3f, arrayIndex: number];
+type GatherDepth2dArgs = [texture: textureDepth2d, sampler: sampler, coords: v2f, offset?: v2i];
+type GatherDepth2dArrayArgs = [texture: textureDepth2dArray, sampler: sampler, coords: v2f, arrayIndex: number, offset?: v2i];
+type GatherDepthCubeArgs = [texture: textureDepthCube, sampler: sampler, coords: v3f];
+type GatherDepthCubeArrayArgs = [texture: textureDepthCubeArray, sampler: sampler, coords: v3f, arrayIndex: number];
+type TextureGatherCpuFn = {
+  <T extends texture2d>(...args: Gather2dArgs<T>): PrimitiveToLoadedType[T[typeof $internal]['type']];
+  <T extends texture2dArray>(...args: Gather2dArrayArgs<T>): PrimitiveToLoadedType[T[typeof $internal]['type']];
+  <T extends textureCube>(...args: GatherCubeArgs<T>): PrimitiveToLoadedType[T[typeof $internal]['type']];
+  <T extends textureCubeArray>(...args: GatherCubeArrayArgs<T>): PrimitiveToLoadedType[T[typeof $internal]['type']];
+  (...args: GatherDepth2dArgs): v4f;
+  (...args: GatherDepth2dArrayArgs): v4f;
+  (...args: GatherDepthCubeArgs): v4f;
+  (...args: GatherDepthCubeArrayArgs): v4f;
+};
+declare const textureGather: DualFn;
+declare function textureSampleCompareCpu<T extends textureDepth2d>(texture: T, sampler: comparisonSampler, coords: v2f, depthRef: number): number;
+declare function textureSampleCompareCpu<T extends textureDepth2d>(texture: T, sampler: comparisonSampler, coords: v2f, depthRef: number, offset: v2i): number;
+declare function textureSampleCompareCpu<T extends textureDepth2dArray>(texture: T, sampler: comparisonSampler, coords: v2f, arrayIndex: number, depthRef: number): number;
+declare function textureSampleCompareCpu<T extends textureDepth2dArray>(texture: T, sampler: comparisonSampler, coords: v2f, arrayIndex: number, depthRef: number, offset: v2i): number;
+declare function textureSampleCompareCpu<T extends textureDepthCube>(texture: T, sampler: comparisonSampler, coords: v3f, depthRef: number): number;
+declare function textureSampleCompareCpu<T extends textureDepthCubeArray>(texture: T, sampler: comparisonSampler, coords: v3f, arrayIndex: number, depthRef: number): number;
+declare const textureSampleCompare: DualFn;
+declare function textureSampleCompareLevelCpu<T extends textureDepth2d>(texture: T, sampler: comparisonSampler, coords: v2f, depthRef: number): number;
+declare function textureSampleCompareLevelCpu<T extends textureDepth2d>(texture: T, sampler: comparisonSampler, coords: v2f, depthRef: number, offset: v2i): number;
+declare function textureSampleCompareLevelCpu<T extends textureDepth2dArray>(texture: T, sampler: comparisonSampler, coords: v2f, arrayIndex: number, depthRef: number): number;
+declare function textureSampleCompareLevelCpu<T extends textureDepth2dArray>(texture: T, sampler: comparisonSampler, coords: v2f, arrayIndex: number, depthRef: number, offset: v2i): number;
+declare function textureSampleCompareLevelCpu<T extends textureDepthCube>(texture: T, sampler: comparisonSampler, coords: v3f, depthRef: number): number;
+declare function textureSampleCompareLevelCpu<T extends textureDepthCubeArray>(texture: T, sampler: comparisonSampler, coords: v3f, arrayIndex: number, depthRef: number): number;
+declare const textureSampleCompareLevel: DualFn;
+declare function textureSampleBaseClampToEdgeCpu<T extends texture2d | textureExternal>(_texture: T, _sampler: sampler, _coords: v2f): v4f;
+declare function sampleGradCpu<T extends texture2d>(texture: T, sampler: sampler, coords: v2f, ddx: v2f, ddy: v2f): v4f;
+declare function sampleGradCpu<T extends texture2d>(texture: T, sampler: sampler, coords: v2f, ddx: v2f, ddy: v2f, offset: v2i): v4f;
+declare function sampleGradCpu<T extends texture2dArray>(texture: T, sampler: sampler, coords: v2f, arrayIndex: number, ddx: v2f, ddy: v2f): v4f;
+declare function sampleGradCpu<T extends texture2dArray>(texture: T, sampler: sampler, coords: v2f, arrayIndex: number, ddx: v2f, ddy: v2f, offset: v2i): v4f;
+declare function sampleGradCpu<T extends texture3d>(texture: T, sampler: sampler, coords: v3f, ddx: v3f, ddy: v3f): v4f;
+declare function sampleGradCpu<T extends texture3d>(texture: T, sampler: sampler, coords: v3f, ddx: v3f, ddy: v3f, offset: v3i): v4f;
+declare function sampleGradCpu<T extends textureCube>(texture: T, sampler: sampler, coords: v3f, ddx: v3f, ddy: v3f): v4f;
+declare function sampleGradCpu<T extends textureCubeArray>(texture: T, sampler: sampler, coords: v3f, arrayIndex: number, ddx: v3f, ddy: v3f): v4f;
+declare const textureSampleGrad: DualFn;
+declare const textureSampleBaseClampToEdge: DualFn;
+//#endregion
+export { textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore };

package/std/texture.js

@@ -0,0 +1,207 @@
+import { Void } from "../data/wgslTypes.js";
+import { stitch } from "../core/resolve/stitch.js";
+import { f32, i32, u32 } from "../data/numeric.js";
+import { vec2u, vec3u, vec4f, vec4i, vec4u } from "../data/vector.js";
+import { MissingCpuImplError, dualImpl } from "../core/function/dualImpl.js";
+import { isWgslExternalTexture, isWgslTexture } from "../data/texture.js";
+import { getTextureFormatInfo } from "../core/texture/textureFormats.js";
+//#region src/std/texture.ts
+function sampleCpu(_texture, _sampler, _coords, _offsetOrArrayIndex, _maybeOffset) {
+	throw new MissingCpuImplError("Texture sampling relies on GPU resources and cannot be executed outside of a draw call");
+}
+const textureSample = dualImpl({
+	name: "textureSample",
+	normalImpl: sampleCpu,
+	codegenImpl: (_ctx, args) => stitch`textureSample(${args})`,
+	signature: (...args) => {
+		return {
+			argTypes: args,
+			returnType: args[0].type.startsWith("texture_depth") ? f32 : vec4f
+		};
+	}
+});
+function sampleBiasCpu(_texture, _sampler, _coords, _biasOrArrayIndex, _biasOrOffset, _maybeOffset) {
+	throw new MissingCpuImplError("Texture sampling with bias relies on GPU resources and cannot be executed outside of a draw call");
+}
+const textureSampleBias = dualImpl({
+	name: "textureSampleBias",
+	normalImpl: sampleBiasCpu,
+	codegenImpl: (_ctx, args) => stitch`textureSampleBias(${args})`,
+	signature: (...args) => ({
+		argTypes: args,
+		returnType: vec4f
+	})
+});
+function sampleLevelCpu(_texture, _sampler, _coords, _level, _offsetOrArrayIndex, _maybeOffset) {
+	throw new MissingCpuImplError("Texture sampling relies on GPU resources and cannot be executed outside of a draw call");
+}
+const textureSampleLevel = dualImpl({
+	name: "textureSampleLevel",
+	normalImpl: sampleLevelCpu,
+	codegenImpl: (_ctx, args) => stitch`textureSampleLevel(${args})`,
+	signature: (...args) => {
+		return {
+			argTypes: args,
+			returnType: args[0].type.startsWith("texture_depth") ? f32 : vec4f
+		};
+	}
+});
+function textureLoadCpu(_texture, _coords, _levelOrArrayIndex) {
+	throw new MissingCpuImplError("`textureLoad` relies on GPU resources and cannot be executed outside of a draw call");
+}
+const textureLoad = dualImpl({
+	name: "textureLoad",
+	normalImpl: textureLoadCpu,
+	codegenImpl: (_ctx, args) => stitch`textureLoad(${args})`,
+	signature: (...args) => {
+		const texture = args[0];
+		if (isWgslTexture(texture)) {
+			const isDepth = texture.type.startsWith("texture_depth");
+			const sampleType = texture.sampleType;
+			return {
+				argTypes: args,
+				returnType: isDepth ? f32 : sampleType.type === "f32" ? vec4f : sampleType.type === "u32" ? vec4u : vec4i
+			};
+		}
+		if (isWgslExternalTexture(texture)) return {
+			argTypes: args,
+			returnType: vec4f
+		};
+		const format = texture.format;
+		return {
+			argTypes: args,
+			returnType: getTextureFormatInfo(format).vectorType
+		};
+	}
+});
+function textureStoreCpu(_texture, _coords, _arrayIndexOrValue, _maybeValue) {
+	throw new MissingCpuImplError("`textureStore` relies on GPU resources and cannot be executed outside of a draw call");
+}
+const textureStore = dualImpl({
+	name: "textureStore",
+	normalImpl: textureStoreCpu,
+	codegenImpl: (_ctx, args) => stitch`textureStore(${args})`,
+	signature: (...args) => ({
+		argTypes: args,
+		returnType: Void
+	})
+});
+function textureDimensionsCpu(_texture, _level) {
+	throw new MissingCpuImplError("`textureDimensions` relies on GPU resources and cannot be executed outside of a draw call");
+}
+const textureDimensions = dualImpl({
+	name: "textureDimensions",
+	normalImpl: textureDimensionsCpu,
+	codegenImpl: (_ctx, args) => stitch`textureDimensions(${args})`,
+	signature: (...args) => {
+		const dim = args[0].dimension;
+		if (dim === "1d") return {
+			argTypes: args,
+			returnType: u32
+		};
+		if (dim === "3d") return {
+			argTypes: args,
+			returnType: vec3u
+		};
+		return {
+			argTypes: args,
+			returnType: vec2u
+		};
+	}
+});
+const textureGatherCpu = (..._args) => {
+	throw new Error("Texture gather relies on GPU resources and cannot be executed outside of a draw call");
+};
+const sampleTypeToVecType = {
+	f32: vec4f,
+	i32: vec4i,
+	u32: vec4u
+};
+const textureGather = dualImpl({
+	name: "textureGather",
+	normalImpl: textureGatherCpu,
+	codegenImpl: (_ctx, args) => stitch`textureGather(${args})`,
+	signature: (...args) => {
+		if (args[0].type.startsWith("texture")) {
+			const [texture, sampler, coords, _, ...rest] = args;
+			return {
+				argTypes: texture.type === "texture_depth_2d_array" || texture.type === "texture_depth_cube_array" ? [
+					texture,
+					sampler,
+					coords,
+					[u32, i32],
+					...rest
+				] : args,
+				returnType: vec4f
+			};
+		}
+		const [_, texture, sampler, coords, ...rest] = args;
+		return {
+			argTypes: texture.type === "texture_2d_array" || texture.type === "texture_cube_array" ? [
+				[u32, i32],
+				texture,
+				sampler,
+				coords,
+				[u32, i32],
+				...rest
+			] : [
+				[u32, i32],
+				texture,
+				sampler,
+				coords,
+				...rest
+			],
+			returnType: sampleTypeToVecType[texture.sampleType.type]
+		};
+	}
+});
+function textureSampleCompareCpu(_texture, _sampler, _coords, _depthRefOrArrayIndex, _depthRefOrOffset, _maybeOffset) {
+	throw new MissingCpuImplError("Texture comparison sampling relies on GPU resources and cannot be executed outside of a draw call");
+}
+const textureSampleCompare = dualImpl({
+	name: "textureSampleCompare",
+	normalImpl: textureSampleCompareCpu,
+	codegenImpl: (_ctx, args) => stitch`textureSampleCompare(${args})`,
+	signature: (...args) => ({
+		argTypes: args,
+		returnType: f32
+	})
+});
+function textureSampleCompareLevelCpu(_texture, _sampler, _coords, _depthRefOrArrayIndex, _depthRefOrOffset, _maybeOffset) {
+	throw new MissingCpuImplError("Texture comparison sampling with level relies on GPU resources and cannot be executed outside of a draw call");
+}
+const textureSampleCompareLevel = dualImpl({
+	name: "textureSampleCompareLevel",
+	normalImpl: textureSampleCompareLevelCpu,
+	codegenImpl: (ctx, args) => stitch`textureSampleCompareLevel(${args})`,
+	signature: (...args) => ({
+		argTypes: args,
+		returnType: f32
+	})
+});
+function textureSampleBaseClampToEdgeCpu(_texture, _sampler, _coords) {
+	throw new MissingCpuImplError("Texture sampling with base clamp to edge is not supported outside of GPU mode.");
+}
+function sampleGradCpu(_texture, _sampler, _coords, _ddxOrArrayIndex, _ddyOrDdx, _offsetOrDdy, _maybeOffset) {
+	throw new MissingCpuImplError("Texture sampling with gradients relies on GPU resources and cannot be executed outside of a draw call");
+}
+const textureSampleGrad = dualImpl({
+	name: "textureSampleGrad",
+	normalImpl: sampleGradCpu,
+	codegenImpl: (_ctx, args) => stitch`textureSampleGrad(${args})`,
+	signature: (...args) => ({
+		argTypes: args,
+		returnType: vec4f
+	})
+});
+const textureSampleBaseClampToEdge = dualImpl({
+	name: "textureSampleBaseClampToEdge",
+	normalImpl: textureSampleBaseClampToEdgeCpu,
+	codegenImpl: (_ctx, args) => stitch`textureSampleBaseClampToEdge(${args})`,
+	signature: (...args) => ({
+		argTypes: args,
+		returnType: vec4f
+	})
+});
+//#endregion
+export { textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore };

package/tgpu.js

@@ -0,0 +1,42 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { comptime } from "./core/function/comptime.js";
+import { constant } from "./core/constant/tgpuConstant.js";
+import { fn } from "./core/function/tgpuFn.js";
+import { bindGroupLayout } from "./tgpuBindGroupLayout.js";
+import { slot } from "./core/slot/slot.js";
+import { privateVar, workgroupVar } from "./core/variable/tgpuVariable.js";
+import { unroll } from "./core/unroll/tgpuUnroll.js";
+import { resolve, resolveWithContext } from "./core/resolve/tgpuResolve.js";
+import { computeFn } from "./core/function/tgpuComputeFn.js";
+import { vertexLayout } from "./core/vertexLayout/vertexLayout.js";
+import { init, initFromDevice } from "./core/root/init.js";
+import { lazy } from "./core/slot/lazy.js";
+import { accessor, mutableAccessor } from "./core/slot/accessor.js";
+import { fragmentFn } from "./core/function/tgpuFragmentFn.js";
+import { vertexFn } from "./core/function/tgpuVertexFn.js";
+import { tgpuUnstable_exports } from "./tgpuUnstable.js";
+//#region src/tgpu.ts
+var tgpu_exports = /* @__PURE__ */ __exportAll({
+	accessor: () => accessor,
+	bindGroupLayout: () => bindGroupLayout,
+	comptime: () => comptime,
+	computeFn: () => computeFn,
+	const: () => constant,
+	fn: () => fn,
+	fragmentFn: () => fragmentFn,
+	init: () => init,
+	initFromDevice: () => initFromDevice,
+	lazy: () => lazy,
+	mutableAccessor: () => mutableAccessor,
+	privateVar: () => privateVar,
+	resolve: () => resolve,
+	resolveWithContext: () => resolveWithContext,
+	slot: () => slot,
+	unroll: () => unroll,
+	vertexFn: () => vertexFn,
+	vertexLayout: () => vertexLayout,
+	workgroupVar: () => workgroupVar,
+	"~unstable": () => tgpuUnstable_exports
+});
+//#endregion
+export { tgpu_exports };