typegpu 0.11.9 → 0.12.1

package/core/texture/textureUtils.js

@@ -1,28 +1,22 @@
 import { getEffectiveSampleTypes, getTextureFormatInfo } from "./textureFormats.js";
-
-//#region src/core/texture/textureUtils.ts
-function getImageSourceDimensions(source) {
-	const { videoWidth, videoHeight } = source;
-	if (videoWidth && videoHeight) return {
-		width: videoWidth,
-		height: videoHeight
-	};
-	const { naturalWidth, naturalHeight } = source;
-	if (naturalWidth && naturalHeight) return {
-		width: naturalWidth,
-		height: naturalHeight
-	};
-	const { codedWidth, codedHeight } = source;
-	if (codedWidth && codedHeight) return {
-		width: codedWidth,
-		height: codedHeight
-	};
-	const { width, height } = source;
-	if (width && height) return {
-		width,
-		height
-	};
-	throw new Error("Cannot determine dimensions of the provided image source.");
+export function getImageSourceDimensions(source) {
+    const { videoWidth, videoHeight } = source;
+    if (videoWidth && videoHeight) {
+        return { width: videoWidth, height: videoHeight };
+    }
+    const { naturalWidth, naturalHeight } = source;
+    if (naturalWidth && naturalHeight) {
+        return { width: naturalWidth, height: naturalHeight };
+    }
+    const { codedWidth, codedHeight } = source;
+    if (codedWidth && codedHeight) {
+        return { width: codedWidth, height: codedHeight };
+    }
+    const { width, height } = source;
+    if (width && height) {
+        return { width, height };
+    }
+    throw new Error('Cannot determine dimensions of the provided image source.');
 }
 const FULLSCREEN_VERTEX_SHADER = `
 struct VertexOutput {
@@ -56,169 +50,181 @@ fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
   let a = textureGather(3, src, samp, uv);
   return vec4f(dot(r, vec4f(0.25)), dot(g, vec4f(0.25)), dot(b, vec4f(0.25)), dot(a, vec4f(0.25)));
 }`;
-const blitCache = /* @__PURE__ */ new WeakMap();
+const blitCache = new WeakMap();
 function getOrCreateDeviceCache(device) {
-	let cache = blitCache.get(device);
-	if (!cache) {
-		cache = {
-			vertexModule: device.createShaderModule({ code: FULLSCREEN_VERTEX_SHADER }),
-			filterableResources: /* @__PURE__ */ new Map(),
-			layoutResources: /* @__PURE__ */ new Map()
-		};
-		blitCache.set(device, cache);
-	}
-	return cache;
+    let cache = blitCache.get(device);
+    if (!cache) {
+        cache = {
+            vertexModule: device.createShaderModule({
+                code: FULLSCREEN_VERTEX_SHADER,
+            }),
+            filterableResources: new Map(),
+            layoutResources: new Map(),
+        };
+        blitCache.set(device, cache);
+    }
+    return cache;
 }
 function getBlitResources(device, filterable, sampleType) {
-	const cache = getOrCreateDeviceCache(device);
-	let filterableRes = cache.filterableResources.get(filterable);
-	if (!filterableRes) {
-		filterableRes = {
-			fragmentModule: device.createShaderModule({ code: filterable ? SAMPLE_FRAGMENT_SHADER : GATHER_FRAGMENT_SHADER }),
-			sampler: device.createSampler(filterable ? {
-				magFilter: "linear",
-				minFilter: "linear"
-			} : {})
-		};
-		cache.filterableResources.set(filterable, filterableRes);
-	}
-	const layoutKey = `${filterable}:${sampleType}`;
-	let layoutRes = cache.layoutResources.get(layoutKey);
-	if (!layoutRes) {
-		const bindGroupLayout = device.createBindGroupLayout({ entries: [{
-			binding: 0,
-			visibility: GPUShaderStage.FRAGMENT,
-			texture: { sampleType }
-		}, {
-			binding: 1,
-			visibility: GPUShaderStage.FRAGMENT,
-			sampler: { type: filterable ? "filtering" : "non-filtering" }
-		}] });
-		layoutRes = {
-			bindGroupLayout,
-			pipelineLayout: device.createPipelineLayout({ bindGroupLayouts: [bindGroupLayout] })
-		};
-		cache.layoutResources.set(layoutKey, layoutRes);
-	}
-	return {
-		vertexModule: cache.vertexModule,
-		...filterableRes,
-		...layoutRes
-	};
+    const cache = getOrCreateDeviceCache(device);
+    let filterableRes = cache.filterableResources.get(filterable);
+    if (!filterableRes) {
+        filterableRes = {
+            fragmentModule: device.createShaderModule({
+                code: filterable ? SAMPLE_FRAGMENT_SHADER : GATHER_FRAGMENT_SHADER,
+            }),
+            sampler: device.createSampler(filterable ? { magFilter: 'linear', minFilter: 'linear' } : {}),
+        };
+        cache.filterableResources.set(filterable, filterableRes);
+    }
+    const layoutKey = `${filterable}:${sampleType}`;
+    let layoutRes = cache.layoutResources.get(layoutKey);
+    if (!layoutRes) {
+        const bindGroupLayout = device.createBindGroupLayout({
+            entries: [
+                {
+                    binding: 0,
+                    visibility: GPUShaderStage.FRAGMENT,
+                    texture: { sampleType },
+                },
+                {
+                    binding: 1,
+                    visibility: GPUShaderStage.FRAGMENT,
+                    sampler: { type: filterable ? 'filtering' : 'non-filtering' },
+                },
+            ],
+        });
+        layoutRes = {
+            bindGroupLayout,
+            pipelineLayout: device.createPipelineLayout({
+                bindGroupLayouts: [bindGroupLayout],
+            }),
+        };
+        cache.layoutResources.set(layoutKey, layoutRes);
+    }
+    return {
+        vertexModule: cache.vertexModule,
+        ...filterableRes,
+        ...layoutRes,
+    };
 }
 function blit(options) {
-	const { device, source, destination, format, filterable, sampleType } = options;
-	const resources = getBlitResources(device, filterable, sampleType);
-	const pipeline = device.createRenderPipeline({
-		layout: resources.pipelineLayout,
-		vertex: { module: resources.vertexModule },
-		fragment: {
-			module: resources.fragmentModule,
-			targets: [{ format }]
-		},
-		primitive: { topology: "triangle-list" }
-	});
-	const bindGroup = device.createBindGroup({
-		layout: resources.bindGroupLayout,
-		entries: [{
-			binding: 0,
-			resource: source
-		}, {
-			binding: 1,
-			resource: resources.sampler
-		}]
-	});
-	const ownEncoder = !options.encoder;
-	const encoder = options.encoder ?? device.createCommandEncoder();
-	const pass = encoder.beginRenderPass({ colorAttachments: [{
-		view: destination,
-		loadOp: "clear",
-		storeOp: "store"
-	}] });
-	pass.setPipeline(pipeline);
-	pass.setBindGroup(0, bindGroup);
-	pass.draw(3);
-	pass.end();
-	if (ownEncoder) device.queue.submit([encoder.finish()]);
+    const { device, source, destination, format, filterable, sampleType } = options;
+    const resources = getBlitResources(device, filterable, sampleType);
+    const pipeline = device.createRenderPipeline({
+        layout: resources.pipelineLayout,
+        vertex: { module: resources.vertexModule },
+        fragment: { module: resources.fragmentModule, targets: [{ format }] },
+        primitive: { topology: 'triangle-list' },
+    });
+    const bindGroup = device.createBindGroup({
+        layout: resources.bindGroupLayout,
+        entries: [
+            { binding: 0, resource: source },
+            { binding: 1, resource: resources.sampler },
+        ],
+    });
+    const ownEncoder = !options.encoder;
+    const encoder = options.encoder ?? device.createCommandEncoder();
+    const pass = encoder.beginRenderPass({
+        colorAttachments: [
+            {
+                view: destination,
+                loadOp: 'clear',
+                storeOp: 'store',
+            },
+        ],
+    });
+    pass.setPipeline(pipeline);
+    pass.setBindGroup(0, bindGroup);
+    pass.draw(3);
+    pass.end();
+    if (ownEncoder) {
+        device.queue.submit([encoder.finish()]);
+    }
 }
-function clearTextureUtilsCache(device) {
-	blitCache.delete(device);
+export function clearTextureUtilsCache(device) {
+    blitCache.delete(device);
 }
 function validateBlitFormat(device, format, operation) {
-	const info = getTextureFormatInfo(format);
-	const effectiveSampleTypes = getEffectiveSampleTypes(device, format);
-	const isFloat = effectiveSampleTypes.includes("float");
-	const isUnfilterableFloat = effectiveSampleTypes.includes("unfilterable-float");
-	if (!isFloat && !isUnfilterableFloat) throw new Error(`Cannot ${operation} for format '${format}': only float formats are supported.`);
-	if (!info.canRenderAttachment) throw new Error(`Cannot ${operation} for format '${format}': format does not support render attachments.`);
-	return {
-		filterable: isFloat,
-		sampleType: isFloat ? "float" : "unfilterable-float"
-	};
+    const info = getTextureFormatInfo(format);
+    const effectiveSampleTypes = getEffectiveSampleTypes(device, format);
+    const isFloat = effectiveSampleTypes.includes('float');
+    const isUnfilterableFloat = effectiveSampleTypes.includes('unfilterable-float');
+    if (!isFloat && !isUnfilterableFloat) {
+        throw new Error(`Cannot ${operation} for format '${format}': only float formats are supported.`);
+    }
+    if (!info.canRenderAttachment) {
+        throw new Error(`Cannot ${operation} for format '${format}': format does not support render attachments.`);
+    }
+    return {
+        filterable: isFloat,
+        sampleType: isFloat ? 'float' : 'unfilterable-float',
+    };
 }
-function generateTextureMipmaps(device, texture, baseMipLevel = 0, mipLevels) {
-	if (texture.dimension !== "2d") throw new Error("Mipmap generation only supports 2D textures.");
-	const { filterable, sampleType } = validateBlitFormat(device, texture.format, "generate mipmaps");
-	const levels = mipLevels ?? texture.mipLevelCount - baseMipLevel;
-	for (let layer = 0; layer < texture.depthOrArrayLayers; layer++) for (let mip = baseMipLevel; mip < baseMipLevel + levels - 1; mip++) {
-		const viewOptions = (level) => ({
-			dimension: "2d",
-			baseMipLevel: level,
-			mipLevelCount: 1,
-			baseArrayLayer: layer,
-			arrayLayerCount: 1
-		});
-		blit({
-			device,
-			source: texture.createView(viewOptions(mip)),
-			destination: texture.createView(viewOptions(mip + 1)),
-			format: texture.format,
-			filterable,
-			sampleType
-		});
-	}
+export function generateTextureMipmaps(device, texture, baseMipLevel = 0, mipLevels) {
+    if (texture.dimension !== '2d') {
+        throw new Error('Mipmap generation only supports 2D textures.');
+    }
+    const { filterable, sampleType } = validateBlitFormat(device, texture.format, 'generate mipmaps');
+    const levels = mipLevels ?? texture.mipLevelCount - baseMipLevel;
+    for (let layer = 0; layer < texture.depthOrArrayLayers; layer++) {
+        for (let mip = baseMipLevel; mip < baseMipLevel + levels - 1; mip++) {
+            const viewOptions = (level) => ({
+                dimension: '2d',
+                baseMipLevel: level,
+                mipLevelCount: 1,
+                baseArrayLayer: layer,
+                arrayLayerCount: 1,
+            });
+            blit({
+                device,
+                source: texture.createView(viewOptions(mip)),
+                destination: texture.createView(viewOptions(mip + 1)),
+                format: texture.format,
+                filterable,
+                sampleType,
+            });
+        }
+    }
 }
-function resampleImage(device, targetTexture, image, layer = 0) {
-	if (targetTexture.dimension !== "2d") throw new Error("Resampling only supports 2D textures.");
-	const { filterable } = validateBlitFormat(device, targetTexture.format, "resample");
-	const { width, height } = getImageSourceDimensions(image);
-	const inputTexture = device.createTexture({
-		size: [width, height],
-		format: "rgba8unorm",
-		usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT
-	});
-	device.queue.copyExternalImageToTexture({ source: image }, { texture: inputTexture }, [width, height]);
-	const renderTexture = device.createTexture({
-		size: [targetTexture.width, targetTexture.height],
-		format: targetTexture.format,
-		usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC
-	});
-	const encoder = device.createCommandEncoder();
-	blit({
-		device,
-		source: inputTexture.createView(),
-		destination: renderTexture.createView(),
-		format: targetTexture.format,
-		filterable,
-		sampleType: "float",
-		encoder
-	});
-	encoder.copyTextureToTexture({ texture: renderTexture }, {
-		texture: targetTexture,
-		origin: {
-			x: 0,
-			y: 0,
-			z: layer
-		}
-	}, {
-		width: targetTexture.width,
-		height: targetTexture.height,
-		depthOrArrayLayers: 1
-	});
-	device.queue.submit([encoder.finish()]);
-	inputTexture.destroy();
-	renderTexture.destroy();
+export function resampleImage(device, targetTexture, image, layer = 0) {
+    if (targetTexture.dimension !== '2d') {
+        throw new Error('Resampling only supports 2D textures.');
+    }
+    const { filterable } = validateBlitFormat(device, targetTexture.format, 'resample');
+    const { width, height } = getImageSourceDimensions(image);
+    const inputTexture = device.createTexture({
+        size: [width, height],
+        format: 'rgba8unorm',
+        usage: GPUTextureUsage.TEXTURE_BINDING |
+            GPUTextureUsage.COPY_DST |
+            GPUTextureUsage.RENDER_ATTACHMENT,
+    });
+    device.queue.copyExternalImageToTexture({ source: image }, {
+        texture: inputTexture,
+    }, [width, height]);
+    const renderTexture = device.createTexture({
+        size: [targetTexture.width, targetTexture.height],
+        format: targetTexture.format,
+        usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
+    });
+    const encoder = device.createCommandEncoder();
+    blit({
+        device,
+        source: inputTexture.createView(),
+        destination: renderTexture.createView(),
+        format: targetTexture.format,
+        filterable,
+        sampleType: 'float', // Input is always rgba8unorm which is filterable
+        encoder,
+    });
+    encoder.copyTextureToTexture({ texture: renderTexture }, { texture: targetTexture, origin: { x: 0, y: 0, z: layer } }, {
+        width: targetTexture.width,
+        height: targetTexture.height,
+        depthOrArrayLayers: 1,
+    });
+    device.queue.submit([encoder.finish()]);
+    inputTexture.destroy();
+    renderTexture.destroy();
 }
-
-//#endregion
-export { clearTextureUtilsCache, generateTextureMipmaps, getImageSourceDimensions, resampleImage };

package/core/texture/usageExtension.d.ts

@@ -1,21 +1,24 @@
-import { StorageFlag } from "../../extension.js";
-import { TextureProps } from "./textureProps.js";
-import { StorageTextureFormats } from "./textureFormats.js";
-
-//#region src/core/texture/usageExtension.d.ts
-interface SampledFlag {
-  usableAsSampled: true;
+import type { StorageFlag } from '../../extension.ts';
+import type { StorageTextureFormats } from './textureFormats.ts';
+import type { TextureProps } from './textureProps.ts';
+export interface SampledFlag {
+    usableAsSampled: true;
 }
-interface RenderFlag {
-  usableAsRender: true;
+export interface RenderFlag {
+    usableAsRender: true;
 }
-type LiteralToExtensionMap = {
-  storage: StorageFlag;
-  sampled: SampledFlag;
-  render: RenderFlag;
+export type LiteralToExtensionMap = {
+    storage: StorageFlag;
+    sampled: SampledFlag;
+    render: RenderFlag;
+    transient: RenderFlag;
 };
-type AllowedUsages<TProps extends TextureProps> = 'sampled' | 'render' | (TProps['format'] extends StorageTextureFormats ? 'storage' : never);
-declare function isUsableAsSampled<T>(value: T): value is T & SampledFlag;
-declare function isUsableAsRender<T>(value: T): value is T & RenderFlag;
-//#endregion
-export { AllowedUsages, LiteralToExtensionMap, RenderFlag, SampledFlag, isUsableAsRender, isUsableAsSampled };
+export type AllowedUsages<TProps extends TextureProps> = 'sampled' | 'render' | 'transient' | (TProps['format'] extends StorageTextureFormats ? 'storage' : never);
+export declare function isUsableAsSampled<T>(value: T): value is T & SampledFlag;
+export declare function isUsableAsRender<T>(value: T): value is T & RenderFlag;
+/**
+ * @category Errors
+ */
+export declare class NotSampledError extends Error {
+    constructor(value: object);
+}

package/core/texture/usageExtension.js

@@ -1,21 +1,17 @@
 import { getName } from "../../shared/meta.js";
-
-//#region src/core/texture/usageExtension.ts
-function isUsableAsSampled(value) {
-	return !!value?.usableAsSampled;
+export function isUsableAsSampled(value) {
+    return !!value?.usableAsSampled;
 }
-function isUsableAsRender(value) {
-	return !!value?.usableAsRender;
+export function isUsableAsRender(value) {
+    return !!value?.usableAsRender;
 }
 /**
-* @category Errors
-*/
-var NotSampledError = class NotSampledError extends Error {
-	constructor(value) {
-		super(`Resource '${getName(value) ?? "<unnamed>"}' cannot be bound as 'sampled'. Use .$usage('sampled') to allow it.`);
-		Object.setPrototypeOf(this, NotSampledError.prototype);
-	}
-};
-
-//#endregion
-export { NotSampledError, isUsableAsRender, isUsableAsSampled };
+ * @category Errors
+ */
+export class NotSampledError extends Error {
+    constructor(value) {
+        super(`Resource '${getName(value) ?? '<unnamed>'}' cannot be bound as 'sampled'. Use .$usage('sampled') to allow it.`);
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, NotSampledError.prototype);
+    }
+}

package/core/unroll/tgpuUnroll.d.ts

@@ -1,9 +1,17 @@
-import { $internal } from "../../shared/symbols.js";
-import "../../data/snippet.js";
-import { GPUCallable } from "../../types.js";
-
-//#region src/core/unroll/tgpuUnroll.d.ts
-
+import { $internal, $resolve } from '../../shared/symbols.ts';
+import { type ResolvedSnippet, type Snippet } from '../../data/snippet.ts';
+import type { ResolutionCtx, SelfResolvable } from '../../types.ts';
+/**
+ * The result of calling `tgpu.unroll(...)`. The code responsible for
+ * generating shader code can check if the value of a snippet is
+ * an instance of `UnrollableIterable`, and act accordingly.
+ */
+export declare class UnrollableIterable implements SelfResolvable {
+    readonly [$internal] = true;
+    readonly snippet: Snippet;
+    constructor(snippet: Snippet);
+    [$resolve](ctx: ResolutionCtx): ResolvedSnippet;
+}
 /**
  * Marks an iterable to be unrolled by the shader generator when used in a for loop.
  *
@@ -48,23 +56,16 @@ import { GPUCallable } from "../../types.js";
  * fn fbm(pos: vec3f) -> f32 {
  *   var sum = 0f;
  *   // unrolled iteration #0
- *   {
- *     sum += noise3d(pos * 1.4f) * 1f;
- *   }
+ *   sum += noise3d(pos * 1.4f) * 1f;
  *   // unrolled iteration #1
- *   {
- *     sum += noise3d(pos * 2.8f) * 0.5f;
- *   }
+ *   sum += noise3d(pos * 2.8f) * 0.5f;
  *   // unrolled iteration #2
- *   {
- *     sum += noise3d(pos * 5.6f) * 0.25f;
- *   }
+ *   sum += noise3d(pos * 5.6f) * 0.25f;
+ *   // ---
  *   return sum;
  * }
  * ```
  */
-declare const unroll: (<T extends Iterable<unknown>>(iterable: T) => T) & GPUCallable<[iterable: Iterable<unknown>]> & {
-  [$internal]: true;
+export declare const unroll: (<T extends Iterable<unknown>>(iterable: T) => T) & import("../../types.ts").GPUCallable<[iterable: Iterable<unknown>]> & {
+    [$internal]: true;
 };
-//#endregion
-export { unroll };