typegpu 0.11.9 → 0.12.1

package/std/texture.js

@@ -1,209 +1,213 @@
-import { Void } from "../data/wgslTypes.js";
 import { stitch } from "../core/resolve/stitch.js";
+import { isWgslExternalTexture, isWgslTexture, } from "../data/texture.js";
+import { dualImpl, MissingCpuImplError } from "../core/function/dualImpl.js";
 import { f32, i32, u32 } from "../data/numeric.js";
 import { vec2u, vec3u, vec4f, vec4i, vec4u } from "../data/vector.js";
-import { MissingCpuImplError, dualImpl } from "../core/function/dualImpl.js";
-import { isWgslExternalTexture, isWgslTexture } from "../data/texture.js";
-import { getTextureFormatInfo } from "../core/texture/textureFormats.js";
-
-//#region src/std/texture.ts
+import { Void, } from "../data/wgslTypes.js";
+import { getTextureFormatInfo, } from "../core/texture/textureFormats.js";
 function sampleCpu(_texture, _sampler, _coords, _offsetOrArrayIndex, _maybeOffset) {
-	throw new MissingCpuImplError("Texture sampling relies on GPU resources and cannot be executed outside of a draw call");
+    throw new MissingCpuImplError('Texture sampling relies on GPU resources and cannot be executed outside of a draw call');
 }
-const textureSample = dualImpl({
-	name: "textureSample",
-	normalImpl: sampleCpu,
-	codegenImpl: (_ctx, args) => stitch`textureSample(${args})`,
-	signature: (...args) => {
-		return {
-			argTypes: args,
-			returnType: args[0].type.startsWith("texture_depth") ? f32 : vec4f
-		};
-	}
+export const textureSample = dualImpl({
+    name: 'textureSample',
+    normalImpl: sampleCpu,
+    codegenImpl: (_ctx, args) => stitch `textureSample(${args})`,
+    signature: (...args) => {
+        const isDepth = args[0].type.startsWith('texture_depth');
+        return {
+            argTypes: args,
+            returnType: isDepth ? f32 : vec4f,
+        };
+    },
+    sideEffects: false,
 });
 function sampleBiasCpu(_texture, _sampler, _coords, _biasOrArrayIndex, _biasOrOffset, _maybeOffset) {
-	throw new MissingCpuImplError("Texture sampling with bias relies on GPU resources and cannot be executed outside of a draw call");
+    throw new MissingCpuImplError('Texture sampling with bias relies on GPU resources and cannot be executed outside of a draw call');
 }
-const textureSampleBias = dualImpl({
-	name: "textureSampleBias",
-	normalImpl: sampleBiasCpu,
-	codegenImpl: (_ctx, args) => stitch`textureSampleBias(${args})`,
-	signature: (...args) => ({
-		argTypes: args,
-		returnType: vec4f
-	})
+export const textureSampleBias = dualImpl({
+    name: 'textureSampleBias',
+    normalImpl: sampleBiasCpu,
+    codegenImpl: (_ctx, args) => stitch `textureSampleBias(${args})`,
+    signature: (...args) => ({
+        argTypes: args,
+        returnType: vec4f,
+    }),
+    sideEffects: false,
 });
 function sampleLevelCpu(_texture, _sampler, _coords, _level, _offsetOrArrayIndex, _maybeOffset) {
-	throw new MissingCpuImplError("Texture sampling relies on GPU resources and cannot be executed outside of a draw call");
+    throw new MissingCpuImplError('Texture sampling relies on GPU resources and cannot be executed outside of a draw call');
 }
-const textureSampleLevel = dualImpl({
-	name: "textureSampleLevel",
-	normalImpl: sampleLevelCpu,
-	codegenImpl: (_ctx, args) => stitch`textureSampleLevel(${args})`,
-	signature: (...args) => {
-		return {
-			argTypes: args,
-			returnType: args[0].type.startsWith("texture_depth") ? f32 : vec4f
-		};
-	}
+export const textureSampleLevel = dualImpl({
+    name: 'textureSampleLevel',
+    normalImpl: sampleLevelCpu,
+    codegenImpl: (_ctx, args) => stitch `textureSampleLevel(${args})`,
+    signature: (...args) => {
+        const isDepth = args[0].type.startsWith('texture_depth');
+        return {
+            argTypes: args,
+            returnType: isDepth ? f32 : vec4f,
+        };
+    },
+    sideEffects: false,
 });
 function textureLoadCpu(_texture, _coords, _levelOrArrayIndex) {
-	throw new MissingCpuImplError("`textureLoad` relies on GPU resources and cannot be executed outside of a draw call");
+    throw new MissingCpuImplError('`textureLoad` relies on GPU resources and cannot be executed outside of a draw call');
 }
-const textureLoad = dualImpl({
-	name: "textureLoad",
-	normalImpl: textureLoadCpu,
-	codegenImpl: (_ctx, args) => stitch`textureLoad(${args})`,
-	signature: (...args) => {
-		const texture = args[0];
-		if (isWgslTexture(texture)) {
-			const isDepth = texture.type.startsWith("texture_depth");
-			const sampleType = texture.sampleType;
-			return {
-				argTypes: args,
-				returnType: isDepth ? f32 : sampleType.type === "f32" ? vec4f : sampleType.type === "u32" ? vec4u : vec4i
-			};
-		}
-		if (isWgslExternalTexture(texture)) return {
-			argTypes: args,
-			returnType: vec4f
-		};
-		const format = texture.format;
-		return {
-			argTypes: args,
-			returnType: getTextureFormatInfo(format).vectorType
-		};
-	}
+export const textureLoad = dualImpl({
+    name: 'textureLoad',
+    normalImpl: textureLoadCpu,
+    codegenImpl: (_ctx, args) => stitch `textureLoad(${args})`,
+    signature: (...args) => {
+        const texture = args[0];
+        if (isWgslTexture(texture)) {
+            const isDepth = texture.type.startsWith('texture_depth');
+            const sampleType = texture.sampleType;
+            return {
+                argTypes: args,
+                returnType: isDepth
+                    ? f32
+                    : sampleType.type === 'f32'
+                        ? vec4f
+                        : sampleType.type === 'u32'
+                            ? vec4u
+                            : vec4i,
+            };
+        }
+        if (isWgslExternalTexture(texture)) {
+            return {
+                argTypes: args,
+                returnType: vec4f,
+            };
+        }
+        const format = texture.format;
+        const dataType = getTextureFormatInfo(format).vectorType;
+        return {
+            argTypes: args,
+            returnType: dataType,
+        };
+    },
+    sideEffects: false,
 });
 function textureStoreCpu(_texture, _coords, _arrayIndexOrValue, _maybeValue) {
-	throw new MissingCpuImplError("`textureStore` relies on GPU resources and cannot be executed outside of a draw call");
+    throw new MissingCpuImplError('`textureStore` relies on GPU resources and cannot be executed outside of a draw call');
 }
-const textureStore = dualImpl({
-	name: "textureStore",
-	normalImpl: textureStoreCpu,
-	codegenImpl: (_ctx, args) => stitch`textureStore(${args})`,
-	signature: (...args) => ({
-		argTypes: args,
-		returnType: Void
-	})
+export const textureStore = dualImpl({
+    name: 'textureStore',
+    normalImpl: textureStoreCpu,
+    codegenImpl: (_ctx, args) => stitch `textureStore(${args})`,
+    signature: (...args) => ({ argTypes: args, returnType: Void }),
+    sideEffects: true,
 });
 function textureDimensionsCpu(_texture, _level) {
-	throw new MissingCpuImplError("`textureDimensions` relies on GPU resources and cannot be executed outside of a draw call");
+    throw new MissingCpuImplError('`textureDimensions` relies on GPU resources and cannot be executed outside of a draw call');
 }
-const textureDimensions = dualImpl({
-	name: "textureDimensions",
-	normalImpl: textureDimensionsCpu,
-	codegenImpl: (_ctx, args) => stitch`textureDimensions(${args})`,
-	signature: (...args) => {
-		const dim = args[0].dimension;
-		if (dim === "1d") return {
-			argTypes: args,
-			returnType: u32
-		};
-		if (dim === "3d") return {
-			argTypes: args,
-			returnType: vec3u
-		};
-		return {
-			argTypes: args,
-			returnType: vec2u
-		};
-	}
+export const textureDimensions = dualImpl({
+    name: 'textureDimensions',
+    normalImpl: textureDimensionsCpu,
+    codegenImpl: (_ctx, args) => stitch `textureDimensions(${args})`,
+    signature: (...args) => {
+        const dim = args[0].dimension;
+        if (dim === '1d') {
+            return {
+                argTypes: args,
+                returnType: u32,
+            };
+        }
+        if (dim === '3d') {
+            return {
+                argTypes: args,
+                returnType: vec3u,
+            };
+        }
+        return {
+            argTypes: args,
+            returnType: vec2u,
+        };
+    },
+    sideEffects: false,
 });
-const textureGatherCpu = (..._args) => {
-	throw new Error("Texture gather relies on GPU resources and cannot be executed outside of a draw call");
+export const textureGatherCpu = (..._args) => {
+    throw new Error('Texture gather relies on GPU resources and cannot be executed outside of a draw call');
 };
 const sampleTypeToVecType = {
-	f32: vec4f,
-	i32: vec4i,
-	u32: vec4u
+    f32: vec4f,
+    i32: vec4i,
+    u32: vec4u,
 };
-const textureGather = dualImpl({
-	name: "textureGather",
-	normalImpl: textureGatherCpu,
-	codegenImpl: (_ctx, args) => stitch`textureGather(${args})`,
-	signature: (...args) => {
-		if (args[0].type.startsWith("texture")) {
-			const [texture$1, sampler$1, coords$1, _$1, ...rest$1] = args;
-			return {
-				argTypes: texture$1.type === "texture_depth_2d_array" || texture$1.type === "texture_depth_cube_array" ? [
-					texture$1,
-					sampler$1,
-					coords$1,
-					[u32, i32],
-					...rest$1
-				] : args,
-				returnType: vec4f
-			};
-		}
-		const [_, texture, sampler, coords, ...rest] = args;
-		return {
-			argTypes: texture.type === "texture_2d_array" || texture.type === "texture_cube_array" ? [
-				[u32, i32],
-				texture,
-				sampler,
-				coords,
-				[u32, i32],
-				...rest
-			] : [
-				[u32, i32],
-				texture,
-				sampler,
-				coords,
-				...rest
-			],
-			returnType: sampleTypeToVecType[texture.sampleType.type]
-		};
-	}
+export const textureGather = dualImpl({
+    name: 'textureGather',
+    normalImpl: textureGatherCpu,
+    codegenImpl: (_ctx, args) => stitch `textureGather(${args})`,
+    signature: (...args) => {
+        if (args[0].type.startsWith('texture')) {
+            const [texture, sampler, coords, _, ...rest] = args;
+            const isArrayTexture = texture.type === 'texture_depth_2d_array' || texture.type === 'texture_depth_cube_array';
+            const argTypes = isArrayTexture
+                ? [texture, sampler, coords, [u32, i32], ...rest]
+                : args;
+            return { argTypes: argTypes, returnType: vec4f };
+        }
+        const [_, texture, sampler, coords, ...rest] = args;
+        const isArrayTexture = texture.type === 'texture_2d_array' || texture.type === 'texture_cube_array';
+        const argTypes = isArrayTexture
+            ? [[u32, i32], texture, sampler, coords, [u32, i32], ...rest]
+            : [[u32, i32], texture, sampler, coords, ...rest];
+        return {
+            argTypes: argTypes,
+            returnType: sampleTypeToVecType[texture.sampleType.type],
+        };
+    },
+    sideEffects: false,
 });
 function textureSampleCompareCpu(_texture, _sampler, _coords, _depthRefOrArrayIndex, _depthRefOrOffset, _maybeOffset) {
-	throw new MissingCpuImplError("Texture comparison sampling relies on GPU resources and cannot be executed outside of a draw call");
+    throw new MissingCpuImplError('Texture comparison sampling relies on GPU resources and cannot be executed outside of a draw call');
 }
-const textureSampleCompare = dualImpl({
-	name: "textureSampleCompare",
-	normalImpl: textureSampleCompareCpu,
-	codegenImpl: (_ctx, args) => stitch`textureSampleCompare(${args})`,
-	signature: (...args) => ({
-		argTypes: args,
-		returnType: f32
-	})
+export const textureSampleCompare = dualImpl({
+    name: 'textureSampleCompare',
+    normalImpl: textureSampleCompareCpu,
+    codegenImpl: (_ctx, args) => stitch `textureSampleCompare(${args})`,
+    signature: (...args) => ({
+        argTypes: args,
+        returnType: f32,
+    }),
+    sideEffects: false,
 });
 function textureSampleCompareLevelCpu(_texture, _sampler, _coords, _depthRefOrArrayIndex, _depthRefOrOffset, _maybeOffset) {
-	throw new MissingCpuImplError("Texture comparison sampling with level relies on GPU resources and cannot be executed outside of a draw call");
+    throw new MissingCpuImplError('Texture comparison sampling with level relies on GPU resources and cannot be executed outside of a draw call');
 }
-const textureSampleCompareLevel = dualImpl({
-	name: "textureSampleCompareLevel",
-	normalImpl: textureSampleCompareLevelCpu,
-	codegenImpl: (ctx, args) => stitch`textureSampleCompareLevel(${args})`,
-	signature: (...args) => ({
-		argTypes: args,
-		returnType: f32
-	})
+export const textureSampleCompareLevel = dualImpl({
+    name: 'textureSampleCompareLevel',
+    normalImpl: textureSampleCompareLevelCpu,
+    codegenImpl: (ctx, args) => stitch `textureSampleCompareLevel(${args})`,
+    signature: (...args) => ({
+        argTypes: args,
+        returnType: f32,
+    }),
+    sideEffects: false,
 });
 function textureSampleBaseClampToEdgeCpu(_texture, _sampler, _coords) {
-	throw new MissingCpuImplError("Texture sampling with base clamp to edge is not supported outside of GPU mode.");
+    throw new MissingCpuImplError('Texture sampling with base clamp to edge is not supported outside of GPU mode.');
 }
 function sampleGradCpu(_texture, _sampler, _coords, _ddxOrArrayIndex, _ddyOrDdx, _offsetOrDdy, _maybeOffset) {
-	throw new MissingCpuImplError("Texture sampling with gradients relies on GPU resources and cannot be executed outside of a draw call");
+    throw new MissingCpuImplError('Texture sampling with gradients relies on GPU resources and cannot be executed outside of a draw call');
 }
-const textureSampleGrad = dualImpl({
-	name: "textureSampleGrad",
-	normalImpl: sampleGradCpu,
-	codegenImpl: (_ctx, args) => stitch`textureSampleGrad(${args})`,
-	signature: (...args) => ({
-		argTypes: args,
-		returnType: vec4f
-	})
+export const textureSampleGrad = dualImpl({
+    name: 'textureSampleGrad',
+    normalImpl: sampleGradCpu,
+    codegenImpl: (_ctx, args) => stitch `textureSampleGrad(${args})`,
+    signature: (...args) => ({
+        argTypes: args,
+        returnType: vec4f,
+    }),
+    sideEffects: false,
 });
-const textureSampleBaseClampToEdge = dualImpl({
-	name: "textureSampleBaseClampToEdge",
-	normalImpl: textureSampleBaseClampToEdgeCpu,
-	codegenImpl: (_ctx, args) => stitch`textureSampleBaseClampToEdge(${args})`,
-	signature: (...args) => ({
-		argTypes: args,
-		returnType: vec4f
-	})
+export const textureSampleBaseClampToEdge = dualImpl({
+    name: 'textureSampleBaseClampToEdge',
+    normalImpl: textureSampleBaseClampToEdgeCpu,
+    codegenImpl: (_ctx, args) => stitch `textureSampleBaseClampToEdge(${args})`,
+    signature: (...args) => ({
+        argTypes: args,
+        returnType: vec4f,
+    }),
+    sideEffects: false,
 });
-
-//#endregion
-export { textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore };

package/taskQueue.d.ts

@@ -0,0 +1,6 @@
+export declare class TaskQueue {
+    private _queue;
+    private _pending;
+    enqueue<T>(task: () => Promise<T>): Promise<T>;
+    private _processQueue;
+}

package/taskQueue.js

@@ -0,0 +1,30 @@
+export class TaskQueue {
+    _queue = [];
+    _pending = false;
+    enqueue(task) {
+        return new Promise((resolve, reject) => {
+            this._queue.push(async () => {
+                try {
+                    resolve(await task());
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+            void this._processQueue();
+        });
+    }
+    async _processQueue() {
+        if (this._pending) {
+            return;
+        }
+        this._pending = true;
+        while (this._queue.length > 0) {
+            const task = this._queue.shift();
+            if (task) {
+                await task();
+            }
+        }
+        this._pending = false;
+    }
+}

package/tgpu.d.ts

@@ -0,0 +1,16 @@
+export { constant as const } from './core/constant/tgpuConstant.ts';
+export { fn } from './core/function/tgpuFn.ts';
+export { comptime } from './core/function/comptime.ts';
+export { resolve, resolveWithContext } from './core/resolve/tgpuResolve.ts';
+export { init, initFromDevice } from './core/root/init.ts';
+export { slot } from './core/slot/slot.ts';
+export { lazy } from './core/slot/lazy.ts';
+export { accessor, mutableAccessor } from './core/slot/accessor.ts';
+export { privateVar, workgroupVar } from './core/variable/tgpuVariable.ts';
+export { vertexLayout } from './core/vertexLayout/vertexLayout.ts';
+export { bindGroupLayout } from './tgpuBindGroupLayout.ts';
+export { computeFn } from './core/function/tgpuComputeFn.ts';
+export { fragmentFn } from './core/function/tgpuFragmentFn.ts';
+export { vertexFn } from './core/function/tgpuVertexFn.ts';
+export { unroll } from './core/unroll/tgpuUnroll.ts';
+export * as '~unstable' from './tgpuUnstable.ts';

package/tgpu.js

@@ -1,44 +1,17 @@
-import { __export } from "./_virtual/rolldown_runtime.js";
-import { comptime } from "./core/function/comptime.js";
-import { constant } from "./core/constant/tgpuConstant.js";
-import { fn } from "./core/function/tgpuFn.js";
-import { bindGroupLayout } from "./tgpuBindGroupLayout.js";
-import { slot } from "./core/slot/slot.js";
-import { privateVar, workgroupVar } from "./core/variable/tgpuVariable.js";
-import { unroll } from "./core/unroll/tgpuUnroll.js";
-import { resolve, resolveWithContext } from "./core/resolve/tgpuResolve.js";
-import { computeFn } from "./core/function/tgpuComputeFn.js";
-import { vertexLayout } from "./core/vertexLayout/vertexLayout.js";
-import { init, initFromDevice } from "./core/root/init.js";
-import { lazy } from "./core/slot/lazy.js";
-import { accessor, mutableAccessor } from "./core/slot/accessor.js";
-import { fragmentFn } from "./core/function/tgpuFragmentFn.js";
-import { vertexFn } from "./core/function/tgpuVertexFn.js";
-import { tgpuUnstable_exports } from "./tgpuUnstable.js";
-
-//#region src/tgpu.ts
-var tgpu_exports = /* @__PURE__ */ __export({
-	accessor: () => accessor,
-	bindGroupLayout: () => bindGroupLayout,
-	comptime: () => comptime,
-	computeFn: () => computeFn,
-	const: () => constant,
-	fn: () => fn,
-	fragmentFn: () => fragmentFn,
-	init: () => init,
-	initFromDevice: () => initFromDevice,
-	lazy: () => lazy,
-	mutableAccessor: () => mutableAccessor,
-	privateVar: () => privateVar,
-	resolve: () => resolve,
-	resolveWithContext: () => resolveWithContext,
-	slot: () => slot,
-	unroll: () => unroll,
-	vertexFn: () => vertexFn,
-	vertexLayout: () => vertexLayout,
-	workgroupVar: () => workgroupVar,
-	"~unstable": () => tgpuUnstable_exports
-});
-
-//#endregion
-export { tgpu_exports };
+// NOTE: This is a barrel file, internal files should not import things from this file
+export { constant as const } from "./core/constant/tgpuConstant.js";
+export { fn } from "./core/function/tgpuFn.js";
+export { comptime } from "./core/function/comptime.js";
+export { resolve, resolveWithContext } from "./core/resolve/tgpuResolve.js";
+export { init, initFromDevice } from "./core/root/init.js";
+export { slot } from "./core/slot/slot.js";
+export { lazy } from "./core/slot/lazy.js";
+export { accessor, mutableAccessor } from "./core/slot/accessor.js";
+export { privateVar, workgroupVar } from "./core/variable/tgpuVariable.js";
+export { vertexLayout } from "./core/vertexLayout/vertexLayout.js";
+export { bindGroupLayout } from "./tgpuBindGroupLayout.js";
+export { computeFn } from "./core/function/tgpuComputeFn.js";
+export { fragmentFn } from "./core/function/tgpuFragmentFn.js";
+export { vertexFn } from "./core/function/tgpuVertexFn.js";
+export { unroll } from "./core/unroll/tgpuUnroll.js";
+export * as '~unstable' from "./tgpuUnstable.js";