typegpu 0.10.1 → 0.10.2

package/core/texture/texture.d.ts

@@ -0,0 +1,118 @@
+import { TgpuNamable } from "../../shared/meta.js";
+import { $gpuValueOf, $internal } from "../../shared/symbols.js";
+import { Default, TypedArray, UnionToIntersection } from "../../shared/utilityTypes.js";
+import "../../data/snippet.js";
+import { TextureProps } from "./textureProps.js";
+import { AllowedUsages, LiteralToExtensionMap } from "./usageExtension.js";
+import "../../tgpuBindGroupLayout.js";
+import "../root/rootTypes.js";
+import "../../types.js";
+import { F32 } from "../../data/wgslTypes.js";
+import { TextureFormats, ViewDimensionToDimension } from "./textureFormats.js";
+import { TextureSchemaForDescriptor, WgslStorageTexture, WgslTexture } from "../../data/texture.js";
+import { Infer, ValidateTextureViewSchema } from "../../shared/repr.js";
+
+//#region src/core/texture/texture.d.ts
+type TextureInternals = {
+  unwrap(): GPUTexture;
+};
+type TextureViewInternals = {
+  readonly unwrap: (() => GPUTextureView) | undefined;
+};
+type ExternalImageSource = HTMLCanvasElement | HTMLImageElement | HTMLVideoElement | ImageBitmap | ImageData | OffscreenCanvas | VideoFrame;
+type TgpuTextureViewDescriptor = {
+  /**
+   * Which {@link GPUTextureAspect | aspect(s)} of the texture are accessible to the texture view.
+   */
+  aspect?: GPUTextureAspect;
+  /**
+   * The first (most detailed) mipmap level accessible to the texture view.
+   */
+  baseMipLevel?: GPUIntegerCoordinate;
+  /**
+   * How many mipmap levels, starting with {@link GPUTextureViewDescriptor#baseMipLevel}, are accessible to
+   * the texture view.
+   */
+  mipLevelCount?: GPUIntegerCoordinate;
+  /**
+   * The index of the first array layer accessible to the texture view.
+   */
+  baseArrayLayer?: GPUIntegerCoordinate;
+  /**
+   * How many array layers, starting with {@link GPUTextureViewDescriptor#baseArrayLayer}, are accessible
+   * to the texture view.
+   */
+  arrayLayerCount?: GPUIntegerCoordinate;
+  /**
+   * The format of the texture view. Must be either the {@link GPUTextureDescriptor#format} of the
+   * texture or one of the {@link GPUTextureDescriptor#viewFormats} specified during its creation.
+   */
+  format?: GPUTextureFormat;
+};
+type DefaultViewSchema<T extends Partial<TextureProps>> = TextureSchemaForDescriptor<{
+  dimension: Default<T['dimension'], '2d'>;
+  sampleType: T['format'] extends keyof TextureFormats ? TextureFormats[T['format']]['channelType'] : TextureFormats[keyof TextureFormats]['channelType'];
+  multisampled: Default<T['sampleCount'], 1> extends 1 ? false : true;
+}>;
+type BaseDimension<T extends string> = T extends keyof ViewDimensionToDimension ? ViewDimensionToDimension[T] : never;
+type OptionalDimension<T extends string> = T extends '2d' | '2d-array' | 'cube' | 'cube-array' ? {
+  dimension?: BaseDimension<T>;
+} : {
+  dimension: BaseDimension<T>;
+};
+type MultisampledProps<T extends WgslTexture> = T['multisampled'] extends true ? OptionalDimension<T['dimension']> & {
+  sampleCount: 4;
+} : OptionalDimension<T['dimension']> & {
+  sampleCount?: 1;
+};
+type PropsForSchema<T extends WgslTexture | WgslStorageTexture> = T extends WgslTexture ? {
+  size: readonly number[];
+  format: GPUTextureFormat;
+} & MultisampledProps<T> : T extends WgslStorageTexture ? {
+  size: readonly number[];
+  format: T['format'];
+} & OptionalDimension<T['dimension']> : never;
+type CopyCompatibleTexture<T extends TextureProps> = TgpuTexture<{
+  size: T['size'];
+  format: T['format'];
+  sampleCount?: T['sampleCount'];
+}>;
+interface TgpuTexture<TProps extends TextureProps = any> extends TgpuNamable {
+  readonly [$internal]: TextureInternals;
+  readonly resourceType: 'texture';
+  readonly props: TProps;
+  readonly destroyed: boolean;
+  readonly usableAsStorage: boolean;
+  readonly usableAsSampled: boolean;
+  readonly usableAsRender: boolean;
+  $usage<T extends AllowedUsages<TProps>[]>(...usages: T): this & UnionToIntersection<LiteralToExtensionMap[T[number]]>;
+  createView(...args: this['usableAsSampled'] extends true ? [] : [ValidateTextureViewSchema<this, WgslTexture>]): TgpuTextureView<DefaultViewSchema<TProps>>;
+  createView(schema: 'render', viewDescriptor?: TgpuTextureViewDescriptor): TgpuTextureRenderView;
+  createView<T extends WgslTexture>(schema: ValidateTextureViewSchema<this, T>, viewDescriptor?: TgpuTextureViewDescriptor & {
+    sampleType?: T['sampleType'] extends F32 ? 'float' | 'unfilterable-float' : never;
+  }): TgpuTextureView<T>;
+  createView<T extends WgslStorageTexture>(schema: ValidateTextureViewSchema<this, T>, viewDescriptor?: TgpuTextureViewDescriptor): TgpuTextureView<T>;
+  clear(mipLevel?: number | 'all'): void;
+  generateMipmaps(baseMipLevel?: number, mipLevels?: number): void;
+  write(source: ExternalImageSource | ExternalImageSource[]): void;
+  write(source: ArrayBuffer | TypedArray | DataView, mipLevel?: number): void;
+  copyFrom<T extends CopyCompatibleTexture<TProps>>(source: T): void;
+  destroy(): void;
+}
+interface TgpuTextureView<TSchema extends WgslStorageTexture | WgslTexture = WgslStorageTexture | WgslTexture> extends TgpuNamable {
+  readonly [$internal]: TextureViewInternals;
+  readonly resourceType: 'texture-view';
+  readonly schema: TSchema;
+  readonly size?: number[] | undefined;
+  readonly [$gpuValueOf]: Infer<TSchema>;
+  value: Infer<TSchema>;
+  $: Infer<TSchema>;
+}
+interface TgpuTextureRenderView {
+  readonly [$internal]: TextureViewInternals;
+  readonly resourceType: 'texture-view';
+  readonly descriptor: TgpuTextureViewDescriptor;
+}
+declare function isTexture(value: unknown): value is TgpuTexture;
+//#endregion
+export { PropsForSchema, TextureInternals, TgpuTexture, TgpuTextureRenderView, TgpuTextureView, isTexture };

package/core/texture/texture.js

@@ -0,0 +1,312 @@
+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 { isWgslStorageTexture, textureDescriptorToSchema } from "../../data/texture.js";
+import { getTextureFormatInfo } from "./textureFormats.js";
+import { generateTextureMipmaps, getImageSourceDimensions, resampleImage } from "./textureUtils.js";
+
+//#region src/core/texture/texture.ts
+function getDescriptorForProps(props) {
+	return {
+		dimension: props.dimension ?? "2d",
+		sampleType: getTextureFormatInfo(props.format).channelType,
+		multisampled: !((props.sampleCount ?? 1) === 1)
+	};
+}
+function INTERNAL_createTexture(props, branch) {
+	return new TgpuTextureImpl(props, branch);
+}
+function isTexture(value) {
+	return value?.resourceType === "texture" && !!value[$internal];
+}
+function isTextureView(value) {
+	return value?.resourceType === "texture-view" && !!value[$internal];
+}
+var TgpuTextureImpl = class {
+	[$internal];
+	resourceType = "texture";
+	usableAsSampled = false;
+	usableAsStorage = false;
+	usableAsRender = false;
+	#formatInfo;
+	#destroyed = false;
+	#flags = GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC;
+	#texture = null;
+	#branch;
+	constructor(props, branch) {
+		this.props = props;
+		const format = props.format;
+		this.#branch = branch;
+		this.#formatInfo = getTextureFormatInfo(format);
+		this[$internal] = { unwrap: () => {
+			if (this.#destroyed) throw new Error("This texture has been destroyed");
+			if (!this.#texture) this.#texture = branch.device.createTexture({
+				label: getName(this) ?? "<unnamed>",
+				format: props.format,
+				size: props.size,
+				usage: this.#flags,
+				dimension: props.dimension ?? "2d",
+				viewFormats: props.viewFormats ?? [],
+				mipLevelCount: props.mipLevelCount ?? 1,
+				sampleCount: props.sampleCount ?? 1
+			});
+			return this.#texture;
+		} };
+	}
+	$name(label) {
+		setName(this, label);
+		return this;
+	}
+	$usage(...usages) {
+		const hasStorage = usages.includes("storage");
+		const hasSampled = usages.includes("sampled");
+		const hasRender = usages.includes("render");
+		this.#flags |= hasSampled ? GPUTextureUsage.TEXTURE_BINDING : 0;
+		this.#flags |= hasStorage ? GPUTextureUsage.STORAGE_BINDING : 0;
+		this.#flags |= hasRender ? GPUTextureUsage.RENDER_ATTACHMENT : 0;
+		this.usableAsStorage ||= hasStorage;
+		this.usableAsSampled ||= hasSampled;
+		this.usableAsRender ||= hasRender;
+		return this;
+	}
+	createView(schema, viewDescriptor) {
+		if (schema === "render") return new TgpuTextureRenderViewImpl(this, viewDescriptor);
+		return new TgpuFixedTextureViewImpl(schema ?? textureDescriptorToSchema(getDescriptorForProps(this.props)), this, viewDescriptor);
+	}
+	#clearMipLevel(mip = 0) {
+		const scale = 2 ** mip;
+		const [width, height, depth] = [
+			Math.max(1, Math.floor((this.props.size[0] ?? 1) / scale)),
+			Math.max(1, Math.floor((this.props.size[1] ?? 1) / scale)),
+			Math.max(1, Math.floor((this.props.size[2] ?? 1) / scale))
+		];
+		const texelSize = this.#formatInfo.texelSize;
+		if (texelSize === "non-copyable") throw new Error(`Cannot clear texture with format '${this.props.format}': this format does not support copy operations.`);
+		this.#branch.device.queue.writeTexture({
+			texture: this[$internal].unwrap(),
+			mipLevel: mip
+		}, new Uint8Array(width * height * depth * texelSize), {
+			bytesPerRow: texelSize * width,
+			rowsPerImage: height
+		}, [
+			width,
+			height,
+			depth
+		]);
+	}
+	clear(mipLevel = "all") {
+		if (mipLevel === "all") {
+			const mipLevels = this.props.mipLevelCount ?? 1;
+			for (let i = 0; i < mipLevels; i++) this.#clearMipLevel(i);
+		} else this.#clearMipLevel(mipLevel);
+	}
+	generateMipmaps(baseMipLevel = 0, mipLevels) {
+		if (!this.usableAsRender) throw new Error("generateMipmaps called without specifying 'render' usage. Add it via the $usage('render') method.");
+		const actualMipLevels = mipLevels ?? (this.props.mipLevelCount ?? 1) - baseMipLevel;
+		if (actualMipLevels <= 1) {
+			console.warn(`generateMipmaps is a no-op: would generate ${actualMipLevels} mip levels (base: ${baseMipLevel}, total: ${this.props.mipLevelCount ?? 1})`);
+			return;
+		}
+		if (baseMipLevel >= (this.props.mipLevelCount ?? 1)) throw new Error(`Base mip level ${baseMipLevel} is out of range. Texture has ${this.props.mipLevelCount ?? 1} mip levels.`);
+		generateTextureMipmaps(this.#branch.device, this[$internal].unwrap(), baseMipLevel, actualMipLevels);
+	}
+	write(source, mipLevel = 0) {
+		if (source instanceof ArrayBuffer || ArrayBuffer.isView(source)) {
+			this.#writeBufferData(source, mipLevel);
+			return;
+		}
+		const dimension = this.props.dimension ?? "2d";
+		if (!Array.isArray(source)) {
+			this.#writeSingleLayer(source, dimension === "3d" ? 0 : void 0);
+			return;
+		}
+		const layerCount = this.props.size[2] ?? 1;
+		if (source.length > layerCount) console.warn(`Too many image sources provided. Expected ${layerCount} layers, got ${source.length}. Extra sources will be ignored.`);
+		for (let layer = 0; layer < Math.min(source.length, layerCount); layer++) {
+			const bitmap = source[layer];
+			if (bitmap) this.#writeSingleLayer(bitmap, layer);
+		}
+	}
+	#writeBufferData(source, mipLevel) {
+		const mipWidth = Math.max(1, this.props.size[0] >> mipLevel);
+		const mipHeight = Math.max(1, (this.props.size[1] ?? 1) >> mipLevel);
+		const mipDepth = Math.max(1, (this.props.size[2] ?? 1) >> mipLevel);
+		const texelSize = this.#formatInfo.texelSize;
+		if (texelSize === "non-copyable") throw new Error(`Cannot write to texture with format '${this.props.format}': this format does not support copy operations.`);
+		const expectedSize = mipWidth * mipHeight * mipDepth * texelSize;
+		const actualSize = source.byteLength ?? source.byteLength;
+		if (actualSize !== expectedSize) throw new Error(`Buffer size mismatch. Expected ${expectedSize} bytes for mip level ${mipLevel}, got ${actualSize} bytes.`);
+		this.#branch.device.queue.writeTexture({
+			texture: this[$internal].unwrap(),
+			mipLevel
+		}, "buffer" in source ? source.buffer : source, {
+			bytesPerRow: texelSize * mipWidth,
+			rowsPerImage: mipHeight
+		}, [
+			mipWidth,
+			mipHeight,
+			mipDepth
+		]);
+	}
+	#writeSingleLayer(source, layer) {
+		const targetWidth = this.props.size[0];
+		const targetHeight = this.props.size[1] ?? 1;
+		const { width: sourceWidth, height: sourceHeight } = getImageSourceDimensions(source);
+		if (sourceWidth !== targetWidth || sourceHeight !== targetHeight) {
+			resampleImage(this.#branch.device, this[$internal].unwrap(), source, layer);
+			return;
+		}
+		this.#branch.device.queue.copyExternalImageToTexture({ source }, {
+			texture: this[$internal].unwrap(),
+			...layer !== void 0 && { origin: {
+				x: 0,
+				y: 0,
+				z: layer
+			} }
+		}, layer !== void 0 ? [
+			targetWidth,
+			targetHeight,
+			1
+		] : this.props.size);
+	}
+	copyFrom(source) {
+		if (source.props.format !== this.props.format) throw new Error(`Texture format mismatch. Source texture has format ${source.props.format}, target texture has format ${this.props.format}`);
+		if (source.props.size[0] !== this.props.size[0] || (source.props.size[1] ?? 1) !== (this.props.size[1] ?? 1) || (source.props.size[2] ?? 1) !== (this.props.size[2] ?? 1)) throw new Error(`Texture size mismatch. Source texture has size ${source.props.size.join("x")}, target texture has size ${this.props.size.join("x")}`);
+		const commandEncoder = this.#branch.device.createCommandEncoder();
+		commandEncoder.copyTextureToTexture({ texture: source[$internal].unwrap() }, { texture: this[$internal].unwrap() }, source.props.size);
+		this.#branch.device.queue.submit([commandEncoder.finish()]);
+	}
+	toString() {
+		return `${this.resourceType}:${getName(this) ?? "<unnamed>"}`;
+	}
+	get destroyed() {
+		return this.#destroyed;
+	}
+	destroy() {
+		if (this.#destroyed) return;
+		this.#destroyed = true;
+		this.#texture?.destroy();
+	}
+};
+var TgpuFixedTextureViewImpl = class {
+	[$internal];
+	resourceType = "texture-view";
+	#baseTexture;
+	#view;
+	#descriptor;
+	constructor(schema, baseTexture, descriptor) {
+		this.schema = schema;
+		this.#baseTexture = baseTexture;
+		this.#descriptor = descriptor;
+		this[$internal] = { unwrap: () => {
+			if (!this.#view) {
+				const schema = this.schema;
+				const format = isWgslStorageTexture(schema) ? schema.format : this.#baseTexture.props.format;
+				this.#view = this.#baseTexture[$internal].unwrap().createView({
+					...this.#descriptor,
+					label: getName(this) ?? "<unnamed>",
+					format: this.#descriptor?.format ?? format,
+					dimension: schema.dimension
+				});
+			}
+			return this.#view;
+		} };
+	}
+	$name(label) {
+		setName(this, label);
+		if (this.#view) this.#view.label = label;
+		return this;
+	}
+	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 texture view values is possible only as part of a compute dispatch or draw call. Try .read() or .write() instead");
+	}
+	get value() {
+		return this.$;
+	}
+	get size() {
+		return this.#baseTexture.props.size;
+	}
+	toString() {
+		return `textureView:${getName(this) ?? "<unnamed>"}`;
+	}
+	[$resolve](ctx) {
+		const id = ctx.getUniqueName(this);
+		const { group, binding } = ctx.allocateFixedEntry(isWgslStorageTexture(this.schema) ? { storageTexture: this.schema } : {
+			texture: this.schema,
+			sampleType: this.#descriptor?.sampleType ?? this.schema.bindingSampleType[0]
+		}, this);
+		ctx.addDeclaration(`@group(${group}) @binding(${binding}) var ${id}: ${ctx.resolve(this.schema).value};`);
+		return snip(id, this.schema, "handle");
+	}
+};
+var TgpuLaidOutTextureViewImpl = class {
+	[$internal] = { unwrap: void 0 };
+	resourceType = "texture-view";
+	#membership;
+	constructor(schema, membership) {
+		this.schema = schema;
+		this.#membership = membership;
+		setName(this, membership.key);
+	}
+	toString() {
+		return `textureView:${getName(this) ?? "<unnamed>"}`;
+	}
+	[$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(`Accessed view '${getName(this) ?? "<unnamed>"}' outside of codegen mode. 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.$;
+	}
+	$name(label) {
+		setName(this, label);
+		return this;
+	}
+};
+var TgpuTextureRenderViewImpl = class {
+	[$internal];
+	resourceType = "texture-view";
+	constructor(baseTexture, descriptor = {}) {
+		this.descriptor = descriptor;
+		this[$internal] = { unwrap: () => {
+			return baseTexture[$internal].unwrap().createView({
+				label: getName(this) ?? "<unnamed>",
+				...this.descriptor
+			});
+		} };
+	}
+};
+
+//#endregion
+export { INTERNAL_createTexture, TgpuLaidOutTextureViewImpl, isTexture, isTextureView };

package/core/texture/textureFormats.d.ts

@@ -0,0 +1,29 @@
+import { F32, I32, U32, Vec4f, Vec4i, Vec4u } from "../../data/wgslTypes.js";
+
+//#region src/core/texture/textureFormats.d.ts
+type ViewDimensionToDimension = {
+  '1d': '1d';
+  '2d': '2d';
+  '2d-array': '2d';
+  '3d': '3d';
+  cube: '2d';
+  'cube-array': '2d';
+};
+type StorageTextureFormats = 'rgba8unorm' | 'rgba8snorm' | 'rgba8uint' | 'rgba8sint' | 'rgba16unorm' | 'rgba16snorm' | 'rgba16uint' | 'rgba16sint' | 'rgba16float' | 'rg8unorm' | 'rg8snorm' | 'rg8uint' | 'rg8sint' | 'rg16unorm' | 'rg16snorm' | 'rg16uint' | 'rg16sint' | 'rg16float' | 'r32uint' | 'r32sint' | 'r32float' | 'rg32uint' | 'rg32sint' | 'rg32float' | 'rgba32uint' | 'rgba32sint' | 'rgba32float' | 'bgra8unorm' | 'r8unorm' | 'r8snorm' | 'r8uint' | 'r8sint' | 'r16unorm' | 'r16snorm' | 'r16uint' | 'r16sint' | 'r16float' | 'rgb10a2unorm' | 'rgb10a2uint' | 'rg11b10ufloat';
+type ParseChannelType<T extends GPUTextureFormat> = T extends `${string}uint${string}` ? 'u32' : T extends `${string}sint${string}` ? 'i32' : 'f32';
+type ChannelTypeToSampleType<T extends 'f32' | 'i32' | 'u32'> = {
+  f32: F32;
+  i32: I32;
+  u32: U32;
+}[T];
+type ChannelTypeToVectorType<T extends 'f32' | 'i32' | 'u32'> = {
+  f32: Vec4f;
+  i32: Vec4i;
+  u32: Vec4u;
+}[T];
+type TextureFormats = { [K in GPUTextureFormat]: {
+  channelType: ChannelTypeToSampleType<ParseChannelType<K>>;
+  vectorType: ChannelTypeToVectorType<ParseChannelType<K>>;
+} };
+//#endregion
+export { StorageTextureFormats, TextureFormats, ViewDimensionToDimension };

package/core/texture/textureFormats.js

@@ -0,0 +1,99 @@
+import { f32, i32, u32 } from "../../data/numeric.js";
+import { vec4f, vec4i, vec4u } from "../../data/vector.js";
+
+//#region src/core/texture/textureFormats.ts
+const DEPTH_ASPECT_NON_COPYABLE = {
+	channelType: f32,
+	vectorType: vec4f,
+	sampleTypes: ["depth", "unfilterable-float"],
+	texelSize: "non-copyable"
+};
+const DEPTH_ASPECT_16 = {
+	channelType: f32,
+	vectorType: vec4f,
+	sampleTypes: ["depth", "unfilterable-float"],
+	texelSize: 2
+};
+const DEPTH_ASPECT_32 = {
+	channelType: f32,
+	vectorType: vec4f,
+	sampleTypes: ["depth", "unfilterable-float"],
+	texelSize: 4
+};
+const STENCIL_ASPECT = {
+	channelType: u32,
+	vectorType: vec4u,
+	sampleTypes: ["uint"],
+	texelSize: 1
+};
+const formatInfoCache = /* @__PURE__ */ new Map();
+function getTextureFormatInfo(format) {
+	let info = formatInfoCache.get(format);
+	if (info === void 0) {
+		info = createFormatInfo(format);
+		formatInfoCache.set(format, info);
+	}
+	return info;
+}
+function createFormatInfo(format) {
+	const channelType = parseChannelType(format);
+	const depthAspect = getDepthAspect(format);
+	const hasStencil = format.includes("stencil");
+	return {
+		channelType,
+		vectorType: channelType === u32 ? vec4u : channelType === i32 ? vec4i : vec4f,
+		texelSize: parseTexelSize(format),
+		sampleTypes: parseSampleTypes(format),
+		canRenderAttachment: canRenderAttachment(format),
+		...depthAspect && { depthAspect },
+		...hasStencil && { stencilAspect: STENCIL_ASPECT }
+	};
+}
+function getDepthAspect(format) {
+	if (format === "depth16unorm") return DEPTH_ASPECT_16;
+	if (format === "depth32float" || format === "depth32float-stencil8") return DEPTH_ASPECT_32;
+	if (format === "depth24plus" || format === "depth24plus-stencil8") return DEPTH_ASPECT_NON_COPYABLE;
+}
+function canRenderAttachment(format) {
+	if (format.startsWith("bc") || format.startsWith("etc2") || format.startsWith("eac") || format.startsWith("astc")) return false;
+	if (format === "rgb9e5ufloat") return false;
+	return true;
+}
+function parseChannelType(format) {
+	if (format === "stencil8") return u32;
+	if (format.includes("uint")) return u32;
+	if (format.includes("sint")) return i32;
+	return f32;
+}
+function parseTexelSize(format) {
+	const [, channels, bits] = format.match(/^(rgba|bgra|rg|r)(8|16|32)/) ?? [];
+	if (channels && bits) return channels.length * Number(bits) / 8;
+	if (format === "stencil8") return 1;
+	if (format === "depth16unorm") return 2;
+	if (format === "depth32float") return 4;
+	if (format === "depth32float-stencil8") return 5;
+	if (format === "depth24plus" || format === "depth24plus-stencil8") return "non-copyable";
+	if (/^(bc[14]-|etc2-rgb8|eac-r11)/.test(format)) return 8;
+	if (/^(bc|astc-|etc2-rgba|eac-rg)/.test(format)) return 16;
+	return 4;
+}
+function parseSampleTypes(format) {
+	if (format === "stencil8") return ["uint"];
+	if (format.includes("uint")) return ["uint"];
+	if (format.includes("sint")) return ["sint"];
+	if (format.includes("depth")) return ["depth", "unfilterable-float"];
+	if (/^(r|rg|rgba)16(u|s)norm$/.test(format)) return ["unfilterable-float"];
+	return ["float", "unfilterable-float"];
+}
+const FLOAT32_FORMATS = new Set([
+	"r32float",
+	"rg32float",
+	"rgba32float"
+]);
+function getEffectiveSampleTypes(device, format) {
+	if (FLOAT32_FORMATS.has(format) && !device.features.has("float32-filterable")) return ["unfilterable-float"];
+	return getTextureFormatInfo(format).sampleTypes;
+}
+
+//#endregion
+export { getEffectiveSampleTypes, getTextureFormatInfo };

package/core/texture/textureProps.d.ts

@@ -0,0 +1,11 @@
+//#region src/core/texture/textureProps.d.ts
+type TextureProps = {
+  size: readonly number[];
+  format: GPUTextureFormat;
+  viewFormats?: GPUTextureFormat[] | undefined;
+  dimension?: GPUTextureDimension | undefined;
+  mipLevelCount?: number | undefined;
+  sampleCount?: number | undefined;
+};
+//#endregion
+export { TextureProps };