typegpu 0.11.9 → 0.12.1

package/core/pipeline/computePipeline.js

@@ -1,229 +1,295 @@
-import { $getNameForward, $internal, $resolve } from "../../shared/symbols.js";
-import { Void } from "../../data/wgslTypes.js";
-import { PERF, getName, setName } from "../../shared/meta.js";
 import { snip } from "../../data/snippet.js";
-import { isGPUBuffer } from "../../types.js";
-import { isBindGroup } from "../../tgpuBindGroupLayout.js";
+import { Void } from "../../data/wgslTypes.js";
 import { resolve } from "../../resolutionCtx.js";
-import { isGPUCommandEncoder, isGPUComputePassEncoder } from "./typeGuards.js";
+import { getName, PERF, setName } from "../../shared/meta.js";
+import { $getNameForward, $internal, $resolve, $soul } from "../../shared/symbols.js";
+import { isBindGroup, isBindGroupLayout, } from "../../tgpuBindGroupLayout.js";
+import { INTERNAL_adoptCommandEncoder, INTERNAL_createCommandEncoder, } from "../commandEncoder/commandEncoder.js";
+import { INTERNAL_adoptComputePass } from "../commandEncoder/computePass.js";
+import { emitComputeDispatch, finalizeOwnEncoder } from "./drawState.js";
+import { isGPUCommandEncoder, isGPUComputePassEncoder, isTgpuCommandEncoder, isTgpuComputePass, } from "./typeGuards.js";
+import { isGPUBuffer } from "../../types.js";
+import { wgslEnableExtensions, wgslEnableExtensionToFeatureName } from "../../wgslExtensions.js";
 import { namespace } from "../resolve/namespace.js";
-import { applyBindGroups } from "./applyPipelineState.js";
-import { logDataFromGPU } from "../../tgsl/consoleLog/deserializers.js";
-import { wgslEnableExtensionToFeatureName, wgslEnableExtensions } from "../../wgslExtensions.js";
-import { resolveIndirectOffset } from "./pipelineUtils.js";
-import { createWithPerformanceCallback, createWithTimestampWrites, setupTimestampWrites, triggerPerformanceCallback } from "./timeable.js";
-
-//#region src/core/pipeline/computePipeline.ts
-function INTERNAL_createComputePipeline(branch, slotBindings, descriptor) {
-	return new TgpuComputePipelineImpl(new ComputePipelineCore(branch, slotBindings, descriptor), {});
+import { warnIfOverflow } from "./webgpuLimitations.js";
+import { collectBindGroupPairs, DISPATCH_INDIRECT_SIZE, resolveIndirectOffset, restoreTimestampPriors, } from "./pipelineUtils.js";
+import { invariant } from "../../errors.js";
+import { createWithPerformanceCallback, createWithTimestampWrites, } from "./timeable.js";
+import { nonTransferablePriorsOf } from "./priors.js";
+import { NullPerformanceTracker, PerformanceTrackerImpl, } from "./performanceTracker.js";
+import { logger } from "../../tgpuLogger.js";
+export function INTERNAL_createComputePipeline(root, slotBindings, descriptor) {
+    return new TgpuComputePipelineImpl(new ComputePipelineCore(root, slotBindings, descriptor), {});
+}
+export function INTERNAL_restoreComputePipeline(soul, ctx) {
+    invariant(soul.raw, 'A compute pipeline soul is only complete once materialized.');
+    const root = ctx.getRoot(soul.device);
+    const core = ComputePipelineCore.precompiled(root, {
+        pipeline: soul.raw,
+        usedBindGroupLayouts: soul.usedBindGroupLayouts ?? [],
+        // The catchall group is already one of `bindGroups`, keyed by the layout it was resolved with
+        catchall: undefined,
+        logResources: undefined,
+    });
+    const pipeline = new TgpuComputePipelineImpl(core, {
+        bindGroupLayoutMap: new Map(soul.bindGroups),
+    });
+    return restoreTimestampPriors(pipeline, soul);
+}
+class TgpuComputePipelineImpl {
+    [$internal];
+    [$soul];
+    resourceType = 'compute-pipeline';
+    [$getNameForward];
+    constructor(core, priors) {
+        this[$soul] = {
+            type: 'compute-pipeline',
+            device: core.root.device,
+            raw: undefined,
+            label: undefined,
+        };
+        this[$internal] = {
+            core,
+            priors,
+            root: core.root,
+            materialize: () => {
+                const soul = this[$soul];
+                if (!soul.raw) {
+                    const memo = core.unwrap();
+                    soul.raw = memo.pipeline;
+                    soul.usedBindGroupLayouts = memo.usedBindGroupLayouts;
+                    soul.bindGroups = collectBindGroupPairs(memo.usedBindGroupLayouts, memo.catchall, priors.bindGroupLayoutMap);
+                    soul.timestampWrites = priors.timestampWrites;
+                    soul.performanceCallback = priors.performanceCallback;
+                    soul.nonTransferablePriors = nonTransferablePriorsOf(priors);
+                }
+                return soul.raw;
+            },
+        };
+        this[$getNameForward] = core;
+    }
+    [$resolve](ctx) {
+        return ctx.resolve(this[$internal].core);
+    }
+    toString() {
+        return `computePipeline:${getName(this) ?? '<unnamed>'}`;
+    }
+    #withPriors(patch) {
+        const { core, priors } = this[$internal];
+        return new TgpuComputePipelineImpl(core, { ...priors, ...patch });
+    }
+    with(first, bindGroup) {
+        const internals = this[$internal];
+        if (isTgpuComputePass(first)) {
+            return this.#withPriors({ pass: first, encoder: undefined });
+        }
+        if (isTgpuCommandEncoder(first)) {
+            return this.#withPriors({ pass: undefined, encoder: first });
+        }
+        if (isGPUComputePassEncoder(first)) {
+            return this.#withPriors({
+                pass: INTERNAL_adoptComputePass(internals.root, first),
+                encoder: undefined,
+            });
+        }
+        if (isGPUCommandEncoder(first)) {
+            return this.#withPriors({
+                pass: undefined,
+                encoder: INTERNAL_adoptCommandEncoder(internals.root, first),
+            });
+        }
+        if (isBindGroup(first) || isBindGroupLayout(first)) {
+            const [layout, group] = isBindGroup(first)
+                ? [first.layout, first]
+                : [first, bindGroup];
+            return this.#withPriors({
+                bindGroupLayoutMap: new Map([
+                    ...(internals.priors.bindGroupLayoutMap ?? []),
+                    [layout, group],
+                ]),
+            });
+        }
+        throw new Error('Unsupported value passed into .with()');
+    }
+    withPerformanceCallback(callback) {
+        const internals = this[$internal];
+        if (internals.priors.timestampWrites) {
+            return this.#withPriors({ performanceCallback: callback });
+        }
+        const querySet = internals.core.performanceCallbackQuerySet;
+        if (!querySet) {
+            logger.warn('webgpu-feature-missing', 'Performance callback cannot be used because the timestamp-query feature is not enabled on the root.');
+            return this;
+        }
+        return this.#withPriors(createWithPerformanceCallback(internals.priors, callback, querySet));
+    }
+    withTimestampWrites(options) {
+        const internals = this[$internal];
+        return this.#withPriors(createWithTimestampWrites(internals.priors, options, internals.root));
+    }
+    dispatchWorkgroups(x, y, z) {
+        this.#execute((pass) => pass.dispatchWorkgroups(x, y, z));
+    }
+    dispatchWorkgroupsIndirect(indirectBuffer, start) {
+        const rawBuffer = isGPUBuffer(indirectBuffer) ? indirectBuffer : indirectBuffer.buffer;
+        const offset = resolveIndirectOffset(indirectBuffer, start, DISPATCH_INDIRECT_SIZE, 'dispatchWorkgroupsIndirect');
+        this.#execute((pass) => pass.dispatchWorkgroupsIndirect(rawBuffer, offset));
+    }
+    initAsync() {
+        return this[$internal].core.initAsync();
+    }
+    initSync() {
+        this[$internal].core.initSync();
+    }
+    #execute(dispatch) {
+        const { core, priors, root } = this[$internal];
+        if (priors.pass) {
+            emitComputeDispatch(root, priors.pass[$internal], this, dispatch);
+            return;
+        }
+        const encoder = priors.encoder ?? INTERNAL_createCommandEncoder(root);
+        const pass = encoder.beginComputePass({
+            label: getName(core) ?? '<unnamed>',
+            timestampWrites: priors.timestampWrites,
+        });
+        emitComputeDispatch(root, pass[$internal], this, dispatch, /* ownsPass */ true);
+        pass.end();
+        finalizeOwnEncoder(encoder, core, core.unwrap().logResources, priors);
+    }
+    $name(label) {
+        setName(this, label);
+        return this;
+    }
+}
+class ComputePipelineCore {
+    [$internal] = true;
+    root;
+    #performanceTracker;
+    #initAsyncPromise;
+    #memo;
+    #slotBindings;
+    #descriptor;
+    #performanceCallbackQuerySet;
+    constructor(root, slotBindings, descriptor) {
+        this.root = root;
+        this.#slotBindings = slotBindings;
+        this.#descriptor = descriptor;
+        this.#performanceTracker = PERF?.enabled
+            ? new PerformanceTrackerImpl()
+            : new NullPerformanceTracker();
+    }
+    static precompiled(root, memo) {
+        const core = new ComputePipelineCore(root, [], undefined);
+        core.#memo = memo;
+        return core;
+    }
+    [$resolve](ctx) {
+        const descriptor = this.#descriptor;
+        if (!descriptor) {
+            // Precompiled pipelines have nothing to contribute to the shader
+            return snip('', Void, /* origin */ 'runtime');
+        }
+        return ctx.withSlots(this.#slotBindings, () => {
+            ctx.resolve(descriptor.compute);
+            return snip('', Void, /* origin */ 'runtime');
+        });
+    }
+    toString() {
+        return 'computePipelineCore';
+    }
+    get performanceCallbackQuerySet() {
+        if (!this.root.enabledFeatures.has('timestamp-query')) {
+            return undefined;
+        }
+        return (this.#performanceCallbackQuerySet ??= this.root.createQuerySet('timestamp', 2));
+    }
+    /**
+     * @privateRemarks
+     * This function cannot be a regular async function
+     * because when called multiple times before the promise finishes,
+     * we want it to return the same promise each time.
+     */
+    initAsync() {
+        if (this.#memo !== undefined) {
+            // the pipeline was already resolved & compiled
+            return Promise.resolve();
+        }
+        if (this.#initAsyncPromise === undefined) {
+            // the pipeline did not start resolution & compilation
+            const device = this.root.device;
+            const { resolutionResult, module } = this.resolveAndCreateShaderModule();
+            const { usedBindGroupLayouts, catchall, logResources } = resolutionResult;
+            this.#initAsyncPromise = device
+                .createComputePipelineAsync({
+                label: getName(this) ?? '<unnamed>',
+                layout: device.createPipelineLayout({
+                    label: `${getName(this) ?? '<unnamed>'} - Pipeline Layout`,
+                    bindGroupLayouts: usedBindGroupLayouts.map((l) => this.root.unwrap(l)),
+                }),
+                compute: { module },
+            })
+                .then((pipeline) => {
+                this.#memo = { pipeline, usedBindGroupLayouts, catchall, logResources };
+                this.#performanceTracker.measureCompile(device);
+            })
+                .finally(() => {
+                this.#initAsyncPromise = undefined;
+            });
+        }
+        return this.#initAsyncPromise;
+    }
+    initSync() {
+        if (this.#memo !== undefined) {
+            return;
+        }
+        if (this.#initAsyncPromise !== undefined) {
+            throw new Error("'pipeline.initAsync()' was called and is not yet resolved.");
+        }
+        const device = this.root.device;
+        const { resolutionResult, module } = this.resolveAndCreateShaderModule();
+        const { usedBindGroupLayouts, catchall, logResources } = resolutionResult;
+        this.#memo = {
+            pipeline: device.createComputePipeline({
+                label: getName(this) ?? '<unnamed>',
+                layout: device.createPipelineLayout({
+                    label: `${getName(this) ?? '<unnamed>'} - Pipeline Layout`,
+                    bindGroupLayouts: usedBindGroupLayouts.map((l) => this.root.unwrap(l)),
+                }),
+                compute: { module },
+            }),
+            usedBindGroupLayouts,
+            catchall,
+            logResources,
+        };
+        this.#performanceTracker.measureCompile(device);
+    }
+    unwrap() {
+        this.initSync();
+        return this.#memo;
+    }
+    resolveAndCreateShaderModule() {
+        const device = this.root.device;
+        const enableExtensions = wgslEnableExtensions.filter((extension) => this.root.enabledFeatures.has(wgslEnableExtensionToFeatureName[extension]));
+        // Resolving code
+        const ns = namespace({ names: this.root.nameRegistrySetting });
+        const resolutionResult = this.#performanceTracker.measureResolve(() => resolve(this, {
+            namespace: ns,
+            minify: this.root.minify,
+            enableExtensions,
+            shaderGenerator: this.root.shaderGeneratorClass
+                ? new this.root.shaderGeneratorClass()
+                : undefined,
+            root: this.root,
+        }));
+        const { code, usedBindGroupLayouts, catchall } = resolutionResult;
+        if (catchall !== undefined) {
+            usedBindGroupLayouts[catchall[0]]?.$name(`${getName(this) ?? '<unnamed>'} - Automatic Bind Group & Layout`);
+        }
+        warnIfOverflow(usedBindGroupLayouts, device.limits);
+        const module = device.createShaderModule({
+            label: `${getName(this) ?? '<unnamed>'} - Shader`,
+            code,
+        });
+        return { resolutionResult, module };
+    }
 }
-const _lastAppliedCompute = /* @__PURE__ */ new WeakMap();
-var TgpuComputePipelineImpl = class TgpuComputePipelineImpl {
-	[$internal];
-	resourceType = "compute-pipeline";
-	[$getNameForward];
-	#core;
-	#priors;
-	constructor(core, priors) {
-		this.#core = core;
-		this.#priors = priors;
-		this[$internal] = {
-			get rawPipeline() {
-				return core.unwrap().pipeline;
-			},
-			get priors() {
-				return priors;
-			},
-			get root() {
-				return core.root;
-			}
-		};
-		this[$getNameForward] = core;
-	}
-	[$resolve](ctx) {
-		return ctx.resolve(this.#core);
-	}
-	toString() {
-		return `computePipeline:${getName(this) ?? "<unnamed>"}`;
-	}
-	get rawPipeline() {
-		return this.#core.unwrap().pipeline;
-	}
-	with(first, bindGroup) {
-		if (isGPUComputePassEncoder(first)) return new TgpuComputePipelineImpl(this.#core, {
-			...this.#priors,
-			externalPass: first,
-			externalEncoder: void 0
-		});
-		if (isGPUCommandEncoder(first)) return new TgpuComputePipelineImpl(this.#core, {
-			...this.#priors,
-			externalEncoder: first,
-			externalPass: void 0
-		});
-		if (isBindGroup(first)) return new TgpuComputePipelineImpl(this.#core, {
-			...this.#priors,
-			bindGroupLayoutMap: new Map([...this.#priors.bindGroupLayoutMap ?? [], [first.layout, first]])
-		});
-		return new TgpuComputePipelineImpl(this.#core, {
-			...this.#priors,
-			bindGroupLayoutMap: new Map([...this.#priors.bindGroupLayoutMap ?? [], [first, bindGroup]])
-		});
-	}
-	withPerformanceCallback(callback) {
-		if (this.#priors.timestampWrites) return new TgpuComputePipelineImpl(this.#core, {
-			...this.#priors,
-			performanceCallback: callback
-		});
-		const querySet = this.#core.performanceCallbackQuerySet;
-		if (!querySet) {
-			console.warn("Performance callback cannot be used because the timestamp-query feature is not enabled on the root.");
-			return this;
-		}
-		const newPriors = createWithPerformanceCallback(this.#priors, callback, querySet);
-		return new TgpuComputePipelineImpl(this.#core, newPriors);
-	}
-	withTimestampWrites(options) {
-		const newPriors = createWithTimestampWrites(this.#priors, options, this.#core.root);
-		return new TgpuComputePipelineImpl(this.#core, newPriors);
-	}
-	dispatchWorkgroups(x, y, z) {
-		this._executeComputePass((pass) => pass.dispatchWorkgroups(x, y, z));
-	}
-	dispatchWorkgroupsIndirect(indirectBuffer, start) {
-		const DISPATCH_SIZE = 12;
-		const rawBuffer = isGPUBuffer(indirectBuffer) ? indirectBuffer : indirectBuffer.buffer;
-		const offset = resolveIndirectOffset(indirectBuffer, start, DISPATCH_SIZE, "dispatchWorkgroupsIndirect");
-		this._executeComputePass((pass) => pass.dispatchWorkgroupsIndirect(rawBuffer, offset));
-	}
-	_applyComputeState(pass) {
-		const memo = this.#core.unwrap();
-		const { root } = this.#core;
-		pass.setPipeline(memo.pipeline);
-		applyBindGroups(pass, root, memo.usedBindGroupLayouts, memo.catchall, (layout) => this.#priors.bindGroupLayoutMap?.get(layout));
-	}
-	_executeComputePass(dispatch) {
-		const { root } = this.#core;
-		if (this.#priors.externalPass) {
-			if (_lastAppliedCompute.get(this.#priors.externalPass) !== this) {
-				this._applyComputeState(this.#priors.externalPass);
-				_lastAppliedCompute.set(this.#priors.externalPass, this);
-			}
-			dispatch(this.#priors.externalPass);
-			return;
-		}
-		if (this.#priors.externalEncoder) {
-			const passDescriptor$1 = {
-				label: getName(this.#core) ?? "<unnamed>",
-				...setupTimestampWrites(this.#priors, root)
-			};
-			const pass$1 = this.#priors.externalEncoder.beginComputePass(passDescriptor$1);
-			this._applyComputeState(pass$1);
-			dispatch(pass$1);
-			pass$1.end();
-			return;
-		}
-		const memo = this.#core.unwrap();
-		const passDescriptor = {
-			label: getName(this.#core) ?? "<unnamed>",
-			...setupTimestampWrites(this.#priors, root)
-		};
-		const commandEncoder = root.device.createCommandEncoder();
-		const pass = commandEncoder.beginComputePass(passDescriptor);
-		this._applyComputeState(pass);
-		dispatch(pass);
-		pass.end();
-		root.device.queue.submit([commandEncoder.finish()]);
-		if (memo.logResources) logDataFromGPU(memo.logResources);
-		if (this.#priors.performanceCallback) triggerPerformanceCallback({
-			root,
-			priors: this.#priors
-		});
-	}
-	$name(label) {
-		setName(this, label);
-		return this;
-	}
-};
-var ComputePipelineCore = class {
-	[$internal] = true;
-	root;
-	_memo;
-	#slotBindings;
-	#descriptor;
-	#performanceCallbackQuerySet;
-	constructor(root, slotBindings, descriptor) {
-		this.root = root;
-		this.#slotBindings = slotBindings;
-		this.#descriptor = descriptor;
-	}
-	[$resolve](ctx) {
-		return ctx.withSlots(this.#slotBindings, () => {
-			ctx.resolve(this.#descriptor.compute);
-			return snip("", Void, "runtime");
-		});
-	}
-	toString() {
-		return "computePipelineCore";
-	}
-	get performanceCallbackQuerySet() {
-		if (!this.root.enabledFeatures.has("timestamp-query")) return;
-		return this.#performanceCallbackQuerySet ??= this.root.createQuerySet("timestamp", 2);
-	}
-	unwrap() {
-		if (this._memo === void 0) {
-			const device = this.root.device;
-			const enableExtensions = wgslEnableExtensions.filter((extension) => this.root.enabledFeatures.has(wgslEnableExtensionToFeatureName[extension]));
-			let resolutionResult;
-			let resolveMeasure;
-			const ns = namespace({ names: this.root.nameRegistrySetting });
-			if (PERF?.enabled) {
-				const resolveStart = performance.mark("typegpu:resolution:start");
-				resolutionResult = resolve(this, {
-					namespace: ns,
-					enableExtensions,
-					shaderGenerator: this.root.shaderGenerator,
-					root: this.root
-				});
-				resolveMeasure = performance.measure("typegpu:resolution", { start: resolveStart.name });
-			} else resolutionResult = resolve(this, {
-				namespace: ns,
-				enableExtensions,
-				shaderGenerator: this.root.shaderGenerator,
-				root: this.root
-			});
-			const { code, usedBindGroupLayouts, catchall, logResources } = resolutionResult;
-			if (catchall !== void 0) usedBindGroupLayouts[catchall[0]]?.$name(`${getName(this) ?? "<unnamed>"} - Automatic Bind Group & Layout`);
-			const module = device.createShaderModule({
-				label: `${getName(this) ?? "<unnamed>"} - Shader`,
-				code
-			});
-			this._memo = {
-				pipeline: device.createComputePipeline({
-					label: getName(this) ?? "<unnamed>",
-					layout: device.createPipelineLayout({
-						label: `${getName(this) ?? "<unnamed>"} - Pipeline Layout`,
-						bindGroupLayouts: usedBindGroupLayouts.map((l) => this.root.unwrap(l))
-					}),
-					compute: { module }
-				}),
-				usedBindGroupLayouts,
-				catchall,
-				logResources
-			};
-			if (PERF?.enabled) (async () => {
-				const start = performance.mark("typegpu:compile-start");
-				await device.queue.onSubmittedWorkDone();
-				const compileMeasure = performance.measure("typegpu:compiled", { start: start.name });
-				PERF?.record("resolution", {
-					resolveDuration: resolveMeasure?.duration,
-					compileDuration: compileMeasure.duration,
-					wgslSize: code.length
-				});
-			})();
-		}
-		return this._memo;
-	}
-};
-
-//#endregion
-export { INTERNAL_createComputePipeline };

package/core/pipeline/connectAttachmentToShader.d.ts

@@ -0,0 +1,4 @@
+import { type BaseData } from '../../data/wgslTypes.ts';
+import type { ColorAttachment } from '../commandEncoder/attachments.ts';
+import type { AnyFragmentColorAttachment } from './renderPipeline.ts';
+export declare function connectAttachmentToShader(fragmentOut: BaseData, attachment: AnyFragmentColorAttachment): ColorAttachment[];

package/core/pipeline/connectAttachmentToShader.js

@@ -1,26 +1,29 @@
-import { isWgslStruct } from "../../data/wgslTypes.js";
 import { isBuiltin } from "../../data/attributes.js";
-
-//#region src/core/pipeline/connectAttachmentToShader.ts
+import { isVoid, isWgslStruct } from "../../data/wgslTypes.js";
 function isColorAttachment(value) {
-	return !!value?.view;
+    return !!value?.view;
 }
-function connectAttachmentToShader(fragmentOut, attachment) {
-	if (isBuiltin(fragmentOut)) return [];
-	if (isWgslStruct(fragmentOut)) {
-		const result = [];
-		for (const key of Object.keys(fragmentOut.propTypes)) {
-			const outputValue = fragmentOut.propTypes[key];
-			if (isBuiltin(outputValue)) continue;
-			const matching = attachment[key];
-			if (!matching) throw new Error(`A color attachment by the name of '${key}' was not provided to the shader.`);
-			result.push(matching);
-		}
-		return result;
-	}
-	if (!isColorAttachment(attachment)) throw new Error("Expected a single color attachment, not a record.");
-	return [attachment];
+export function connectAttachmentToShader(fragmentOut, attachment) {
+    if (isVoid(fragmentOut) || isBuiltin(fragmentOut)) {
+        return [];
+    }
+    if (isWgslStruct(fragmentOut)) {
+        const result = [];
+        for (const key of Object.keys(fragmentOut.propTypes)) {
+            const outputValue = fragmentOut.propTypes[key];
+            if (isBuiltin(outputValue)) {
+                continue;
+            }
+            const matching = attachment[key];
+            if (!matching) {
+                throw new Error(`A color attachment by the name of '${key}' was not provided to the shader.`);
+            }
+            result.push(matching);
+        }
+        return result;
+    }
+    if (!isColorAttachment(attachment)) {
+        throw new Error('Expected a single color attachment, not a record.');
+    }
+    return [attachment];
 }
-
-//#endregion
-export { connectAttachmentToShader };

package/core/pipeline/connectTargetsToShader.d.ts

@@ -0,0 +1,3 @@
+import { type BaseData } from '../../data/wgslTypes.ts';
+import type { AnyFragmentTargets } from './renderPipeline.ts';
+export declare function connectTargetsToShader(fragmentOut: BaseData, targets: AnyFragmentTargets): (GPUColorTargetState | null)[];

package/core/pipeline/connectTargetsToShader.js

@@ -1,29 +1,31 @@
-import { isVoid, isWgslStruct } from "../../data/wgslTypes.js";
 import { isBuiltin } from "../../data/attributes.js";
-
-//#region src/core/pipeline/connectTargetsToShader.ts
-function connectTargetsToShader(fragmentOut, targets) {
-	let presentationFormat;
-	if (isVoid(fragmentOut) || isBuiltin(fragmentOut)) return [null];
-	if (isWgslStruct(fragmentOut)) {
-		const result = [];
-		for (const key of Object.keys(fragmentOut.propTypes)) {
-			const outputValue = fragmentOut.propTypes[key];
-			if (isBuiltin(outputValue)) continue;
-			const matchingTarget = targets[key];
-			result.push({
-				...matchingTarget,
-				format: matchingTarget?.format ?? (presentationFormat ??= navigator.gpu.getPreferredCanvasFormat())
-			});
-		}
-		return result;
-	}
-	const singleTarget = targets;
-	return [{
-		...singleTarget,
-		format: singleTarget?.format ?? (presentationFormat ??= navigator.gpu.getPreferredCanvasFormat())
-	}];
+import { isVoid, isWgslStruct } from "../../data/wgslTypes.js";
+export function connectTargetsToShader(fragmentOut, targets) {
+    let presentationFormat;
+    if (isVoid(fragmentOut) || isBuiltin(fragmentOut)) {
+        return [null];
+    }
+    if (isWgslStruct(fragmentOut)) {
+        const result = [];
+        for (const key of Object.keys(fragmentOut.propTypes)) {
+            const outputValue = fragmentOut.propTypes[key];
+            if (isBuiltin(outputValue)) {
+                continue;
+            }
+            const matchingTarget = targets[key];
+            result.push({
+                ...matchingTarget,
+                format: matchingTarget?.format ??
+                    (presentationFormat ??= navigator.gpu.getPreferredCanvasFormat()),
+            });
+        }
+        return result;
+    }
+    const singleTarget = targets;
+    return [
+        {
+            ...singleTarget,
+            format: singleTarget?.format ?? (presentationFormat ??= navigator.gpu.getPreferredCanvasFormat()),
+        },
+    ];
 }
-
-//#endregion
-export { connectTargetsToShader };