typegpu 0.11.8 → 0.12.0

package/core/resolve/tgpuResolve.js

@@ -1,68 +1,119 @@
-import { $internal, $resolve } from "../../shared/symbols.js";
-import { Void } from "../../data/wgslTypes.js";
 import { snip } from "../../data/snippet.js";
-import { mergeExternals, replaceExternalsInWgsl } from "./externals.js";
+import { Void } from "../../data/wgslTypes.js";
+import { getName } from "../../internal.js";
+import { resolve as resolveImpl } from "../../resolutionCtx.js";
+import { $internal, $resolve, $soul } from "../../shared/symbols.js";
 import { isBindGroupLayout } from "../../tgpuBindGroupLayout.js";
-import { resolve } from "../../resolutionCtx.js";
+import { logger } from "../../tgpuLogger.js";
+import { isBuffer } from "../../types.js";
+import { isBufferBinding } from "../buffer/bufferBinding.js";
 import { isPipeline } from "../pipeline/typeGuards.js";
+import { isComparisonSampler, isSampler } from "../sampler/sampler.js";
+import { isTexture, isTextureView } from "../texture/texture.js";
+import { replaceExternalsInWgsl } from "./externals.js";
 import { namespace } from "./namespace.js";
-
-//#region src/core/resolve/tgpuResolve.ts
-function resolveWithContext(arg0, options) {
-	if (Array.isArray(arg0)) return resolveFromArray(arg0, options);
-	return resolveFromTemplate(arg0);
+export function resolveWithContext(arg0, options) {
+    if (Array.isArray(arg0)) {
+        return resolveFromArray(arg0, options);
+    }
+    return resolveFromTemplate(arg0);
 }
-function resolve$1(arg, options) {
-	if (Array.isArray(arg)) return resolveWithContext(arg, options).code;
-	return resolveWithContext(arg).code;
+export function resolve(arg, options) {
+    if (Array.isArray(arg)) {
+        return resolveWithContext(arg, options).code;
+    }
+    return resolveWithContext(arg).code;
 }
 function resolveFromTemplate(options) {
-	const { template, externals, unstable_shaderGenerator: shaderGenerator, names = "strict", config, enableExtensions } = options;
-	if (!template) console.warn("Calling resolve with an empty template is deprecated and will soon return an empty string. Consider using the 'tgpu.resolve(resolvableArray, options)' API instead.");
-	const dependencies = {};
-	mergeExternals(dependencies, externals ?? {});
-	return resolve({
-		[$internal]: true,
-		[$resolve](ctx) {
-			return snip(replaceExternalsInWgsl(ctx, dependencies, template ?? ""), Void, "runtime");
-		},
-		toString: () => "<root>"
-	}, {
-		namespace: typeof names === "string" ? namespace({ names }) : names,
-		enableExtensions,
-		shaderGenerator,
-		config,
-		root: tryFindRoot(Object.values(externals))
-	});
+    const { template, externals, unstable_shaderGenerator: shaderGenerator, names = 'strict', unstable_minify, config, enableExtensions, } = options;
+    if (!template) {
+        logger.warn('deprecated', "Calling resolve with an empty template is deprecated and will soon return an empty string. Consider using the 'tgpu.resolve(resolvableArray, options)' API instead.");
+    }
+    const resolutionObj = {
+        [$internal]: true,
+        [$resolve](ctx) {
+            return snip(replaceExternalsInWgsl(ctx, externals, template ?? ''), Void, 
+            /* origin */ 'runtime');
+        },
+        toString: () => '<root>',
+    };
+    const maybeRoot = tryFindRoot(Object.values(externals));
+    return resolveImpl(resolutionObj, {
+        namespace: typeof names === 'string' ? namespace({ names }) : names,
+        minify: unstable_minify ?? maybeRoot?.minify ?? false,
+        enableExtensions,
+        shaderGenerator,
+        config,
+        root: maybeRoot,
+    });
 }
 function resolveFromArray(items, options) {
-	const { unstable_shaderGenerator: shaderGenerator, names = "strict", config, enableExtensions } = options ?? {};
-	return resolve({
-		[$internal]: true,
-		[$resolve](ctx) {
-			for (const item of items) if (isBindGroupLayout(item)) for (const binding of Object.values(item[$internal].bound)) ctx.resolve(binding);
-			else ctx.resolve(item);
-			return snip("", Void, "runtime");
-		},
-		toString: () => "<root>"
-	}, {
-		namespace: typeof names === "string" ? namespace({ names }) : names,
-		enableExtensions,
-		shaderGenerator,
-		config,
-		root: tryFindRoot(items)
-	});
+    const { unstable_shaderGenerator: shaderGenerator, names = 'strict', unstable_minify, config, enableExtensions, } = options ?? {};
+    const resolutionObj = {
+        [$internal]: true,
+        [$resolve](ctx) {
+            for (const item of items) {
+                // Support for: tgpu.resolve([layout])
+                if (isBindGroupLayout(item)) {
+                    for (const binding of Object.values(item[$internal])) {
+                        ctx.resolve(binding);
+                    }
+                }
+                else {
+                    ctx.resolve(item);
+                }
+            }
+            return snip('', Void, 'runtime');
+        },
+        toString: () => '<root>',
+    };
+    const maybeRoot = tryFindRoot(items);
+    return resolveImpl(resolutionObj, {
+        namespace: typeof names === 'string' ? namespace({ names }) : names,
+        minify: unstable_minify ?? maybeRoot?.minify ?? false,
+        enableExtensions,
+        shaderGenerator,
+        config,
+        root: maybeRoot,
+    });
 }
 /**
-* Attempts to locate a pipeline in a list of items and returns the root.
-* Does not check recursively.
-* Throws an error if multiple pipelines are found.
-*/
+ * Attempts to locate a root in a list of items that may hold it.
+ * Does not check recursively.
+ * Throws an error if multiple roots are found.
+ */
 function tryFindRoot(items) {
-	const pipelines = items.filter(isPipeline);
-	if (pipelines.length > 1) throw new Error(`Found ${pipelines.length} pipelines but can only resolve one at a time.`);
-	return pipelines[0]?.[$internal].root;
+    const buckets = new Map();
+    for (const item of items) {
+        const root = extractRoot(item);
+        if (root) {
+            const bucket = buckets.get(root) ?? new Set();
+            buckets.set(root, bucket);
+            bucket.add(item);
+        }
+    }
+    if (buckets.size > 1) {
+        const bucketsString = [...buckets.values()]
+            .map((bucket, i) => `root ${i + 1}: ${[...bucket].map((item) => getName(item) ?? '<unnamed>').join(', ')}`)
+            .join('; ');
+        throw new Error(`Found resources originating from different roots in a single resolve (${bucketsString}).`);
+    }
+    return [...buckets.keys()][0];
+}
+function extractRoot(item) {
+    if (isPipeline(item) ||
+        isBuffer(item) ||
+        isTexture(item) ||
+        isSampler(item) ||
+        isComparisonSampler(item)) {
+        return item[$internal].root;
+    }
+    if (isBufferBinding(item)) {
+        return extractRoot(item.buffer);
+    }
+    if (isTextureView(item)) {
+        // laid out texture view should never appear here, but still passes this type guard
+        return extractRoot(item?.[$soul]?.texture);
+    }
+    return undefined;
 }
-
-//#endregion
-export { resolve$1 as resolve, resolveWithContext };

package/core/root/configurableImpl.d.ts

@@ -0,0 +1,10 @@
+import type { BaseData } from '../../data/wgslTypes.ts';
+import type { Infer } from '../../shared/repr.ts';
+import { type TgpuAccessor, type TgpuMutableAccessor, type TgpuSlot } from '../slot/slotTypes.ts';
+import type { Configurable } from './rootTypes.ts';
+export declare class ConfigurableImpl implements Configurable {
+    readonly bindings: [TgpuSlot<unknown>, unknown][];
+    constructor(bindings: [TgpuSlot<unknown>, unknown][]);
+    with<T extends BaseData>(slot: TgpuSlot<T> | TgpuAccessor<T> | TgpuMutableAccessor<T>, value: TgpuAccessor.In<T> | TgpuMutableAccessor.In<T> | Infer<T>): Configurable;
+    pipe(transform: (cfg: Configurable) => Configurable): Configurable;
+}

package/core/root/configurableImpl.js

@@ -1,19 +1,17 @@
-import { isAccessor, isMutableAccessor } from "../slot/slotTypes.js";
-
-//#region src/core/root/configurableImpl.ts
-var ConfigurableImpl = class ConfigurableImpl {
-	bindings;
-	constructor(bindings) {
-		this.bindings = bindings;
-	}
-	with(slot, value) {
-		return new ConfigurableImpl([...this.bindings, [isAccessor(slot) || isMutableAccessor(slot) ? slot.slot : slot, value]]);
-	}
-	pipe(transform) {
-		const newCfg = transform(this);
-		return new ConfigurableImpl([...this.bindings, ...newCfg.bindings]);
-	}
-};
-
-//#endregion
-export { ConfigurableImpl };
+import { isAccessor, isMutableAccessor, } from "../slot/slotTypes.js";
+export class ConfigurableImpl {
+    bindings;
+    constructor(bindings) {
+        this.bindings = bindings;
+    }
+    with(slot, value) {
+        return new ConfigurableImpl([
+            ...this.bindings,
+            [isAccessor(slot) || isMutableAccessor(slot) ? slot.slot : slot, value],
+        ]);
+    }
+    pipe(transform) {
+        const newCfg = transform(this);
+        return new ConfigurableImpl([...this.bindings, ...newCfg.bindings]);
+    }
+}

package/core/root/init.d.ts

@@ -1,44 +1,84 @@
-import "../querySet/querySet.js";
-import "../buffer/bufferShorthand.js";
-import { LogGeneratorOptions } from "../../tgsl/consoleLog/types.js";
-import "../pipeline/computePipeline.js";
-import "../../tgpuBindGroupLayout.js";
-import { ShaderGenerator } from "../../tgsl/shaderGenerator.js";
-import { TgpuRoot } from "./rootTypes.js";
-import "../../data/wgslTypes.js";
-
-//#region src/core/root/init.d.ts
-
+import { type TgpuQuerySet } from '../querySet/querySet.ts';
+import type { v3u, Vec3u } from '../../data/wgslTypes.ts';
+import { $getNameForward, $internal, $soul } from '../../shared/symbols.ts';
+import type { TgpuBindGroup } from '../../tgpuBindGroupLayout.ts';
+import type { LogGeneratorOptions } from '../../tgsl/consoleLog/types.ts';
+import type { WgslGeneratorClass } from '../../tgsl/shaderGenerator.ts';
+import { type TgpuUniform } from '../buffer/bufferBinding.ts';
+import { type TgpuComputePipeline } from '../pipeline/computePipeline.ts';
+import type { ExperimentalTgpuRoot, TgpuGuardedComputePipeline, TgpuGuardedComputePipelineSoul, TgpuRootSoul, TgpuRoot } from './rootTypes.ts';
+import type { RestoreContext } from '../../serial/types.ts';
+export declare class TgpuGuardedComputePipelineImpl<TArgs extends number[]> implements TgpuGuardedComputePipeline<TArgs> {
+    #private;
+    readonly resourceType = "guarded-compute-pipeline";
+    readonly [$soul]: TgpuGuardedComputePipelineSoul;
+    constructor(root: ExperimentalTgpuRoot, pipeline: TgpuComputePipeline, sizeUniform: TgpuUniform<Vec3u>, workgroupSize: v3u);
+    with(bindGroup: TgpuBindGroup): TgpuGuardedComputePipeline<TArgs>;
+    withPerformanceCallback(callback: (start: bigint, end: bigint) => void | Promise<void>): TgpuGuardedComputePipeline<TArgs>;
+    withTimestampWrites(options: {
+        querySet: TgpuQuerySet<'timestamp'> | GPUQuerySet;
+        beginningOfPassWriteIndex?: number;
+        endOfPassWriteIndex?: number;
+    }): TgpuGuardedComputePipeline<TArgs>;
+    dispatchThreads(...threads: TArgs): void;
+    initAsync(): Promise<void>;
+    initSync(): void;
+    get pipeline(): TgpuComputePipeline;
+    get sizeUniform(): TgpuUniform<Vec3u>;
+    [$internal]: boolean;
+    get [$getNameForward](): TgpuComputePipeline;
+    $name(label: string): this;
+}
+export declare function INTERNAL_restoreRoot(soul: TgpuRootSoul, ctx: RestoreContext): TgpuRoot;
+export declare function INTERNAL_restoreGuardedComputePipeline(soul: TgpuGuardedComputePipelineSoul, ctx: RestoreContext): TgpuGuardedComputePipeline;
 /**
  * Options passed into {@link init}.
  */
-type InitOptions = {
-  adapter?: GPURequestAdapterOptions | undefined;
-  device?: (GPUDeviceDescriptor & {
-    optionalFeatures?: Iterable<GPUFeatureName>;
-  }) | undefined;
-  /** @default 'random' */
-  unstable_names?: 'random' | 'strict' | undefined;
-  /**
-   * A custom shader code generator, used when resolving TypeGPU functions.
-   * If not provided, the default WGSL generator will be used.
-   */
-  shaderGenerator?: ShaderGenerator | undefined;
-  unstable_logOptions?: LogGeneratorOptions;
+export type InitOptions = {
+    adapter?: GPURequestAdapterOptions | undefined;
+    device?: (GPUDeviceDescriptor & {
+        optionalFeatures?: Iterable<GPUFeatureName>;
+    }) | undefined;
+    /** @default 'strict' */
+    unstable_names?: 'random' | 'strict' | undefined;
+    /**
+     * If set to true, rooted resolves will be stripped of all excessive spaces.
+     * Rooted resolves include pipelines and all their transitive dependencies,
+     * but not, for example, `tgpu.resolve([MyStruct])`,
+     * as there may be multiple roots with different settings in one program.
+     *
+     * @default false
+     */
+    unstable_minify?: boolean;
+    /**
+     * A custom shader code generator, used when resolving TypeGPU functions.
+     * If not provided, the default WGSL generator will be used.
+     */
+    unstable_shaderGeneratorClass?: WgslGeneratorClass | undefined;
+    unstable_logOptions?: LogGeneratorOptions;
 };
 /**
  * Options passed into {@link initFromDevice}.
  */
-type InitFromDeviceOptions = {
-  device: GPUDevice;
-  /** @default 'random' */
-  unstable_names?: 'random' | 'strict' | undefined;
-  /**
-   * A custom shader code generator, used when resolving TypeGPU functions.
-   * If not provided, the default WGSL generator will be used.
-   */
-  shaderGenerator?: ShaderGenerator | undefined;
-  unstable_logOptions?: LogGeneratorOptions;
+export type InitFromDeviceOptions = {
+    device: GPUDevice;
+    /** @default 'strict' */
+    unstable_names?: 'random' | 'strict' | undefined;
+    /**
+     * If set to true, rooted resolves will be stripped of all excessive spaces.
+     * Rooted resolves include pipelines and all their transitive dependencies,
+     * but not, for example, `tgpu.resolve([MyStruct])`,
+     * as there may be multiple roots with different settings in one program.
+     *
+     * @default false
+     */
+    unstable_minify?: boolean;
+    /**
+     * A custom shader code generator, used when resolving TypeGPU functions.
+     * If not provided, the default WGSL generator will be used.
+     */
+    unstable_shaderGeneratorClass?: WgslGeneratorClass | undefined;
+    unstable_logOptions?: LogGeneratorOptions;
 };
 /**
  * Requests a new GPU device and creates a root around it.
@@ -58,7 +98,7 @@ type InitFromDeviceOptions = {
  * const root = await tgpu.init({ adapter: adapterOptions, device: deviceDescriptor });
  * ```
  */
-declare function init(options?: InitOptions): Promise<TgpuRoot>;
+export declare function init(options?: InitOptions): Promise<TgpuRoot>;
 /**
  * Creates a root from the given device, instead of requesting it like @see init.
  *
@@ -68,6 +108,4 @@ declare function init(options?: InitOptions): Promise<TgpuRoot>;
  * const root = tgpu.initFromDevice({ device });
  * ```
  */
-declare function initFromDevice(options: InitFromDeviceOptions): TgpuRoot;
-//#endregion
-export { InitFromDeviceOptions, InitOptions, init, initFromDevice };
+export declare function initFromDevice(options: InitFromDeviceOptions): TgpuRoot;