typegpu 0.10.1 → 0.10.2

package/tgsl/generationHelpers.js

@@ -0,0 +1,67 @@
+import { $internal, $resolve } from "../shared/symbols.js";
+import { WORKAROUND_getSchema, isMatInstance, isNaturallyEphemeral, isVecInstance } from "../data/wgslTypes.js";
+import { UnknownData } from "../data/dataTypes.js";
+import { isEphemeralSnippet, isSnippet, snip } from "../data/snippet.js";
+import { WgslTypeError } from "../errors.js";
+import { getOwnSnippet } from "../types.js";
+import { stitch } from "../core/resolve/stitch.js";
+import { isRef } from "../data/ref.js";
+import { abstractFloat, abstractInt, bool, f32, i32 } from "../data/numeric.js";
+
+//#region src/tgsl/generationHelpers.ts
+function numericLiteralToSnippet(value) {
+	if (value >= 2 ** 63 || value < -(2 ** 63)) return snip(value, abstractFloat, "constant");
+	if (Number.isInteger(value)) {
+		if (!Number.isSafeInteger(value)) console.warn(`The integer ${value} exceeds the safe integer range and may have lost precision.`);
+		return snip(value, abstractInt, "constant");
+	}
+	return snip(value, abstractFloat, "constant");
+}
+function concretize(type) {
+	if (type.type === "abstractFloat") return f32;
+	if (type.type === "abstractInt") return i32;
+	return type;
+}
+function concretizeSnippet(snippet) {
+	return snip(snippet.value, concretize(snippet.dataType), snippet.origin);
+}
+function concretizeSnippets(args) {
+	return args.map(concretizeSnippet);
+}
+function coerceToSnippet(value) {
+	if (isSnippet(value)) return value;
+	if (isRef(value)) throw new Error("Cannot use refs (d.ref(...)) from the outer scope.");
+	const ownSnippet = getOwnSnippet(value);
+	if (ownSnippet) return ownSnippet;
+	if (isVecInstance(value) || isMatInstance(value)) return snip(value, WORKAROUND_getSchema(value), "constant");
+	if (typeof value === "string" || typeof value === "function" || typeof value === "object" || typeof value === "symbol" || typeof value === "undefined" || value === null) return snip(value, UnknownData, "constant");
+	if (typeof value === "number") return numericLiteralToSnippet(value);
+	if (typeof value === "boolean") return snip(value, bool, "constant");
+	return snip(value, UnknownData, "constant");
+}
+/**
+* Intermediate representation for WGSL array expressions.
+* Defers resolution. Stores array elements as snippets so the
+* generator can access them when needed.
+*/
+var ArrayExpression = class {
+	[$internal] = true;
+	constructor(type, elements) {
+		this.type = type;
+		this.elements = elements;
+	}
+	toString() {
+		return "ArrayExpression";
+	}
+	[$resolve](ctx) {
+		for (const elem of this.elements) if (elem.origin === "argument" && !isNaturallyEphemeral(elem.dataType) || !isEphemeralSnippet(elem)) {
+			const snippetStr = ctx.resolve(elem.value, elem.dataType).value;
+			const snippetType = ctx.resolve(concretize(elem.dataType)).value;
+			throw new WgslTypeError(`'${snippetStr}' reference cannot be used in an array constructor.\n-----\nTry '${snippetType}(${snippetStr})' or 'arrayOf(${snippetType}, count)([...])' to copy the value instead.\n-----`);
+		}
+		return snip(stitch`${`array<${ctx.resolve(this.type.elementType).value}, ${this.elements.length}>`}(${this.elements})`, this.type, "runtime");
+	}
+};
+
+//#endregion
+export { ArrayExpression, coerceToSnippet, concretize, concretizeSnippets, numericLiteralToSnippet };

package/tgsl/math.js

@@ -0,0 +1,45 @@
+import { f32 } from "../data/numeric.js";
+import { abs, acos, acosh, asin, asinh, atan, atan2, atanh, ceil, cos, cosh, countLeadingZeros, exp, floor, log, log2, max, min, pow, sign, sin, sinh, sqrt, tan, tanh, trunc } from "../std/numeric.js";
+
+//#region src/tgsl/math.ts
+const mathToStd = {
+	abs,
+	acos,
+	acosh,
+	asin,
+	asinh,
+	atan,
+	atan2,
+	atanh,
+	ceil,
+	cos,
+	cosh,
+	exp,
+	floor,
+	fround: f32,
+	clz32: countLeadingZeros,
+	trunc,
+	log,
+	log2,
+	pow,
+	sign,
+	sin,
+	sinh,
+	sqrt,
+	tan,
+	tanh,
+	max,
+	min,
+	cbrt: void 0,
+	log10: void 0,
+	log1p: void 0,
+	f16round: void 0,
+	hypot: void 0,
+	expm1: void 0,
+	random: void 0,
+	imul: void 0,
+	round: void 0
+};
+
+//#endregion
+export { mathToStd };

package/tgsl/shaderGenerator.d.ts

@@ -0,0 +1,18 @@
+import { Snippet } from "../data/snippet.js";
+import { GenerationCtx } from "./generationHelpers.js";
+import { ExternalMap } from "../core/resolve/externals.js";
+import { BaseData } from "../data/wgslTypes.js";
+import { Block, Expression, Statement } from "tinyest";
+
+//#region src/tgsl/shaderGenerator.d.ts
+interface ShaderGenerator {
+  initGenerator(ctx: GenerationCtx): void;
+  block(body: Block, externalMap?: ExternalMap): string;
+  identifier(id: string): Snippet;
+  typedExpression(expression: Expression, expectedType: BaseData): Snippet;
+  expression(expression: Expression): Snippet;
+  statement(statement: Statement): string;
+  functionDefinition(body: Block): string;
+}
+//#endregion
+export { ShaderGenerator };

package/tgsl/shellless.d.ts

@@ -0,0 +1,11 @@
+import { Snippet } from "../data/snippet.js";
+import { ShelllessImpl } from "../core/function/shelllessImpl.js";
+
+//#region src/tgsl/shellless.d.ts
+type AnyFn = (...args: never[]) => unknown;
+declare class ShelllessRepository {
+  cache: Map<AnyFn, ShelllessImpl[]>;
+  get(fn: AnyFn, argSnippets: Snippet[] | undefined): ShelllessImpl | undefined;
+}
+//#endregion
+export { ShelllessRepository };

package/tgsl/shellless.js

@@ -0,0 +1,53 @@
+import { getMetaData, getName } from "../shared/meta.js";
+import { isPtr, isWgslArray, isWgslStruct } from "../data/wgslTypes.js";
+import { UnknownData } from "../data/dataTypes.js";
+import { WgslTypeError } from "../errors.js";
+import { getResolutionCtx } from "../execMode.js";
+import { RefOperator } from "../data/ref.js";
+import { concretize } from "./generationHelpers.js";
+import { createShelllessImpl } from "../core/function/shelllessImpl.js";
+
+//#region src/tgsl/shellless.ts
+function shallowEqualSchemas(a, b) {
+	if (a.type !== b.type) return false;
+	if (isPtr(a) && isPtr(b)) return a.access === b.access && a.addressSpace === b.addressSpace && a.implicit === b.implicit && shallowEqualSchemas(a.inner, b.inner);
+	if (isWgslArray(a) && isWgslArray(b)) return a.elementCount === b.elementCount && shallowEqualSchemas(a.elementType, b.elementType);
+	if (isWgslStruct(a) && isWgslStruct(b)) return a === b;
+	return true;
+}
+var ShelllessRepository = class {
+	cache = /* @__PURE__ */ new Map();
+	get(fn, argSnippets) {
+		const meta = getMetaData(fn);
+		if (!meta?.ast) return void 0;
+		if (!argSnippets && meta.ast.params.length > 0) throw new Error(`Cannot resolve '${getName(fn)}' directly, because it expects arguments. Either call it from another function, or wrap it in a shell`);
+		const argTypes = (argSnippets ?? []).map((s, index) => {
+			if (s.value instanceof RefOperator) {
+				if (s.dataType === UnknownData) throw new WgslTypeError(`d.ref() created with primitive types must be stored in a variable before use`);
+				return s.dataType;
+			}
+			if (s.dataType === UnknownData) throw new Error(`Passed illegal value ${s.value} as the #${index} argument to ${meta.name}(...)\nShellless functions can only accept arguments representing WGSL resources: constructible WGSL types, d.refs, samplers or texture views.\nRemember, that arguments such as samplers, texture views, accessors, slots etc. should be dereferenced via '.$' first.`);
+			let type = concretize(s.dataType);
+			if (s.origin === "constant-tgpu-const-ref" || s.origin === "runtime-tgpu-const-ref") {
+				const ctx = getResolutionCtx();
+				throw new Error(`Cannot pass constant references as function arguments. Explicitly copy them by wrapping them in a schema: '${ctx.resolve(type).value}(...)'`);
+			}
+			if (isPtr(type) && type.implicit) type = type.inner;
+			return type;
+		});
+		let cache = this.cache.get(fn);
+		if (cache) {
+			const variant = cache.find((v) => v.argTypes.length === argTypes.length && v.argTypes.every((t, i) => shallowEqualSchemas(t, argTypes[i])));
+			if (variant) return variant;
+		} else {
+			cache = [];
+			this.cache.set(fn, cache);
+		}
+		const shellless = createShelllessImpl(argTypes, fn);
+		cache.push(shellless);
+		return shellless;
+	}
+};
+
+//#endregion
+export { ShelllessRepository };