typegpu 0.10.1 → 0.10.2

package/indexNamedExports.d.ts

@@ -0,0 +1,38 @@
+import { INTERNAL_GlobalExt } from "./shared/meta.js";
+import { Storage, StorageFlag, isUsableAsStorage } from "./extension.js";
+import { TgpuQuerySet } from "./core/querySet/querySet.js";
+import { TgpuBufferMutable, TgpuBufferReadonly, TgpuBufferUniform, isUsableAsUniform } from "./core/buffer/bufferUsage.js";
+import { TgpuMutable, TgpuReadonly, TgpuUniform, isBufferShorthand } from "./core/buffer/bufferShorthand.js";
+import { TgpuComputeFn, TgpuComputeFnShell, isTgpuComputeFn } from "./core/function/tgpuComputeFn.js";
+import { TgpuVar, VariableScope, isVariable } from "./core/variable/tgpuVariable.js";
+import { Eventual, TgpuAccessor, TgpuLazy, TgpuMutableAccessor, TgpuSlot, isAccessor, isLazy, isMutableAccessor, isSlot } from "./core/slot/slotTypes.js";
+import { TgpuComputePipeline } from "./core/pipeline/computePipeline.js";
+import { AutoFragmentIn, AutoFragmentOut, AutoVertexIn, AutoVertexOut } from "./core/function/autoIO.js";
+import { TgpuFragmentFn, TgpuFragmentFnShell, isTgpuFragmentFn } from "./core/function/tgpuFragmentFn.js";
+import { TgpuVertexFn, TgpuVertexFnShell, isTgpuVertexFn } from "./core/function/tgpuVertexFn.js";
+import { TextureProps } from "./core/texture/textureProps.js";
+import { RenderFlag, SampledFlag, isUsableAsRender, isUsableAsSampled } from "./core/texture/usageExtension.js";
+import { TgpuVertexLayout } from "./core/vertexLayout/vertexLayout.js";
+import { ColorAttachment, TgpuPrimitiveState, TgpuRenderPipeline } from "./core/pipeline/renderPipeline.js";
+import { TgpuComparisonSampler, TgpuFixedComparisonSampler, TgpuFixedSampler, TgpuSampler, isComparisonSampler, isSampler } from "./core/sampler/sampler.js";
+import { BindLayoutEntry, ExtractBindGroupInputFromLayout, LayoutEntryToInput, TgpuBindGroup, TgpuBindGroupLayout, TgpuLayoutComparisonSampler, TgpuLayoutEntry, TgpuLayoutExternalTexture, TgpuLayoutSampler, TgpuLayoutStorage, TgpuLayoutTexture, TgpuLayoutUniform } from "./tgpuBindGroupLayout.js";
+import { Configurable, TgpuGuardedComputePipeline, TgpuRoot, ValidateBufferSchema, ValidateStorageSchema, ValidateUniformSchema, WithBinding, WithCompute, WithFragment, WithVertex, Withable } from "./core/root/rootTypes.js";
+import { IndexFlag, TgpuBuffer, Uniform, UniformFlag, ValidUsagesFor, Vertex, VertexFlag, isBuffer, isUsableAsVertex } from "./core/buffer/buffer.js";
+import { TgpuDeclare } from "./core/declare/tgpuDeclare.js";
+import { TgpuFn, TgpuFnShell, TgpuGenericFn, isTgpuFn } from "./core/function/tgpuFn.js";
+import { TgpuTexture, TgpuTextureView, isTexture } from "./core/texture/texture.js";
+import { TgpuConst } from "./core/constant/tgpuConstant.js";
+import { TgpuComptime } from "./core/function/comptime.js";
+import { Namespace } from "./core/resolve/namespace.js";
+import { InitFromDeviceOptions, InitOptions } from "./core/root/init.js";
+import { RawCodeSnippetOrigin, TgpuRawCodeSnippet } from "./core/rawCodeSnippet/tgpuRawCodeSnippet.js";
+import { index_d_exports } from "./data/index.js";
+import { index_d_exports as index_d_exports$1 } from "./std/index.js";
+import { index_d_exports as index_d_exports$2 } from "./common/index.js";
+import { MissingBindGroupsError, MissingLinksError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, ResolutionError } from "./errors.js";
+
+//#region src/indexNamedExports.d.ts
+/** @deprecated Use TgpuRenderPipeline.Descriptor */
+type TgpuRenderPipelineDescriptor = TgpuRenderPipeline.Descriptor;
+//#endregion
+export { TgpuRenderPipelineDescriptor };

package/mathUtils.js

@@ -0,0 +1,13 @@
+//#region src/mathUtils.ts
+/**
+* @param value
+* @param modulo has to be power of 2
+*/
+const roundUp = (value, modulo) => {
+	const bitMask = modulo - 1;
+	const invBitMask = ~bitMask;
+	return (value & bitMask) === 0 ? value : (value & invBitMask) + modulo;
+};
+
+//#endregion
+export { roundUp };

package/memo.js

@@ -0,0 +1,22 @@
+//#region src/memo.ts
+/**
+* Caches results of the function passed in as
+* the argument to the constructor.
+*
+* If the key can be garbage collected, it will be.
+*/
+var WeakMemo = class {
+	_map = /* @__PURE__ */ new WeakMap();
+	constructor(_make) {
+		this._make = _make;
+	}
+	getOrMake(key, ...args) {
+		if (this._map.has(key)) return this._map.get(key);
+		const value = this._make(key, ...args);
+		this._map.set(key, value);
+		return value;
+	}
+};
+
+//#endregion
+export { WeakMemo };

package/nameRegistry.d.ts

@@ -0,0 +1,30 @@
+//#region src/nameRegistry.d.ts
+interface NameRegistry {
+  /**
+   * Creates a valid WGSL identifier, each guaranteed to be unique
+   * in the lifetime of a single resolution process
+   * (excluding non-global identifiers from popped scopes).
+   * Should append "_" to primer, followed by some id.
+   * @param primer Used in the generation process, makes the identifier more recognizable.
+   * @param global Whether the name should be registered in the global scope (true), or in the current function scope (false)
+   */
+  makeUnique(primer: string | undefined, global: boolean): string;
+  /**
+   * Creates a valid WGSL identifier.
+   * Renames identifiers that are WGSL reserved words.
+   * @param primer Used in the generation process.
+   *
+   * @example
+   * makeValid("notAKeyword"); // "notAKeyword"
+   * makeValid("struct"); // makeUnique("struct")
+   * makeValid("struct_1"); // makeUnique("struct_1") (to avoid potential name collisions)
+   * makeValid("_"); // ERROR (too difficult to make valid to care)
+   */
+  makeValid(primer: string): string;
+  pushFunctionScope(): void;
+  popFunctionScope(): void;
+  pushBlockScope(): void;
+  popBlockScope(): void;
+}
+//#endregion
+export { NameRegistry };

package/nameRegistry.js

@@ -0,0 +1,449 @@
+import { invariant } from "./errors.js";
+
+//#region src/nameRegistry.ts
+const bannedTokens = new Set([
+	"alias",
+	"break",
+	"case",
+	"const",
+	"const_assert",
+	"continue",
+	"continuing",
+	"default",
+	"diagnostic",
+	"discard",
+	"else",
+	"enable",
+	"false",
+	"fn",
+	"for",
+	"if",
+	"let",
+	"loop",
+	"override",
+	"requires",
+	"return",
+	"struct",
+	"switch",
+	"true",
+	"var",
+	"while",
+	"NULL",
+	"Self",
+	"abstract",
+	"active",
+	"alignas",
+	"alignof",
+	"as",
+	"asm",
+	"asm_fragment",
+	"async",
+	"attribute",
+	"auto",
+	"await",
+	"become",
+	"cast",
+	"catch",
+	"class",
+	"co_await",
+	"co_return",
+	"co_yield",
+	"coherent",
+	"column_major",
+	"common",
+	"compile",
+	"compile_fragment",
+	"concept",
+	"const_cast",
+	"consteval",
+	"constexpr",
+	"constinit",
+	"crate",
+	"debugger",
+	"decltype",
+	"delete",
+	"demote",
+	"demote_to_helper",
+	"do",
+	"dynamic_cast",
+	"enum",
+	"explicit",
+	"export",
+	"extends",
+	"extern",
+	"external",
+	"fallthrough",
+	"filter",
+	"final",
+	"finally",
+	"friend",
+	"from",
+	"fxgroup",
+	"get",
+	"goto",
+	"groupshared",
+	"highp",
+	"impl",
+	"implements",
+	"import",
+	"inline",
+	"instanceof",
+	"interface",
+	"layout",
+	"lowp",
+	"macro",
+	"macro_rules",
+	"match",
+	"mediump",
+	"meta",
+	"mod",
+	"module",
+	"move",
+	"mut",
+	"mutable",
+	"namespace",
+	"new",
+	"nil",
+	"noexcept",
+	"noinline",
+	"nointerpolation",
+	"non_coherent",
+	"noncoherent",
+	"noperspective",
+	"null",
+	"nullptr",
+	"of",
+	"operator",
+	"package",
+	"packoffset",
+	"partition",
+	"pass",
+	"patch",
+	"pixelfragment",
+	"precise",
+	"precision",
+	"premerge",
+	"priv",
+	"protected",
+	"pub",
+	"public",
+	"readonly",
+	"ref",
+	"regardless",
+	"register",
+	"reinterpret_cast",
+	"require",
+	"resource",
+	"restrict",
+	"self",
+	"set",
+	"shared",
+	"sizeof",
+	"smooth",
+	"snorm",
+	"static",
+	"static_assert",
+	"static_cast",
+	"std",
+	"subroutine",
+	"super",
+	"target",
+	"template",
+	"this",
+	"thread_local",
+	"throw",
+	"trait",
+	"try",
+	"type",
+	"typedef",
+	"typeid",
+	"typename",
+	"typeof",
+	"union",
+	"unless",
+	"unorm",
+	"unsafe",
+	"unsized",
+	"use",
+	"using",
+	"varying",
+	"virtual",
+	"volatile",
+	"wgsl",
+	"where",
+	"with",
+	"writeonly",
+	"yield",
+	"sampler",
+	"uniform",
+	"storage"
+]);
+const builtins = new Set([
+	"array",
+	"bool",
+	"f16",
+	"f32",
+	"i32",
+	"u32",
+	"mat2x2",
+	"mat2x3",
+	"mat2x4",
+	"mat3x2",
+	"mat3x3",
+	"mat3x4",
+	"mat4x2",
+	"mat4x3",
+	"mat4x4",
+	"vec2",
+	"vec3",
+	"vec4",
+	"bitcast",
+	"all",
+	"any",
+	"select",
+	"arrayLength",
+	"abs",
+	"acos",
+	"acosh",
+	"asin",
+	"asinh",
+	"atan",
+	"atanh",
+	"atan2",
+	"ceil",
+	"clamp",
+	"cos",
+	"cosh",
+	"countLeadingZeros",
+	"countOneBits",
+	"countTrailingZeros",
+	"cross",
+	"degrees",
+	"determinant",
+	"distance",
+	"dot",
+	"dot4U8Packed",
+	"dot4I8Packed",
+	"exp",
+	"exp2",
+	"extractBits",
+	"faceForward",
+	"firstLeadingBit",
+	"firstTrailingBit",
+	"floor",
+	"fma",
+	"fract",
+	"frexp",
+	"insertBits",
+	"inverseSqrt",
+	"ldexp",
+	"length",
+	"log",
+	"log2",
+	"max",
+	"min",
+	"mix",
+	"modf",
+	"normalize",
+	"pow",
+	"quantizeToF16",
+	"radians",
+	"reflect",
+	"refract",
+	"reverseBits",
+	"round",
+	"saturate",
+	"sign",
+	"sin",
+	"sinh",
+	"smoothstep",
+	"sqrt",
+	"step",
+	"tan",
+	"tanh",
+	"transpose",
+	"trunc",
+	"dpdx",
+	"dpdxCoarse",
+	"dpdxFine",
+	"dpdy",
+	"dpdyCoarse",
+	"dpdyFine",
+	"fwidth",
+	"fwidthCoarse",
+	"fwidthFine",
+	"textureDimensions",
+	"textureGather",
+	"textureGatherCompare",
+	"textureLoad",
+	"textureNumLayers",
+	"textureNumLevels",
+	"textureNumSamples",
+	"textureSample",
+	"textureSampleBias",
+	"textureSampleCompare",
+	"textureSampleCompareLevel",
+	"textureSampleGrad",
+	"textureSampleLevel",
+	"textureSampleBaseClampToEdge",
+	"textureStore",
+	"atomicLoad",
+	"atomicStore",
+	"atomicAdd",
+	"atomicSub",
+	"atomicMax",
+	"atomicMin",
+	"atomicAnd",
+	"atomicOr",
+	"atomicXor",
+	"atomicExchange",
+	"atomicCompareExchangeWeak",
+	"pack4x8snorm",
+	"pack4x8unorm",
+	"pack4xI8",
+	"pack4xU8",
+	"pack4xI8Clamp",
+	"pack4xU8Clamp",
+	"pack2x16snorm",
+	"pack2x16unorm",
+	"pack2x16float",
+	"unpack4x8snorm",
+	"unpack4x8unorm",
+	"unpack4xI8",
+	"unpack4xU8",
+	"unpack2x16snorm",
+	"unpack2x16unorm",
+	"unpack2x16float",
+	"storageBarrier",
+	"textureBarrier",
+	"workgroupBarrier",
+	"workgroupUniformLoad",
+	"subgroupAdd",
+	"subgroupExclusiveAdd",
+	"subgroupInclusiveAdd",
+	"subgroupAll",
+	"subgroupAnd",
+	"subgroupAny",
+	"subgroupBallot",
+	"subgroupBroadcast",
+	"subgroupBroadcastFirst",
+	"subgroupElect",
+	"subgroupMax",
+	"subgroupMin",
+	"subgroupMul",
+	"subgroupExclusiveMul",
+	"subgroupInclusiveMul",
+	"subgroupOr",
+	"subgroupShuffle",
+	"subgroupShuffleDown",
+	"subgroupShuffleUp",
+	"subgroupShuffleXor",
+	"subgroupXor",
+	"quadBroadcast",
+	"quadSwapDiagonal",
+	"quadSwapX",
+	"quadSwapY"
+]);
+function sanitizePrimer(primer) {
+	if (primer) return primer.replaceAll(/\s/g, "_").replaceAll(/[^\w\d]/g, "");
+	return "item";
+}
+/**
+* A function for checking whether an identifier needs renaming.
+* Throws if provided with an invalid identifier that cannot be easily renamed.
+* @example
+* isValidIdentifier("ident"); // true
+* isValidIdentifier("struct"); // false
+* isValidIdentifier("struct_1"); // false
+* isValidIdentifier("_"); // ERROR
+* isValidIdentifier("my variable"); // ERROR
+*/
+function isValidIdentifier(ident) {
+	if (ident === "_" || ident.startsWith("__") || /\s/.test(ident)) throw new Error(`Invalid identifier '${ident}'. Choose an identifier without whitespaces or leading underscores.`);
+	const prefix = ident.split("_")[0];
+	return !bannedTokens.has(prefix) && !builtins.has(prefix);
+}
+/**
+* Same as `isValidIdentifier`, except does not check for builtin clashes.
+*/
+function isValidProp(ident) {
+	if (ident === "_" || ident.startsWith("__") || /\s/.test(ident)) throw new Error(`Invalid identifier '${ident}'. Choose an identifier without whitespaces or leading underscores.`);
+	const prefix = ident.split("_")[0];
+	return !bannedTokens.has(prefix);
+}
+var NameRegistryImpl = class {
+	#usedNames;
+	#scopeStack;
+	constructor() {
+		this.#usedNames = new Set([...bannedTokens, ...builtins]);
+		this.#scopeStack = [];
+	}
+	get #usedBlockScopeNames() {
+		return this.#scopeStack[this.#scopeStack.length - 1]?.usedBlockScopeNames;
+	}
+	makeUnique(primer, global) {
+		const sanitizedPrimer = sanitizePrimer(primer);
+		const name = this.getUniqueVariant(sanitizedPrimer);
+		if (global) this.#usedNames.add(name);
+		else this.#usedBlockScopeNames?.add(name);
+		return name;
+	}
+	#isUsedInBlocksBefore(name) {
+		const functionScopeIndex = this.#scopeStack.findLastIndex((scope) => scope.type === "functionScope");
+		return this.#scopeStack.slice(functionScopeIndex + 1).some((scope) => scope.usedBlockScopeNames.has(name));
+	}
+	makeValid(primer) {
+		if (isValidIdentifier(primer) && !this.#usedNames.has(primer) && !this.#isUsedInBlocksBefore(primer)) {
+			this.#usedBlockScopeNames?.add(primer);
+			return primer;
+		}
+		return this.makeUnique(primer, false);
+	}
+	isUsed(name) {
+		return this.#usedNames.has(name) || this.#isUsedInBlocksBefore(name);
+	}
+	pushFunctionScope() {
+		this.#scopeStack.push({ type: "functionScope" });
+		this.#scopeStack.push({
+			type: "blockScope",
+			usedBlockScopeNames: /* @__PURE__ */ new Set()
+		});
+	}
+	popFunctionScope() {
+		const functionScopeIndex = this.#scopeStack.findLastIndex((scope) => scope.type === "functionScope");
+		if (functionScopeIndex === -1) throw new Error("Tried to pop function scope when no scope was present.");
+		this.#scopeStack.splice(functionScopeIndex);
+	}
+	pushBlockScope() {
+		this.#scopeStack.push({
+			type: "blockScope",
+			usedBlockScopeNames: /* @__PURE__ */ new Set()
+		});
+	}
+	popBlockScope() {
+		invariant(this.#scopeStack[this.#scopeStack.length - 1]?.type === "blockScope", "Tried to pop block scope, but it is not present");
+		this.#scopeStack.pop();
+	}
+};
+var RandomNameRegistry = class extends NameRegistryImpl {
+	#lastUniqueId = 0;
+	getUniqueVariant(base) {
+		let name = `${base}_${this.#lastUniqueId++}`;
+		while (this.isUsed(name)) name = `${base}_${this.#lastUniqueId++}`;
+		return name;
+	}
+};
+var StrictNameRegistry = class extends NameRegistryImpl {
+	getUniqueVariant(base) {
+		let index = 0;
+		let name = base;
+		while (this.isUsed(name)) {
+			index++;
+			name = `${base}_${index}`;
+		}
+		return name;
+	}
+};
+
+//#endregion
+export { RandomNameRegistry, StrictNameRegistry, isValidProp };

package/package.js

@@ -0,0 +1,5 @@
+//#region package.json
+var version = "0.10.2";
+
+//#endregion
+export { version };

package/package.json

@@ -1,10 +1,29 @@
 {
   "name": "typegpu",
+  "version": "0.10.2",
   "private": false,
-  "version": "0.10.1",
   "description": "A thin layer between JS and WebGPU/WGSL that improves development experience and allows for faster iteration.",
+  "keywords": [
+    "compute",
+    "gpgpu",
+    "shader",
+    "shaders",
+    "typescript",
+    "webgpu",
+    "wgpu",
+    "wgsl"
+  ],
+  "homepage": "https://typegpu.com",
+  "bugs": {
+    "url": "https://github.com/software-mansion/TypeGPU/issues"
+  },
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/software-mansion/TypeGPU.git"
+  },
   "type": "module",
+  "sideEffects": false,
   "exports": {
     "./package.json": "./package.json",
     ".": {
@@ -24,33 +43,14 @@
       "default": "./common/index.js"
     }
   },
-  "sideEffects": false,
-  "engines": {
-    "node": ">=12.20.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/software-mansion/TypeGPU.git"
-  },
-  "keywords": [
-    "webgpu",
-    "wgpu",
-    "wgsl",
-    "typescript",
-    "compute",
-    "shader",
-    "shaders",
-    "gpgpu"
-  ],
-  "bugs": {
-    "url": "https://github.com/software-mansion/TypeGPU/issues"
-  },
-  "homepage": "https://typegpu.com",
   "dependencies": {
     "tinyest": "~0.3.0",
     "tsover-runtime": "^0.0.5",
     "typed-binary": "^4.3.1"
   },
+  "engines": {
+    "node": ">=12.20.0"
+  },
   "main": "./index.js",
   "types": "./index.d.ts",
   "peerDependencies": {},

package/resolutionCtx.d.ts

@@ -0,0 +1,29 @@
+import "./data/snippet.js";
+import "./tgsl/shellless.js";
+import { LogResources } from "./tgsl/consoleLog/types.js";
+import "./core/slot/slotTypes.js";
+import { TgpuBindGroup, TgpuBindGroupLayout } from "./tgpuBindGroupLayout.js";
+import "./tgsl/shaderGenerator.js";
+import "./core/root/rootTypes.js";
+import "./types.js";
+import "./data/wgslTypes.js";
+import "./data/dataTypes.js";
+import "./core/resolve/namespace.js";
+
+//#region src/resolutionCtx.d.ts
+/**
+ * The results of a WGSL resolution.
+ *
+ * @param code - The resolved code.
+ * @param usedBindGroupLayouts - List of used `tgpu.bindGroupLayout`s.
+ * @param catchall - Automatically constructed bind group for buffer usages and buffer shorthands, preceded by its index.
+ * @param logResources - Buffers and information about used console.logs needed to decode the raw data.
+ */
+interface ResolutionResult {
+  code: string;
+  usedBindGroupLayouts: TgpuBindGroupLayout[];
+  catchall: [number, TgpuBindGroup] | undefined;
+  logResources: LogResources | undefined;
+}
+//#endregion
+export { ResolutionResult };