typegpu 0.11.9 → 0.12.1

package/tgpuBindGroupLayout.js

@@ -1,274 +1,352 @@
-import { $gpuValueOf, $internal } from "./shared/symbols.js";
-import { safeStringify } from "./shared/stringify.js";
-import { getName, setName } from "./shared/meta.js";
-import { NotUniformError } from "./errors.js";
-import { f32, i32, u32 } from "./data/numeric.js";
-import { NotStorageError, isUsableAsStorage } from "./extension.js";
-import { TgpuLaidOutBufferImpl, isUsableAsUniform } from "./core/buffer/bufferUsage.js";
-import { isBuffer } from "./core/buffer/buffer.js";
-import { comparisonSampler, sampler } from "./data/sampler.js";
-import { TgpuLaidOutSamplerImpl, isComparisonSampler, isSampler } from "./core/sampler/sampler.js";
-import { textureDescriptorToSchema } from "./data/texture.js";
+import {} from "./core/buffer/buffer.js";
+import { isBuffer, isUsableAsStorage, isUsableAsUniform } from "./types.js";
+import { isComparisonSampler, isSampler, TgpuLaidOutSamplerImpl, } from "./core/sampler/sampler.js";
+import { comparisonSampler as wgslComparisonSampler, sampler as wgslSampler, } from "./data/sampler.js";
 import { TgpuExternalTextureImpl } from "./core/texture/externalTexture.js";
-import { TgpuLaidOutTextureViewImpl, isTexture, isTextureView } from "./core/texture/texture.js";
-import { NotSampledError, isUsableAsSampled } from "./core/texture/usageExtension.js";
-
-//#region src/tgpuBindGroupLayout.ts
-/**
-* Converts legacy entries to new API format
-*/
-function convertLegacyEntries(entries) {
-	const result = {};
-	for (const [key, entry] of Object.entries(entries)) {
-		if (entry === null) {
-			result[key] = null;
-			continue;
-		}
-		if ("texture" in entry && typeof entry.texture === "string") {
-			const sampleType = entry.texture;
-			result[key] = {
-				...entry,
-				texture: textureDescriptorToSchema({
-					dimension: entry.viewDimension ?? "2d",
-					sampleType: sampleType === "sint" ? i32 : sampleType === "uint" ? u32 : f32,
-					multisampled: entry.multisampled ?? false
-				})
-			};
-		} else if ("storageTexture" in entry && typeof entry.storageTexture === "string") {
-			const accessMap = {
-				readonly: "read-only",
-				writeonly: "write-only",
-				mutable: "read-write"
-			};
-			result[key] = {
-				...entry,
-				storageTexture: textureDescriptorToSchema({
-					access: accessMap[entry.access ?? "writeonly"],
-					format: entry.storageTexture,
-					dimension: entry.viewDimension ?? "2d"
-				})
-			};
-		} else if ("externalTexture" in entry && Object.keys(entry.externalTexture).length === 0) result[key] = {
-			...entry,
-			externalTexture: {
-				type: "texture_external",
-				dimension: "2d"
-			}
-		};
-		else result[key] = entry;
-	}
-	return result;
+import { isTexture, isTextureView, TgpuLaidOutTextureViewImpl, } from "./core/texture/texture.js";
+import { isUsableAsSampled, NotSampledError, } from "./core/texture/usageExtension.js";
+import {} from "./data/texture.js";
+import { invariant, NotUniformError } from "./errors.js";
+import { NotStorageError } from "./extension.js";
+import { getName, setName } from "./shared/meta.js";
+import { safeStringify } from "./shared/stringify.js";
+import { $gpuValueOf, $internal, $soul } from "./shared/symbols.js";
+import { TgpuLaidOutBufferImpl } from "./core/buffer/laidOutBuffer.js";
+import { isMutableBinding, isReadonlyBinding, isUniformBinding, } from "./core/buffer/bufferBinding.js";
+export function bindGroupLayout(entries) {
+    return new TgpuBindGroupLayoutImpl({ ...entries });
 }
-function bindGroupLayout(entries) {
-	return new TgpuBindGroupLayoutImpl(convertLegacyEntries(entries));
+export function INTERNAL_restoreBindGroupLayout(soul) {
+    return bindGroupLayout({ ...soul.entries }).$idx(soul.index);
 }
-function isBindGroupLayout(value) {
-	return !!value && value.resourceType === "bind-group-layout";
+export function INTERNAL_restoreBindGroup(soul, ctx) {
+    invariant(soul.raw, 'A bind group soul is only complete once materialized.');
+    return new TgpuBindGroupImpl(ctx.getRoot(soul.device), soul.layout, {}, soul.raw);
 }
-function isBindGroup(value) {
-	return !!value && value.resourceType === "bind-group";
+export function isBindGroupLayout(value) {
+    return !!value && value.resourceType === 'bind-group-layout';
+}
+export function isBindGroup(value) {
+    return !!value && value.resourceType === 'bind-group';
 }
 /**
-* @category Errors
-*/
-var MissingBindingError = class MissingBindingError extends Error {
-	constructor(groupLabel, key) {
-		super(`Bind group '${groupLabel ?? "<unnamed>"}' is missing a required binding '${key}'`);
-		Object.setPrototypeOf(this, MissingBindingError.prototype);
-	}
-};
-const DEFAULT_MUTABLE_VISIBILITY = ["compute", "fragment"];
-const DEFAULT_READONLY_VISIBILITY = [
-	"compute",
-	"vertex",
-	"fragment"
-];
-var TgpuBindGroupLayoutImpl = class {
-	#index;
-	[$internal];
-	resourceType = "bind-group-layout";
-	value = {};
-	$ = this.value;
-	entries;
-	get [$gpuValueOf]() {
-		return this.$;
-	}
-	constructor(entries) {
-		this.entries = entries;
-		let idx = 0;
-		const bound = {};
-		this[$internal] = { bound };
-		for (const [key, entry] of Object.entries(entries)) {
-			if (entry === null) {
-				idx++;
-				continue;
-			}
-			const membership = {
-				layout: this,
-				key,
-				idx
-			};
-			if ("uniform" in entry) bound[key] = new TgpuLaidOutBufferImpl("uniform", entry.uniform, membership);
-			if ("storage" in entry) {
-				const dataType = "type" in entry.storage ? entry.storage : entry.storage(0);
-				bound[key] = new TgpuLaidOutBufferImpl(entry.access ?? "readonly", dataType, membership);
-			}
-			if ("texture" in entry) bound[key] = new TgpuLaidOutTextureViewImpl(entry.texture, membership);
-			if ("storageTexture" in entry) bound[key] = new TgpuLaidOutTextureViewImpl(entry.storageTexture, membership);
-			if ("externalTexture" in entry) bound[key] = new TgpuExternalTextureImpl(entry.externalTexture, membership);
-			if ("sampler" in entry) bound[key] = new TgpuLaidOutSamplerImpl(entry.sampler === "comparison" ? comparisonSampler() : sampler(), membership);
-			Object.defineProperty(this.value, key, { get: () => {
-				return bound[key].value;
-			} });
-			idx++;
-		}
-	}
-	toString() {
-		return `bindGroupLayout:${getName(this) ?? "<unnamed>"}`;
-	}
-	get index() {
-		return this.#index;
-	}
-	$name(label) {
-		setName(this, label);
-		return this;
-	}
-	get bound() {
-		return this[$internal].bound;
-	}
-	$idx(index) {
-		this.#index = index;
-		return this;
-	}
-	unwrap(unwrapper) {
-		return unwrapper.device.createBindGroupLayout({
-			label: getName(this) ?? "<unnamed>",
-			entries: Object.values(this.entries).map((entry, idx) => {
-				if (entry === null) return null;
-				let visibility = entry.visibility;
-				const binding = {
-					binding: idx,
-					visibility: 0
-				};
-				if ("uniform" in entry) {
-					visibility = visibility ?? DEFAULT_READONLY_VISIBILITY;
-					binding.buffer = { type: "uniform" };
-				} else if ("storage" in entry) {
-					visibility = visibility ?? (entry.access === "mutable" ? DEFAULT_MUTABLE_VISIBILITY : DEFAULT_READONLY_VISIBILITY);
-					binding.buffer = { type: entry.access === "mutable" ? "storage" : "read-only-storage" };
-				} else if ("sampler" in entry) {
-					visibility = visibility ?? DEFAULT_READONLY_VISIBILITY;
-					binding.sampler = { type: entry.sampler };
-				} else if ("texture" in entry) {
-					visibility = visibility ?? DEFAULT_READONLY_VISIBILITY;
-					const { multisampled, dimension, bindingSampleType } = entry.texture;
-					binding.texture = {
-						sampleType: entry.sampleType ?? bindingSampleType[0],
-						viewDimension: dimension,
-						multisampled
-					};
-				} else if ("storageTexture" in entry) {
-					visibility = visibility ?? DEFAULT_MUTABLE_VISIBILITY;
-					const { dimension, access, format } = entry.storageTexture;
-					binding.storageTexture = {
-						access,
-						format,
-						viewDimension: dimension
-					};
-				} else if ("externalTexture" in entry) {
-					visibility = visibility ?? DEFAULT_READONLY_VISIBILITY;
-					binding.externalTexture = {};
-				}
-				if (visibility?.includes("compute")) binding.visibility |= GPUShaderStage.COMPUTE;
-				if (visibility?.includes("vertex")) binding.visibility |= GPUShaderStage.VERTEX;
-				if (visibility?.includes("fragment")) binding.visibility |= GPUShaderStage.FRAGMENT;
-				return binding;
-			}).filter((v) => v !== null)
-		});
-	}
-};
-var TgpuBindGroupImpl = class {
-	resourceType = "bind-group";
-	layout;
-	entries;
-	constructor(layout, entries) {
-		this.layout = layout;
-		this.entries = entries;
-		for (const key of Object.keys(layout.entries)) if (layout.entries[key] !== null && !(key in entries)) throw new MissingBindingError(getName(layout), key);
-	}
-	unwrap(unwrapper) {
-		return unwrapper.device.createBindGroup({
-			label: getName(this.layout) ?? "<unnamed>",
-			layout: unwrapper.unwrap(this.layout),
-			entries: Object.entries(this.layout.entries).map(([key, entry], idx) => {
-				if (entry === null) return null;
-				const value = this.entries[key];
-				if (value === void 0) throw new Error(`'${key}' is a resource required to populate bind group layout '${getName(this.layout) ?? "<unnamed>"}'.`);
-				if ("uniform" in entry) {
-					let resource;
-					if (isBuffer(value)) {
-						if (!isUsableAsUniform(value)) throw new NotUniformError(value);
-						resource = { buffer: unwrapper.unwrap(value) };
-					} else resource = { buffer: value };
-					return {
-						binding: idx,
-						resource
-					};
-				}
-				if ("storage" in entry) {
-					let resource;
-					if (isBuffer(value)) {
-						if (!isUsableAsStorage(value)) throw new NotStorageError(value);
-						resource = { buffer: unwrapper.unwrap(value) };
-					} else resource = { buffer: value };
-					return {
-						binding: idx,
-						resource
-					};
-				}
-				if ("texture" in entry) {
-					let resource;
-					if (isTexture(value)) {
-						if (!isUsableAsSampled(value)) throw new NotSampledError(value);
-						resource = unwrapper.unwrap(value.createView(entry.texture));
-					} else if (isTextureView(value)) resource = unwrapper.unwrap(value);
-					else resource = value;
-					return {
-						binding: idx,
-						resource
-					};
-				}
-				if ("storageTexture" in entry) {
-					let resource;
-					if (isTexture(value)) {
-						if (!isUsableAsStorage(value)) throw new NotStorageError(value);
-						resource = unwrapper.unwrap(value.createView(entry.storageTexture));
-					} else if (isTextureView(value)) resource = unwrapper.unwrap(value);
-					else resource = value;
-					return {
-						binding: idx,
-						resource
-					};
-				}
-				if ("sampler" in entry) {
-					if (isComparisonSampler(value) || isSampler(value)) return {
-						binding: idx,
-						resource: unwrapper.unwrap(value)
-					};
-					return {
-						binding: idx,
-						resource: value
-					};
-				}
-				if ("externalTexture" in entry) return {
-					binding: idx,
-					resource: value
-				};
-				throw new Error(`Malformed bind group entry: ${safeStringify(value)}`);
-			}).filter((v) => v !== null)
-		});
-	}
-};
-
-//#endregion
-export { TgpuBindGroupImpl, bindGroupLayout, isBindGroup, isBindGroupLayout };
+ * @category Errors
+ */
+export class MissingBindingError extends Error {
+    constructor(groupLabel, key) {
+        super(`Bind group '${groupLabel ?? '<unnamed>'}' is missing a required binding '${key}'`);
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, MissingBindingError.prototype);
+    }
+}
+// --------------
+// Implementation
+// --------------
+const DEFAULT_MUTABLE_VISIBILITY = ['compute', 'fragment'];
+const DEFAULT_READONLY_VISIBILITY = ['compute', 'vertex', 'fragment'];
+class TgpuBindGroupLayoutImpl {
+    [$internal];
+    [$soul];
+    resourceType = 'bind-group-layout';
+    $ = {};
+    entries;
+    get [$gpuValueOf]() {
+        return this.$;
+    }
+    constructor(entries) {
+        this.entries = entries;
+        this[$internal] = [];
+        const normalizedEntries = {};
+        this[$soul] = {
+            type: 'bind-group-layout',
+            entries: normalizedEntries,
+            index: undefined,
+            label: undefined,
+        };
+        let idx = 0;
+        for (const [key, entry] of Object.entries(entries)) {
+            if (entry === null) {
+                normalizedEntries[key] = null;
+                idx++;
+                continue;
+            }
+            const membership = { layout: this, key, idx };
+            let item = undefined;
+            normalizedEntries[key] = entry;
+            if ('uniform' in entry) {
+                item = new TgpuLaidOutBufferImpl('uniform', entry.uniform, membership);
+            }
+            if ('storage' in entry) {
+                const dataType = 'type' in entry.storage ? entry.storage : entry.storage(0);
+                item = new TgpuLaidOutBufferImpl(entry.access ?? 'readonly', dataType, membership);
+                normalizedEntries[key] = { ...entry, storage: dataType };
+            }
+            if ('texture' in entry) {
+                item = new TgpuLaidOutTextureViewImpl(entry.texture, membership);
+            }
+            if ('storageTexture' in entry) {
+                item = new TgpuLaidOutTextureViewImpl(entry.storageTexture, membership);
+            }
+            if ('externalTexture' in entry) {
+                item = new TgpuExternalTextureImpl(entry.externalTexture, membership);
+            }
+            if ('sampler' in entry) {
+                item = new TgpuLaidOutSamplerImpl(entry.sampler === 'comparison' ? wgslComparisonSampler() : wgslSampler(), membership);
+            }
+            invariant(item !== undefined, 'Internal error, expected item to be defined');
+            Object.defineProperty(this.$, key, {
+                get: () => {
+                    return item.$;
+                },
+            });
+            this[$internal].push(item);
+            idx++;
+        }
+    }
+    toString() {
+        return `bindGroupLayout:${getName(this) ?? '<unnamed>'}`;
+    }
+    get index() {
+        return this[$soul].index;
+    }
+    $name(label) {
+        setName(this, label);
+        return this;
+    }
+    $idx(index) {
+        this[$soul].index = index;
+        return this;
+    }
+    unwrap(unwrapper) {
+        const unwrapped = unwrapper.device.createBindGroupLayout({
+            label: getName(this) ?? '<unnamed>',
+            entries: Object.values(this.entries)
+                .map((entry, idx) => {
+                if (entry === null) {
+                    return null;
+                }
+                let visibility = entry.visibility;
+                const binding = {
+                    binding: idx,
+                    visibility: 0,
+                };
+                if ('uniform' in entry) {
+                    visibility = visibility ?? DEFAULT_READONLY_VISIBILITY;
+                    binding.buffer = {
+                        type: 'uniform',
+                    };
+                }
+                else if ('storage' in entry) {
+                    visibility =
+                        visibility ??
+                            (entry.access === 'mutable'
+                                ? DEFAULT_MUTABLE_VISIBILITY
+                                : DEFAULT_READONLY_VISIBILITY);
+                    binding.buffer = {
+                        type: entry.access === 'mutable' ? 'storage' : 'read-only-storage',
+                    };
+                }
+                else if ('sampler' in entry) {
+                    visibility = visibility ?? DEFAULT_READONLY_VISIBILITY;
+                    binding.sampler = {
+                        type: entry.sampler,
+                    };
+                }
+                else if ('texture' in entry) {
+                    visibility = visibility ?? DEFAULT_READONLY_VISIBILITY;
+                    const { multisampled, dimension, bindingSampleType } = entry.texture;
+                    binding.texture = {
+                        sampleType: entry.sampleType ?? bindingSampleType[0],
+                        viewDimension: dimension,
+                        multisampled,
+                    };
+                }
+                else if ('storageTexture' in entry) {
+                    visibility = visibility ?? DEFAULT_MUTABLE_VISIBILITY;
+                    const { dimension, access, format } = entry.storageTexture;
+                    binding.storageTexture = {
+                        access,
+                        format,
+                        viewDimension: dimension,
+                    };
+                }
+                else if ('externalTexture' in entry) {
+                    visibility = visibility ?? DEFAULT_READONLY_VISIBILITY;
+                    binding.externalTexture = {};
+                }
+                if (visibility?.includes('compute')) {
+                    binding.visibility |= GPUShaderStage.COMPUTE;
+                }
+                if (visibility?.includes('vertex')) {
+                    binding.visibility |= GPUShaderStage.VERTEX;
+                }
+                if (visibility?.includes('fragment')) {
+                    binding.visibility |= GPUShaderStage.FRAGMENT;
+                }
+                return binding;
+            })
+                .filter((v) => v !== null),
+        });
+        return unwrapped;
+    }
+}
+export class TgpuBindGroupImpl {
+    [$internal];
+    [$soul];
+    resourceType = 'bind-group';
+    #entries;
+    constructor(root, layout, entries, raw) {
+        this.#entries = entries;
+        this[$soul] = {
+            type: 'bind-group',
+            // Undefined only in rootless `tgpu.resolve()`, where the group is never unwrapped
+            device: root?.device,
+            layout,
+            raw,
+            label: undefined,
+        };
+        this[$internal] = {
+            materialize: () => {
+                const soul = this[$soul];
+                if (!soul.raw) {
+                    invariant(root, 'Cannot unwrap a bind group created outside of a root.');
+                    soul.raw = root.unwrap(this);
+                }
+                return soul.raw;
+            },
+        };
+        if (!raw) {
+            // Checking if all entries are present.
+            for (const key of Object.keys(layout.entries)) {
+                if (layout.entries[key] !== null && !(key in entries)) {
+                    throw new MissingBindingError(getName(layout), key);
+                }
+            }
+        }
+    }
+    get layout() {
+        return this[$soul].layout;
+    }
+    get entries() {
+        return this.#entries;
+    }
+    unwrap(unwrapper) {
+        const raw = this[$soul].raw;
+        if (raw) {
+            return raw;
+        }
+        const unwrapped = unwrapper.device.createBindGroup({
+            label: getName(this.layout) ?? '<unnamed>',
+            layout: unwrapper.unwrap(this.layout),
+            entries: Object.entries(this.layout.entries)
+                .map(([key, entry], idx) => {
+                if (entry === null) {
+                    return null;
+                }
+                const value = this.entries[key];
+                if (value === undefined) {
+                    throw new Error(`'${key}' is a resource required to populate bind group layout '${getName(this.layout) ?? '<unnamed>'}'.`);
+                }
+                if ('uniform' in entry) {
+                    let resource;
+                    if (isBuffer(value)) {
+                        if (!isUsableAsUniform(value)) {
+                            throw new NotUniformError(value);
+                        }
+                        resource = { buffer: unwrapper.unwrap(value) };
+                    }
+                    else if (isUniformBinding(value)) {
+                        resource = { buffer: unwrapper.unwrap(value) };
+                    }
+                    else {
+                        resource = { buffer: value };
+                    }
+                    return {
+                        binding: idx,
+                        resource,
+                    };
+                }
+                if ('storage' in entry) {
+                    let resource;
+                    if (isBuffer(value)) {
+                        if (!isUsableAsStorage(value)) {
+                            throw new NotStorageError(value);
+                        }
+                        resource = { buffer: unwrapper.unwrap(value) };
+                    }
+                    else if (isMutableBinding(value) || isReadonlyBinding(value)) {
+                        // Types should guarantee that access is mutable if and only if the binding is mutable.
+                        invariant((entry.access === 'mutable') === (value.resourceType === 'mutable'), 'Invalid buffer access mode.');
+                        resource = { buffer: unwrapper.unwrap(value) };
+                    }
+                    else {
+                        resource = { buffer: value };
+                    }
+                    return {
+                        binding: idx,
+                        resource,
+                    };
+                }
+                if ('texture' in entry) {
+                    let resource;
+                    if (isTexture(value)) {
+                        if (!isUsableAsSampled(value)) {
+                            throw new NotSampledError(value);
+                        }
+                        resource = unwrapper.unwrap(value.createView(entry.texture));
+                    }
+                    else if (isTextureView(value)) {
+                        resource = unwrapper.unwrap(value);
+                    }
+                    else {
+                        resource = value;
+                    }
+                    return {
+                        binding: idx,
+                        resource,
+                    };
+                }
+                if ('storageTexture' in entry) {
+                    let resource;
+                    if (isTexture(value)) {
+                        if (!isUsableAsStorage(value)) {
+                            throw new NotStorageError(value);
+                        }
+                        resource = unwrapper.unwrap(value.createView(entry.storageTexture));
+                    }
+                    else if (isTextureView(value)) {
+                        resource = unwrapper.unwrap(value);
+                    }
+                    else {
+                        resource = value;
+                    }
+                    return {
+                        binding: idx,
+                        resource,
+                    };
+                }
+                if ('sampler' in entry) {
+                    if (isComparisonSampler(value) || isSampler(value)) {
+                        return {
+                            binding: idx,
+                            resource: unwrapper.unwrap(value),
+                        };
+                    }
+                    return {
+                        binding: idx,
+                        resource: value,
+                    };
+                }
+                if ('externalTexture' in entry) {
+                    return {
+                        binding: idx,
+                        resource: value,
+                    };
+                }
+                throw new Error(`Malformed bind group entry: ${safeStringify(value)}`);
+            })
+                .filter((v) => v !== null),
+        });
+        return unwrapped;
+    }
+}