typegpu 0.10.0 → 0.10.2

package/core/sampler/sampler.js

@@ -0,0 +1,116 @@
+import { $gpuValueOf, $internal, $ownSnippet, $resolve } from "../../shared/symbols.js";
+import { getName, setName } from "../../shared/meta.js";
+import { snip } from "../../data/snippet.js";
+import { inCodegenMode } from "../../execMode.js";
+import { valueProxyHandler } from "../valueProxyUtils.js";
+import { comparisonSampler, sampler } from "../../data/sampler.js";
+
+//#region src/core/sampler/sampler.ts
+function INTERNAL_createSampler(props, branch) {
+	return new TgpuFixedSamplerImpl(sampler(), props, branch);
+}
+function INTERNAL_createComparisonSampler(props, branch) {
+	return new TgpuFixedSamplerImpl(comparisonSampler(), props, branch);
+}
+function isSampler(resource) {
+	const maybe = resource;
+	return maybe?.resourceType === "sampler" && !!maybe[$internal];
+}
+function isComparisonSampler(resource) {
+	const maybe = resource;
+	return maybe?.resourceType === "sampler-comparison" && !!maybe[$internal];
+}
+var TgpuLaidOutSamplerImpl = class {
+	[$internal] = { unwrap: void 0 };
+	resourceType;
+	#membership;
+	constructor(schema, membership) {
+		this.schema = schema;
+		this.#membership = membership;
+		this.resourceType = schema.type === "sampler_comparison" ? "sampler-comparison" : "sampler";
+		setName(this, membership.key);
+	}
+	[$resolve](ctx) {
+		const id = ctx.getUniqueName(this);
+		const group = ctx.allocateLayoutEntry(this.#membership.layout);
+		ctx.addDeclaration(`@group(${group}) @binding(${this.#membership.idx}) var ${id}: ${ctx.resolve(this.schema).value};`);
+		return snip(id, this.schema, "handle");
+	}
+	get [$gpuValueOf]() {
+		const schema = this.schema;
+		return new Proxy({
+			[$internal]: true,
+			get [$ownSnippet]() {
+				return snip(this, schema, "handle");
+			},
+			[$resolve]: (ctx) => ctx.resolve(this),
+			toString: () => `${this.toString()}.$`
+		}, valueProxyHandler);
+	}
+	get $() {
+		if (inCodegenMode()) return this[$gpuValueOf];
+		throw new Error("Direct access to sampler values is possible only as part of a compute dispatch or draw call.");
+	}
+	get value() {
+		return this.$;
+	}
+	toString() {
+		return `${this.resourceType}:${getName(this) ?? "<unnamed>"}`;
+	}
+};
+var TgpuFixedSamplerImpl = class {
+	[$internal];
+	resourceType;
+	#filtering;
+	#sampler = null;
+	#props;
+	#branch;
+	constructor(schema, props, branch) {
+		this.schema = schema;
+		this.#props = props;
+		this.#branch = branch;
+		this.resourceType = schema.type === "sampler_comparison" ? "sampler-comparison" : "sampler";
+		this[$internal] = { unwrap: () => {
+			if (!this.#sampler) this.#sampler = this.#branch.device.createSampler({
+				...this.#props,
+				label: getName(this) ?? "<unnamed>"
+			});
+			return this.#sampler;
+		} };
+		this.#filtering = props.minFilter === "linear" || props.magFilter === "linear" || props.mipmapFilter === "linear";
+	}
+	[$resolve](ctx) {
+		const id = ctx.getUniqueName(this);
+		const { group, binding } = ctx.allocateFixedEntry(this.schema.type === "sampler_comparison" ? { sampler: "comparison" } : { sampler: this.#filtering ? "filtering" : "non-filtering" }, this);
+		ctx.addDeclaration(`@group(${group}) @binding(${binding}) var ${id}: ${ctx.resolve(this.schema).value};`);
+		return snip(id, this.schema, "handle");
+	}
+	get [$gpuValueOf]() {
+		const schema = this.schema;
+		return new Proxy({
+			[$internal]: true,
+			get [$ownSnippet]() {
+				return snip(this, schema, "handle");
+			},
+			[$resolve]: (ctx) => ctx.resolve(this),
+			toString: () => `${this.toString()}.$`
+		}, valueProxyHandler);
+	}
+	get $() {
+		if (inCodegenMode()) return this[$gpuValueOf];
+		throw new Error("Direct access to sampler values is possible only as part of a compute dispatch or draw call.");
+	}
+	get value() {
+		return this.$;
+	}
+	$name(label) {
+		setName(this, label);
+		return this;
+	}
+	toString() {
+		return `${this.resourceType}:${getName(this) ?? "<unnamed>"}`;
+	}
+};
+
+//#endregion
+export { INTERNAL_createComparisonSampler, INTERNAL_createSampler, TgpuLaidOutSamplerImpl, isComparisonSampler, isSampler };

package/core/simulate/tgpuSimulate.d.ts

@@ -0,0 +1,36 @@
+import { TgpuVar } from "../variable/tgpuVariable.js";
+import { TgpuBuffer } from "../buffer/buffer.js";
+import { BaseData } from "../../data/wgslTypes.js";
+
+//#region src/core/simulate/tgpuSimulate.d.ts
+interface SimulationResult<T> {
+  value: T;
+  buffers: Map<TgpuBuffer<BaseData>, unknown>;
+  privateVars: Map<TgpuVar<'private'>, unknown>[][][];
+  workgroupVars: Map<TgpuVar<'workgroup'>, unknown>[][][];
+}
+/**
+ * Runs the provided callback in a simulated environment, giving
+ * it access to buffers and variables as if it were running on the GPU.
+ *
+ * The result of the simulation is returned, and does not affect the actual GPU state,
+ * nor does it carry over to other simulations.
+ *
+ * @param callback The callback to run in the simulated environment.
+ * @returns An object containing the result of the simulation, and
+ *          the final state of the environment.
+ *
+ * @example
+ * const counter = tgpu.privateVar(d.u32);
+ *
+ * const result = tgpu.simulate(() => {
+ *  counter.$ += 1;
+ *  counter.$ += 2;
+ *  return counter.$;
+ * });
+ *
+ * console.log(result.value); // 3
+ */
+declare function simulate<T>(callback: () => T): SimulationResult<T>;
+//#endregion
+export { simulate };

package/core/simulate/tgpuSimulate.js

@@ -0,0 +1,76 @@
+import { SimulationState } from "../../types.js";
+import { getResolutionCtx, provideCtx } from "../../execMode.js";
+import { namespace } from "../resolve/namespace.js";
+import wgslGenerator from "../../tgsl/wgslGenerator.js";
+import { ResolutionCtxImpl } from "../../resolutionCtx.js";
+
+//#region src/core/simulate/tgpuSimulate.ts
+/**
+* Runs the provided callback in a simulated environment, giving
+* it access to buffers and variables as if it were running on the GPU.
+*
+* The result of the simulation is returned, and does not affect the actual GPU state,
+* nor does it carry over to other simulations.
+*
+* @param callback The callback to run in the simulated environment.
+* @returns An object containing the result of the simulation, and
+*          the final state of the environment.
+*
+* @example
+* const counter = tgpu.privateVar(d.u32);
+*
+* const result = tgpu.simulate(() => {
+*  counter.$ += 1;
+*  counter.$ += 2;
+*  return counter.$;
+* });
+*
+* console.log(result.value); // 3
+*/
+function simulate(callback) {
+	const ctx = getResolutionCtx() ?? new ResolutionCtxImpl({
+		namespace: namespace(),
+		shaderGenerator: wgslGenerator
+	});
+	const workgroups = [
+		1,
+		1,
+		1
+	];
+	const workgroupSize = [
+		1,
+		1,
+		1
+	];
+	const threads = [
+		workgroups[0] * workgroupSize[0],
+		workgroups[1] * workgroupSize[1],
+		workgroups[2] * workgroupSize[2]
+	];
+	const buffers = /* @__PURE__ */ new Map();
+	const workgroupVars = Array.from({ length: workgroups[0] }, () => Array.from({ length: workgroups[1] }, () => Array.from({ length: workgroups[2] }, () => /* @__PURE__ */ new Map())));
+	const privateVars = Array.from({ length: threads[0] }, () => Array.from({ length: threads[1] }, () => Array.from({ length: threads[2] }, () => /* @__PURE__ */ new Map())));
+	const simStates = Array.from({ length: threads[0] }, (_, i) => Array.from({ length: threads[1] }, (_, j) => Array.from({ length: threads[2] }, (_, k) => {
+		const wi = Math.floor(i / workgroupSize[0]);
+		const wj = Math.floor(j / workgroupSize[1]);
+		const wk = Math.floor(k / workgroupSize[2]);
+		return new SimulationState(buffers, {
+			private: privateVars[i][j][k],
+			workgroup: workgroupVars[wi][wj][wk]
+		});
+	})));
+	ctx.pushMode(simStates[0][0][0]);
+	try {
+		return {
+			value: provideCtx(ctx, callback),
+			buffers,
+			privateVars,
+			workgroupVars
+		};
+	} finally {
+		ctx.popMode("simulate");
+	}
+}
+
+//#endregion
+export { simulate };

package/core/slot/accessor.d.ts

@@ -0,0 +1,13 @@
+import "../../data/snippet.js";
+import { TgpuAccessor, TgpuMutableAccessor } from "./slotTypes.js";
+import { UnwrapRuntimeConstructor } from "../../tgpuBindGroupLayout.js";
+import "../../types.js";
+import "../../data/wgslTypes.js";
+import "../../shared/repr.js";
+import { AnyData } from "../../data/dataTypes.js";
+
+//#region src/core/slot/accessor.d.ts
+declare function accessor<T extends AnyData | ((count: number) => AnyData)>(schemaOrConstructor: T, defaultValue?: TgpuAccessor.In<NoInfer<T>>): TgpuAccessor<UnwrapRuntimeConstructor<T>>;
+declare function mutableAccessor<T extends AnyData | ((count: number) => AnyData)>(schemaOrConstructor: T, defaultValue?: TgpuMutableAccessor.In<NoInfer<T>>): TgpuMutableAccessor<UnwrapRuntimeConstructor<T>>;
+//#endregion
+export { accessor, mutableAccessor };

package/core/slot/accessor.js

@@ -0,0 +1,97 @@
+import { $getNameForward, $gpuValueOf, $internal, $ownSnippet, $resolve } from "../../shared/symbols.js";
+import { getName, hasTinyestMetadata, setName } from "../../shared/meta.js";
+import { isData } from "../../data/dataTypes.js";
+import { isSnippet, snip } from "../../data/snippet.js";
+import { NormalState, getOwnSnippet } from "../../types.js";
+import { getResolutionCtx, inCodegenMode } from "../../execMode.js";
+import { schemaCallWrapper } from "../../data/schemaCallWrapper.js";
+import { getGpuValueRecursively, valueProxyHandler } from "../valueProxyUtils.js";
+import { isTgpuFn } from "../function/tgpuFn.js";
+import { slot } from "./slot.js";
+
+//#region src/core/slot/accessor.ts
+function accessor(schemaOrConstructor, defaultValue) {
+	return new TgpuAccessorImpl(schemaOrConstructor, defaultValue);
+}
+function mutableAccessor(schemaOrConstructor, defaultValue) {
+	return new TgpuMutableAccessorImpl(schemaOrConstructor, defaultValue);
+}
+var AccessorBase = class {
+	[$internal] = true;
+	[$getNameForward];
+	slot;
+	schema;
+	defaultValue;
+	constructor(schemaOrConstructor, defaultValue = void 0) {
+		this.schema = isData(schemaOrConstructor) ? schemaOrConstructor : schemaOrConstructor(0);
+		this.defaultValue = defaultValue;
+		this.slot = slot(defaultValue);
+		this[$getNameForward] = this.slot;
+	}
+	get [$gpuValueOf]() {
+		return new Proxy({
+			[$internal]: true,
+			[$ownSnippet]: this.#createSnippet(),
+			[$resolve]: (ctx) => ctx.resolve(this),
+			toString: () => `${this.resourceType}:${getName(this) ?? "<unnamed>"}.$`
+		}, valueProxyHandler);
+	}
+	/**
+	* @returns A snippet representing the accessor.
+	*/
+	#createSnippet() {
+		const ctx = getResolutionCtx();
+		let value = getGpuValueRecursively(ctx.unwrap(this.slot));
+		while (typeof value === "function" && !isTgpuFn(value) && !hasTinyestMetadata(value)) {
+			value = value();
+			if (isSnippet(value)) value = value.value;
+		}
+		const ownSnippet = getOwnSnippet(value);
+		if (ownSnippet) return ownSnippet;
+		if (isTgpuFn(value) || hasTinyestMetadata(value)) return ctx.withResetIndentLevel(() => snip(`${ctx.resolve(value).value}()`, this.schema, "runtime"));
+		ctx.pushMode(new NormalState());
+		try {
+			return snip(schemaCallWrapper(this.schema, value), this.schema, "constant");
+		} finally {
+			ctx.popMode("normal");
+		}
+	}
+	$name(label) {
+		setName(this, label);
+		if (this.defaultValue && typeof this.defaultValue === "function" && !getName(this.defaultValue)) setName(this.defaultValue, label);
+		return this;
+	}
+	toString() {
+		return `${this.resourceType}:${getName(this) ?? "<unnamed>"}`;
+	}
+	get value() {
+		return this.$;
+	}
+	[$resolve](ctx) {
+		const snippet = this.#createSnippet();
+		return snip(ctx.resolve(snippet.value, snippet.dataType).value, snippet.dataType, snippet.origin);
+	}
+};
+var TgpuAccessorImpl = class extends AccessorBase {
+	resourceType = "accessor";
+	constructor(schemaOrConstructor, defaultValue = void 0) {
+		super(schemaOrConstructor, defaultValue);
+	}
+	get $() {
+		if (inCodegenMode()) return this[$gpuValueOf];
+		throw new Error("`tgpu.accessor` relies on GPU resources and cannot be accessed outside of a compute dispatch or draw call");
+	}
+};
+var TgpuMutableAccessorImpl = class extends AccessorBase {
+	resourceType = "mutable-accessor";
+	constructor(schemaOrConstructor, defaultValue = void 0) {
+		super(schemaOrConstructor, defaultValue);
+	}
+	get $() {
+		if (inCodegenMode()) return this[$gpuValueOf];
+		throw new Error("`tgpu.mutableAccessor` relies on GPU resources and cannot be accessed outside of a compute dispatch or draw call");
+	}
+};
+
+//#endregion
+export { accessor, mutableAccessor };

package/core/slot/internalSlots.js

@@ -0,0 +1,7 @@
+import { slot } from "./slot.js";
+
+//#region src/core/slot/internalSlots.ts
+const shaderStageSlot = slot(void 0);
+
+//#endregion
+export { shaderStageSlot };

package/core/slot/lazy.d.ts

@@ -0,0 +1,6 @@
+import { TgpuLazy } from "./slotTypes.js";
+
+//#region src/core/slot/lazy.d.ts
+declare function lazy<T>(compute: () => T): TgpuLazy<T>;
+//#endregion
+export { lazy };

package/core/slot/lazy.js

@@ -0,0 +1,42 @@
+import { $gpuValueOf, $internal, $providing } from "../../shared/symbols.js";
+import { isAccessor, isMutableAccessor } from "./slotTypes.js";
+import { getResolutionCtx } from "../../execMode.js";
+import { getGpuValueRecursively } from "../valueProxyUtils.js";
+
+//#region src/core/slot/lazy.ts
+function lazy(compute) {
+	if (getResolutionCtx()) throw new Error("Cannot create tgpu.lazy objects during shader resolution.");
+	return new TgpuLazyImpl(compute, void 0);
+}
+var TgpuLazyImpl = class TgpuLazyImpl {
+	[$internal];
+	[$providing];
+	constructor(compute, providing) {
+		this[$internal] = { compute };
+		this[$providing] = providing;
+	}
+	get [$gpuValueOf]() {
+		const ctx = getResolutionCtx();
+		if (!ctx) throw new Error(`Cannot access tgpu.lazy's value outside of resolution.`);
+		return getGpuValueRecursively(ctx.unwrap(this));
+	}
+	get value() {
+		return this[$gpuValueOf];
+	}
+	get $() {
+		return this[$gpuValueOf];
+	}
+	toString() {
+		return "lazy";
+	}
+	with(slot, value) {
+		return new TgpuLazyImpl(this[$internal].compute.bind(this), {
+			inner: this[$providing]?.inner ?? this,
+			pairs: [...this[$providing]?.pairs ?? [], [isAccessor(slot) || isMutableAccessor(slot) ? slot.slot : slot, value]]
+		});
+	}
+};
+TgpuLazyImpl.prototype.resourceType = "lazy";
+
+//#endregion
+export { lazy };

package/core/slot/slot.d.ts

@@ -0,0 +1,6 @@
+import { TgpuSlot } from "./slotTypes.js";
+
+//#region src/core/slot/slot.d.ts
+declare function slot<T>(defaultValue?: T): TgpuSlot<T>;
+//#endregion
+export { slot };

package/core/slot/slot.js

@@ -0,0 +1,40 @@
+import { $gpuValueOf, $internal } from "../../shared/symbols.js";
+import { getName, setName } from "../../shared/meta.js";
+import { getResolutionCtx } from "../../execMode.js";
+import { getGpuValueRecursively } from "../valueProxyUtils.js";
+
+//#region src/core/slot/slot.ts
+function slot(defaultValue) {
+	return new TgpuSlotImpl(defaultValue);
+}
+var TgpuSlotImpl = class {
+	[$internal] = true;
+	resourceType = "slot";
+	constructor(defaultValue = void 0) {
+		this.defaultValue = defaultValue;
+	}
+	$name(label) {
+		setName(this, label);
+		return this;
+	}
+	areEqual(a, b) {
+		return Object.is(a, b);
+	}
+	toString() {
+		return `slot:${getName(this) ?? "<unnamed>"}`;
+	}
+	get [$gpuValueOf]() {
+		const ctx = getResolutionCtx();
+		if (!ctx) throw new Error(`Cannot access tgpu.slot's value outside of resolution.`);
+		return getGpuValueRecursively(ctx.unwrap(this));
+	}
+	get value() {
+		return this[$gpuValueOf];
+	}
+	get $() {
+		return this.value;
+	}
+};
+
+//#endregion
+export { slot };

package/core/slot/slotTypes.d.ts

@@ -0,0 +1,92 @@
+import { TgpuNamable } from "../../shared/meta.js";
+import { $gpuValueOf, $internal, $providing } from "../../shared/symbols.js";
+import { TgpuBufferUsage } from "../buffer/bufferUsage.js";
+import { TgpuBufferShorthand } from "../buffer/bufferShorthand.js";
+import { TgpuVar, VariableScope } from "../variable/tgpuVariable.js";
+import { UnwrapRuntimeConstructor } from "../../tgpuBindGroupLayout.js";
+import { Withable } from "../root/rootTypes.js";
+import { BaseData } from "../../data/wgslTypes.js";
+import { WgslStorageTexture, WgslTexture } from "../../data/texture.js";
+import { TgpuTextureView } from "../texture/texture.js";
+import { GPUValueOf, Infer, InferGPU } from "../../shared/repr.js";
+import { TgpuConst } from "../constant/tgpuConstant.js";
+
+//#region src/core/slot/slotTypes.d.ts
+interface TgpuSlot<T> extends TgpuNamable {
+  readonly [$internal]: true;
+  readonly resourceType: 'slot';
+  readonly defaultValue: T | undefined;
+  /**
+   * Used to determine if code generated using either value `a` or `b` in place
+   * of the slot will be equivalent. Defaults to `Object.is`.
+   */
+  areEqual(a: T, b: T): boolean;
+  readonly [$gpuValueOf]: GPUValueOf<T>;
+  /**
+   * @deprecated Use `.$` instead, works the same way.
+   */
+  readonly value: GPUValueOf<T>;
+  readonly $: GPUValueOf<T>;
+  toString(): string;
+}
+interface TgpuLazy<out T> extends Withable<TgpuLazy<T>> {
+  readonly [$internal]: {
+    compute(): T;
+  };
+  readonly resourceType: 'lazy';
+  readonly [$gpuValueOf]: GPUValueOf<T>;
+  /**
+   * @deprecated Use `.$` instead, works the same way.
+   */
+  readonly value: GPUValueOf<T>;
+  readonly $: GPUValueOf<T>;
+  readonly [$providing]?: Providing | undefined;
+}
+interface TgpuAccessor<T extends BaseData = BaseData> extends TgpuNamable {
+  readonly [$internal]: true;
+  readonly resourceType: 'accessor';
+  readonly schema: T;
+  readonly defaultValue: TgpuAccessor.In<T> | undefined;
+  readonly slot: TgpuSlot<TgpuAccessor.In<T>>;
+  readonly [$gpuValueOf]: InferGPU<T>;
+  /**
+   * @deprecated Use `.$` instead, works the same way.
+   */
+  readonly value: InferGPU<T>;
+  readonly $: InferGPU<T>;
+}
+type DataAccessorIn<T extends BaseData> = (() => DataAccessorIn<T>) | TgpuBufferUsage<T> | TgpuBufferShorthand<T> | TgpuVar<VariableScope, T> | TgpuConst<T> | Infer<T>;
+type TextureAccessorIn<T extends WgslTexture | WgslStorageTexture> = (() => TextureAccessorIn<T>) | Infer<T> | TgpuTextureView<T>;
+declare namespace TgpuAccessor {
+  type In<T extends BaseData | ((count: number) => BaseData)> = UnwrapRuntimeConstructor<T> extends WgslTexture | WgslStorageTexture ? TextureAccessorIn<UnwrapRuntimeConstructor<T>> : DataAccessorIn<UnwrapRuntimeConstructor<T>>;
+}
+interface TgpuMutableAccessor<T extends BaseData = BaseData> extends TgpuNamable {
+  readonly [$internal]: true;
+  readonly resourceType: 'mutable-accessor';
+  readonly schema: T;
+  readonly defaultValue: TgpuMutableAccessor.In<T> | undefined;
+  readonly slot: TgpuSlot<TgpuMutableAccessor.In<T>>;
+  readonly [$gpuValueOf]: InferGPU<T>;
+  value: InferGPU<T>;
+  $: InferGPU<T>;
+}
+type MutableDataAccessorIn<T extends BaseData> = (() => Infer<T> | MutableDataAccessorIn<T>) | TgpuBufferUsage<T> | TgpuBufferShorthand<T> | TgpuVar<VariableScope, T>;
+type MutableTextureAccessorIn<T extends WgslTexture | WgslStorageTexture> = (() => Infer<T> | TgpuTextureView<T> | MutableTextureAccessorIn<T>) | TgpuTextureView<T>;
+declare namespace TgpuMutableAccessor {
+  type In<T extends BaseData | ((count: number) => BaseData)> = UnwrapRuntimeConstructor<T> extends WgslTexture | WgslStorageTexture ? MutableTextureAccessorIn<UnwrapRuntimeConstructor<T>> : MutableDataAccessorIn<UnwrapRuntimeConstructor<T>>;
+}
+/**
+ * Represents a value that is available at resolution time.
+ */
+type Eventual<T> = T | TgpuSlot<T> | TgpuLazy<T>;
+type SlotValuePair<T = unknown> = [TgpuSlot<T>, T];
+type Providing = {
+  inner: object;
+  pairs: SlotValuePair[];
+};
+declare function isSlot<T>(value: unknown): value is TgpuSlot<T>;
+declare function isLazy<T>(value: unknown): value is TgpuLazy<T>;
+declare function isAccessor<T extends BaseData>(value: unknown): value is TgpuAccessor<T>;
+declare function isMutableAccessor<T extends BaseData>(value: unknown): value is TgpuMutableAccessor<T>;
+//#endregion
+export { Eventual, Providing, SlotValuePair, TgpuAccessor, TgpuLazy, TgpuMutableAccessor, TgpuSlot, isAccessor, isLazy, isMutableAccessor, isSlot };

package/core/slot/slotTypes.js

@@ -0,0 +1,21 @@
+import { $providing } from "../../shared/symbols.js";
+
+//#region src/core/slot/slotTypes.ts
+function isSlot(value) {
+	return value?.resourceType === "slot";
+}
+function isLazy(value) {
+	return value?.resourceType === "lazy";
+}
+function isProviding(value) {
+	return value?.[$providing] !== void 0;
+}
+function isAccessor(value) {
+	return value?.resourceType === "accessor";
+}
+function isMutableAccessor(value) {
+	return value?.resourceType === "mutable-accessor";
+}
+
+//#endregion
+export { isAccessor, isLazy, isMutableAccessor, isProviding, isSlot };

package/core/texture/externalTexture.d.ts

@@ -0,0 +1,12 @@
+import "../../data/snippet.js";
+import "../../tgpuBindGroupLayout.js";
+import "../../types.js";
+import "../../data/texture.js";
+import "../../shared/repr.js";
+
+//#region src/core/texture/externalTexture.d.ts
+interface TgpuExternalTexture {
+  readonly resourceType: 'external-texture';
+}
+//#endregion
+export { TgpuExternalTexture };

package/core/texture/externalTexture.js

@@ -0,0 +1,48 @@
+import { $gpuValueOf, $internal, $ownSnippet, $resolve } from "../../shared/symbols.js";
+import { getName, setName } from "../../shared/meta.js";
+import { snip } from "../../data/snippet.js";
+import { inCodegenMode } from "../../execMode.js";
+import { valueProxyHandler } from "../valueProxyUtils.js";
+import { textureExternal } from "../../data/texture.js";
+
+//#region src/core/texture/externalTexture.ts
+var TgpuExternalTextureImpl = class {
+	resourceType = "external-texture";
+	[$internal] = true;
+	#membership;
+	constructor(schema, membership) {
+		this.schema = schema;
+		this.#membership = membership;
+		setName(this, membership.key);
+	}
+	[$resolve](ctx) {
+		const id = ctx.getUniqueName(this);
+		const group = ctx.allocateLayoutEntry(this.#membership.layout);
+		ctx.addDeclaration(`@group(${group}) @binding(${this.#membership.idx}) var ${id}: ${ctx.resolve(this.schema).value};`);
+		return snip(id, textureExternal(), "handle");
+	}
+	get [$gpuValueOf]() {
+		const schema = this.schema;
+		return new Proxy({
+			[$internal]: true,
+			get [$ownSnippet]() {
+				return snip(this, schema, "handle");
+			},
+			[$resolve]: (ctx) => ctx.resolve(this),
+			toString: () => `textureExternal:${getName(this) ?? "<unnamed>"}.$`
+		}, valueProxyHandler);
+	}
+	get $() {
+		if (inCodegenMode()) return this[$gpuValueOf];
+		throw new Error("Direct access to texture views values is possible only as part of a compute dispatch or draw call. Try .read() or .write() instead");
+	}
+	get value() {
+		return this.$;
+	}
+	toString() {
+		return `textureExternal:${getName(this) ?? "<unnamed>"}`;
+	}
+};
+
+//#endregion
+export { TgpuExternalTextureImpl };