typegpu 0.10.0 → 0.10.2

package/std/texture.d.ts

@@ -0,0 +1,108 @@
+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<typeof sampleCpu>;
+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<typeof sampleBiasCpu>;
+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<typeof sampleLevelCpu>;
+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<typeof textureLoadCpu>;
+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<typeof textureStoreCpu>;
+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<typeof textureDimensionsCpu>;
+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<TextureGatherCpuFn>;
+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<typeof textureSampleCompareCpu>;
+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<typeof textureSampleCompareLevelCpu>;
+declare function textureSampleBaseClampToEdgeCpu<T extends texture2d | textureExternal>(_texture: T, _sampler: sampler, _coords: v2f): v4f;
+declare const textureSampleBaseClampToEdge: DualFn<typeof textureSampleBaseClampToEdgeCpu>;
+//#endregion
+export { textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleLevel, textureStore };

package/std/texture.js

@@ -0,0 +1,197 @@
+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.");
+}
+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, textureSampleLevel, textureStore };

package/tgpu.js

@@ -0,0 +1,44 @@
+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 };

package/tgpuBindGroupLayout.d.ts

@@ -0,0 +1,161 @@
+import { TgpuNamable } from "./shared/meta.js";
+import { $gpuValueOf, $internal } from "./shared/symbols.js";
+import { Default, NullableToOptional, Prettify } from "./shared/utilityTypes.js";
+import { WgslComparisonSampler, WgslSampler } from "./data/sampler.js";
+import { StorageFlag } from "./extension.js";
+import { TgpuBufferMutable, TgpuBufferReadonly, TgpuBufferUniform } from "./core/buffer/bufferUsage.js";
+import { SampledFlag } from "./core/texture/usageExtension.js";
+import { Unwrapper } from "./unwrapper.js";
+import { TgpuComparisonSampler, TgpuSampler } from "./core/sampler/sampler.js";
+import { TgpuExternalTexture } from "./core/texture/externalTexture.js";
+import { TgpuBuffer, UniformFlag } from "./core/buffer/buffer.js";
+import { TgpuShaderStage } from "./types.js";
+import { AnyWgslData, BaseData, F32, I32, U32 } from "./data/wgslTypes.js";
+import { StorageTextureFormats } from "./core/texture/textureFormats.js";
+import { StorageTextureDimension, TextureSchemaForDescriptor, WgslExternalTexture, WgslStorageTexture, WgslTexture } from "./data/texture.js";
+import { PropsForSchema, TgpuTexture, TgpuTextureView } from "./core/texture/texture.js";
+import { InferGPU, MemIdentity } from "./shared/repr.js";
+
+//#region src/tgpuBindGroupLayout.d.ts
+type TgpuLayoutEntryBase = {
+  /**
+   * Limits this resource's visibility to specific shader stages.
+   *
+   * By default, each resource is visible to all shader stage types, but
+   * depending on the underlying implementation, this may have performance implications.
+   *
+   * @default ['compute','fragment'] for mutable resources
+   * @default ['compute','vertex','fragment'] for everything else
+   */
+  visibility?: TgpuShaderStage[];
+};
+type TgpuLayoutUniform = TgpuLayoutEntryBase & {
+  uniform: BaseData;
+};
+type TgpuLayoutStorage = TgpuLayoutEntryBase & {
+  storage: BaseData | ((arrayLength: number) => BaseData); /** @default 'readonly' */
+  access?: 'mutable' | 'readonly';
+};
+type TgpuLayoutSampler = TgpuLayoutEntryBase & {
+  sampler: 'filtering' | 'non-filtering';
+};
+type TgpuLayoutComparisonSampler = TgpuLayoutEntryBase & {
+  sampler: 'comparison';
+};
+type TgpuLayoutTexture<TSchema extends WgslTexture = WgslTexture> = TgpuLayoutEntryBase & {
+  texture: TSchema;
+  sampleType?: GPUTextureSampleType;
+};
+type TgpuLayoutStorageTexture<TSchema extends WgslStorageTexture = WgslStorageTexture> = TgpuLayoutEntryBase & {
+  storageTexture: TSchema;
+};
+type TgpuLayoutExternalTexture = TgpuLayoutEntryBase & {
+  externalTexture: WgslExternalTexture;
+};
+type TgpuLegacyLayoutTexture<TSampleType extends GPUTextureSampleType = GPUTextureSampleType> = TgpuLayoutEntryBase & {
+  /**
+   * - 'float' - f32
+   * - 'unfilterable-float' - f32, cannot be used with filtering samplers
+   * - 'depth' - f32
+   * - 'sint' - i32
+   * - 'uint' - u32
+   */
+  texture: TSampleType;
+  /**
+   * @default '2d'
+   */
+  viewDimension?: GPUTextureViewDimension;
+  /**
+   * @default false
+   */
+  multisampled?: boolean;
+};
+type TgpuLegacyLayoutStorageTexture<TFormat extends StorageTextureFormats = StorageTextureFormats> = TgpuLayoutEntryBase & {
+  storageTexture: TFormat; /** @default 'writeonly' */
+  access?: 'readonly' | 'writeonly' | 'mutable'; /** @default '2d' */
+  viewDimension?: StorageTextureDimension;
+};
+type TgpuLegacyLayoutExternalTexture = TgpuLayoutEntryBase & {
+  externalTexture: Record<string, never>;
+};
+type TgpuLegacyLayoutEntry = TgpuLayoutUniform | TgpuLayoutStorage | TgpuLayoutSampler | TgpuLayoutComparisonSampler | TgpuLegacyLayoutTexture | TgpuLegacyLayoutStorageTexture | TgpuLegacyLayoutExternalTexture;
+type TgpuLayoutEntry = TgpuLayoutUniform | TgpuLayoutStorage | TgpuLayoutSampler | TgpuLayoutComparisonSampler | TgpuLayoutTexture | TgpuLayoutStorageTexture | TgpuLayoutExternalTexture;
+type SampleTypeToPrimitive = {
+  float: F32;
+  'unfilterable-float': F32;
+  depth: F32;
+  sint: I32;
+  uint: U32;
+};
+type LeagcyAccessToAccess = {
+  writeonly: 'write-only';
+  readonly: 'read-only';
+  mutable: 'read-write';
+};
+type MapLegacyTextureToUpToDate<T extends Record<string, TgpuLegacyLayoutEntry | TgpuLayoutEntry | null>> = { [K in keyof T]: T[K] extends TgpuLayoutEntry | null ? T[K] : T[K] extends TgpuLegacyLayoutTexture<infer SampleType> ? TgpuLayoutTexture<TextureSchemaForDescriptor<{
+  dimension: Default<T[K]['viewDimension'], '2d'>;
+  sampleType: SampleTypeToPrimitive[SampleType];
+  multisampled: Default<T[K]['multisampled'], false>;
+}>> : T[K] extends TgpuLegacyLayoutStorageTexture<infer Format> ? TgpuLayoutStorageTexture<TextureSchemaForDescriptor<{
+  access: LeagcyAccessToAccess[Default<T[K]['access'], 'writeonly'>];
+  format: Format;
+  dimension: Default<T[K]['viewDimension'], '2d'>;
+}>> : T[K] extends TgpuLegacyLayoutExternalTexture ? TgpuLayoutExternalTexture : never };
+type UnwrapRuntimeConstructorInner<T extends BaseData | ((_: number) => BaseData)> = T extends ((_: number) => BaseData) ? ReturnType<T> : T;
+type UnwrapRuntimeConstructor<T extends BaseData | ((_: number) => BaseData)> = T extends unknown ? UnwrapRuntimeConstructorInner<T> : never;
+interface BindGroupLayoutInternals<Entries extends Record<string, TgpuLayoutEntry | null>> {
+  bound: { [K in keyof Entries]: BindLayoutEntry<Entries[K]> };
+}
+interface TgpuBindGroupLayout<Entries extends Record<string, TgpuLayoutEntry | null> = Record<string, TgpuLayoutEntry | null>> extends TgpuNamable {
+  readonly [$internal]: BindGroupLayoutInternals<Entries>;
+  readonly resourceType: 'bind-group-layout';
+  readonly entries: Entries;
+  /**
+   * @deprecated Use `layout.$.foo` instead of `layout.bound.foo.$`
+   */
+  readonly bound: { [K in keyof Entries]: BindLayoutEntry<Entries[K]> };
+  readonly [$gpuValueOf]: { [K in keyof Entries]: InferLayoutEntry<Entries[K]> };
+  /**
+   * @deprecated Use `.$` instead, works the same way.
+   */
+  readonly value: { [K in keyof Entries]: InferLayoutEntry<Entries[K]> };
+  readonly $: { [K in keyof Entries]: InferLayoutEntry<Entries[K]> };
+  /**
+   * An explicit numeric index assigned to this bind group layout. If undefined, a unique
+   * index is assigned automatically during resolution. This can be changed with the
+   * `.$idx()` method.
+   */
+  readonly index: number | undefined;
+  /**
+   * Associates this bind group layout with an explicit numeric index. When a call to this
+   * method is omitted, a unique numeric index is assigned to it automatically.
+   *
+   * Used when generating WGSL code: `@group(${index}) @binding(...) ...;`
+   */
+  $idx(index?: number): this;
+  /**
+   * Creates a raw WebGPU resource based on the typed descriptor.
+   * NOTE: This creates a new resource every time, better to use `root.unwrap(...)` instead.
+   * @param unwrapper Used to unwrap any resources that this resource depends on.
+   */
+  unwrap(unwrapper: Unwrapper): GPUBindGroupLayout;
+}
+type StorageUsageForEntry<T extends TgpuLayoutStorage> = T extends {
+  access?: infer Access;
+} ? 'mutable' | 'readonly' extends Access ? TgpuBufferReadonly<UnwrapRuntimeConstructor<T['storage']>> | TgpuBufferMutable<UnwrapRuntimeConstructor<T['storage']>> : 'readonly' extends Access ? TgpuBufferReadonly<UnwrapRuntimeConstructor<T['storage']>> : 'mutable' extends Access ? TgpuBufferMutable<UnwrapRuntimeConstructor<T['storage']>> : TgpuBufferReadonly<UnwrapRuntimeConstructor<T['storage']>> | TgpuBufferMutable<UnwrapRuntimeConstructor<T['storage']>> : TgpuBufferReadonly<UnwrapRuntimeConstructor<T['storage']>>;
+type LayoutEntryToInput<T extends TgpuLayoutEntry | null> = TgpuLayoutEntry | null extends T ? TgpuBuffer<AnyWgslData> | GPUBuffer | TgpuSampler | GPUSampler | TgpuComparisonSampler | TgpuTexture | GPUTextureView | GPUExternalTexture : T extends TgpuLayoutUniform ? (TgpuBuffer<MemIdentity<UnwrapRuntimeConstructor<T['uniform']>>> & UniformFlag) | GPUBuffer : T extends TgpuLayoutStorage ? (TgpuBuffer<MemIdentity<UnwrapRuntimeConstructor<T['storage']>>> & StorageFlag) | GPUBuffer : T extends TgpuLayoutSampler ? TgpuSampler | GPUSampler : T extends TgpuLayoutComparisonSampler ? TgpuComparisonSampler | GPUSampler : T extends TgpuLayoutTexture ? GPUTextureView | GPUTexture | (SampledFlag & TgpuTexture<Prettify<PropsForSchema<T['texture']>>>) | TgpuTextureView<WgslTexture> : T extends TgpuLayoutStorageTexture ? GPUTextureView | GPUTexture | (StorageFlag & TgpuTexture<Prettify<PropsForSchema<T['storageTexture']>>>) | TgpuTextureView<WgslStorageTexture> : T extends TgpuLayoutExternalTexture ? GPUExternalTexture : never;
+type BindLayoutEntry<T extends TgpuLayoutEntry | null> = T extends TgpuLayoutUniform ? TgpuBufferUniform<T['uniform']> : T extends TgpuLayoutStorage ? StorageUsageForEntry<T> : T extends TgpuLayoutSampler ? TgpuSampler : T extends TgpuLayoutComparisonSampler ? TgpuComparisonSampler : T extends TgpuLayoutTexture<infer TSchema> ? TgpuTextureView<TSchema> : T extends TgpuLayoutStorageTexture<infer TSchema> ? TgpuTextureView<TSchema> : T extends TgpuLayoutExternalTexture ? TgpuExternalTexture : never;
+type InferLayoutEntry<T extends TgpuLayoutEntry | null> = T extends TgpuLayoutUniform ? InferGPU<T['uniform']> : T extends TgpuLayoutStorage ? InferGPU<UnwrapRuntimeConstructor<T['storage']>> : T extends TgpuLayoutSampler ? InferGPU<WgslSampler> : T extends TgpuLayoutComparisonSampler ? InferGPU<WgslComparisonSampler> : T extends TgpuLayoutTexture<infer TSchema> ? InferGPU<TSchema> : T extends TgpuLayoutStorageTexture<infer TSchema> ? InferGPU<TSchema> : T extends TgpuLayoutExternalTexture ? InferGPU<T['externalTexture']> : never;
+type ExtractBindGroupInputFromLayout<T extends Record<string, TgpuLayoutEntry | null>> = NullableToOptional<{ [K in keyof T]: LayoutEntryToInput<T[K]> }>;
+type TgpuBindGroup<Entries extends Record<string, TgpuLayoutEntry | null> = Record<string, TgpuLayoutEntry | null>> = {
+  readonly resourceType: 'bind-group';
+  readonly layout: TgpuBindGroupLayout<Entries>;
+  unwrap(unwrapper: Unwrapper): GPUBindGroup;
+};
+declare function bindGroupLayout<Entries extends Record<string, TgpuLayoutEntry | null>>(entries: Entries): TgpuBindGroupLayout<Prettify<Entries>>;
+/**
+ * @deprecated Layouts containing the legacy texture api entries are deprecated and will be removed in future versions. Please use the up-to-date texture api entries instead.
+ */
+declare function bindGroupLayout<Entries extends Record<string, TgpuLegacyLayoutEntry | null>>(entries: Entries): TgpuBindGroupLayout<Prettify<MapLegacyTextureToUpToDate<Entries>>>;
+//#endregion
+export { BindLayoutEntry, ExtractBindGroupInputFromLayout, LayoutEntryToInput, TgpuBindGroup, TgpuBindGroupLayout, TgpuLayoutComparisonSampler, TgpuLayoutEntry, TgpuLayoutExternalTexture, TgpuLayoutSampler, TgpuLayoutStorage, TgpuLayoutTexture, TgpuLayoutUniform, UnwrapRuntimeConstructor, bindGroupLayout };