typegpu 0.11.6 → 0.11.8

package/tgsl/forOfUtils.js

@@ -1,7 +1,7 @@
 import { $gpuCallable } from "../shared/symbols.js";
-import { isPtr, isVec, isWgslArray } from "../data/wgslTypes.js";
+import { isNaturallyEphemeral, isPtr, isVec, isWgslArray } from "../data/wgslTypes.js";
 import { UnknownData } from "../data/dataTypes.js";
-import { isEphemeralSnippet, snip } from "../data/snippet.js";
+import { isAlias, snip } from "../data/snippet.js";
 import { WgslTypeError, invariant } from "../errors.js";
 import { stitch } from "../core/resolve/stitch.js";
 import { createPtrFromOrigin, implicitFrom } from "../data/ptr.js";
@@ -13,17 +13,20 @@ import { isTgpuRange } from "../std/range.js";
 
 //#region src/tgsl/forOfUtils.ts
 function getLoopVarKind(elementSnippet) {
-	return elementSnippet.origin === "constant-tgpu-const-ref" ? "const" : "let";
+	return elementSnippet.origin === "constant-immutable-def" ? "const" : "let";
 }
 function getElementSnippet(iterableSnippet, index) {
 	const elementSnippet = accessIndex(iterableSnippet, index);
 	if (!elementSnippet) throw new WgslTypeError("`for ... of ...` loops only support array or vector iterables");
 	return elementSnippet;
 }
+/**
+* Determines the type of the element as accessible inside of the `for .. of` loop body
+*/
 function getElementType(elementSnippet, iterableSnippet) {
 	let elementType = elementSnippet.dataType;
 	if (elementType === UnknownData) throw new WgslTypeError(stitch`The elements in iterable ${iterableSnippet} are of unknown type`);
-	if (isEphemeralSnippet(elementSnippet) || elementSnippet.origin === "constant-tgpu-const-ref" || elementSnippet.origin === "runtime-tgpu-const-ref") return elementType;
+	if (isNaturallyEphemeral(elementSnippet.dataType) || elementSnippet.origin === "runtime" || elementSnippet.origin === "constant" || elementSnippet.origin === "constant-immutable-def" || elementSnippet.origin === "runtime-immutable-def") return elementType;
 	if (!isPtr(elementType)) {
 		const ptrType = createPtrFromOrigin(elementSnippet.origin, concretize(elementType));
 		invariant(ptrType !== void 0, `Creating pointer type from origin ${elementSnippet.origin}`);
@@ -47,7 +50,7 @@ function getRangeSnippets(ctx, iterableSnippet, unroll = false) {
 			comparison: step < 0 ? ">" : "<"
 		};
 	}
-	if (!unroll && isEphemeralSnippet(iterableSnippet)) throw new Error(`\`for ... of ...\` loops only support std.range or iterables stored in variables.
+	if (!unroll && !isAlias(iterableSnippet)) throw new Error(`\`for ... of ...\` loops only support std.range or iterables stored in variables.
 -----
 You can wrap iterable with \`tgpu.unroll(...)\`. If iterable is known at comptime, the loop will be unrolled.
 -----`);

package/tgsl/generationHelpers.js

@@ -1,21 +1,20 @@
 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 { isAlias, 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 (value >= 2 ** 63 || value < -(2 ** 63)) return snip(value, abstractFloat, "constant", false);
 	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, abstractInt, "constant", false);
 	}
-	return snip(value, abstractFloat, "constant");
+	return snip(value, abstractFloat, "constant", false);
 }
 function concretize(type) {
 	if (type.type === "abstractFloat") return f32;
@@ -30,11 +29,11 @@ function coerceToSnippet(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 (isVecInstance(value) || isMatInstance(value)) return snip(value, WORKAROUND_getSchema(value), "constant", false);
+	if (typeof value === "string" || typeof value === "function" || typeof value === "object" || typeof value === "symbol" || typeof value === "undefined" || value === null) return snip(value, UnknownData, "constant", false);
 	if (typeof value === "number") return numericLiteralToSnippet(value);
-	if (typeof value === "boolean") return snip(value, bool, "constant");
-	return snip(value, UnknownData, "constant");
+	if (typeof value === "boolean") return snip(value, bool, "constant", false);
+	return snip(value, UnknownData, "constant", false);
 }
 /**
 * Intermediate representation for WGSL array expressions.
@@ -53,12 +52,12 @@ var ArrayExpression = class {
 		return "ArrayExpression";
 	}
 	[$resolve](ctx) {
-		for (const elem of this.elements) if (elem.origin === "argument" && !isNaturallyEphemeral(elem.dataType) || !isEphemeralSnippet(elem)) {
+		for (const elem of this.elements) if (isAlias(elem) && !isNaturallyEphemeral(elem.dataType)) {
 			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");
+		return ctx.gen.typeInstantiation(this.type, this.elements);
 	}
 };
 

package/tgsl/infixDispatch.js

@@ -0,0 +1,53 @@
+import { inCodegenMode } from "../execMode.js";
+import { add, bitShiftLeft, bitShiftRight, div, mod, mul, sub } from "../std/operators.js";
+
+//#region src/tgsl/infixDispatch.ts
+const infixOperators = {
+	add,
+	sub,
+	mul,
+	div,
+	mod,
+	bitShiftLeft,
+	bitShiftRight
+};
+/**
+* InfixDispatch is only used in codegen mode.
+* `lhs` may either be Numeric or Snippet.
+* @example
+* const external = d.vec2u(1);
+* const fn = () => {
+*    'use gpu';
+*    external.mul(2); // lhs is Numeric
+*    d.vec2u(1).mul(2) // lhs is a snippet
+* }
+*/
+var InfixDispatch = class {
+	lhs;
+	operator;
+	constructor(lhs, operator) {
+		this.lhs = lhs;
+		this.operator = operator;
+	}
+};
+function isInfixDispatch(o) {
+	return o instanceof InfixDispatch;
+}
+/**
+* This function is used on vec/mat prototypes.
+* This is done in runtime in order to avoid a circular dependency.
+*/
+function assignInfixOperator(base, operator, operatorSymbol) {
+	const opImpl = infixOperators[operator];
+	Object.defineProperty(base.prototype, operatorSymbol, { value: opImpl });
+	function jsInfixDispatchFor(arg) {
+		return opImpl(this, arg);
+	}
+	Object.defineProperty(base.prototype, operator, { get() {
+		if (inCodegenMode()) return new InfixDispatch(this, opImpl);
+		return jsInfixDispatchFor;
+	} });
+}
+
+//#endregion
+export { InfixDispatch, assignInfixOperator, infixOperators, isInfixDispatch };

package/tgsl/shaderGenerator.d.ts

@@ -1,6 +1,6 @@
 import { ResolvedSnippet, Snippet } from "../data/snippet.js";
 import { GenerationCtx } from "./generationHelpers.js";
-import { FunctionDefinitionOptions } from "./shaderGenerator_members.js";
+import { ConstantDefinitionOptions, FunctionDefinitionOptions, VariableDefinitionOptions } from "./shaderGenerator_members.js";
 import { BaseData } from "../data/wgslTypes.js";
 
 //#region src/tgsl/shaderGenerator.d.ts
@@ -13,9 +13,12 @@ import { BaseData } from "../data/wgslTypes.js";
  */
 interface ShaderGenerator {
   initGenerator(ctx: GenerationCtx): void;
+  declareGlobalConst(options: ConstantDefinitionOptions): ResolvedSnippet;
+  declareGlobalVar(options: VariableDefinitionOptions): ResolvedSnippet;
   functionDefinition(options: FunctionDefinitionOptions): string;
   typeInstantiation(schema: BaseData, args: readonly Snippet[]): ResolvedSnippet;
   typeAnnotation(schema: BaseData): string;
+  numericLiteral(value: number, schema: BaseData): ResolvedSnippet;
 }
 //#endregion
 export { ShaderGenerator };

package/tgsl/shaderGenerator_members.d.ts

@@ -1,15 +1,33 @@
+import "../shared/meta.js";
 import { Origin, Snippet } from "../data/snippet.js";
-import { FunctionArgument, ResolutionCtx, TgpuShaderStage } from "../types.js";
+import { VariableScope } from "../core/variable/tgpuVariable.js";
+import { BindableBufferUsage, FunctionArgument, ResolutionCtx, TgpuShaderStage } from "../types.js";
 import { BaseData } from "../data/wgslTypes.js";
 import { UnknownData } from "../data/dataTypes.js";
 import { Block } from "tinyest";
 
 //#region src/tgsl/shaderGenerator_members.d.ts
+
 interface FunctionDefinitionOptions {
   readonly functionType: 'normal' | TgpuShaderStage;
+  readonly name: string;
+  readonly workgroupSize?: readonly number[] | undefined;
   readonly args: readonly FunctionArgument[];
   readonly body: Block;
   determineReturnType(): BaseData;
 }
+interface ConstantDefinitionOptions {
+  readonly id: string;
+  readonly dataType: BaseData;
+  readonly init: Snippet;
+}
+interface VariableDefinitionOptions {
+  readonly scope: VariableScope | BindableBufferUsage | 'handle';
+  readonly id: string;
+  readonly dataType: BaseData;
+  readonly init: Snippet | undefined;
+  readonly group?: string | undefined;
+  readonly binding?: number | undefined;
+}
 //#endregion
-export { FunctionDefinitionOptions };
+export { ConstantDefinitionOptions, FunctionDefinitionOptions, VariableDefinitionOptions };

package/tgsl/shaderGenerator_members.js

@@ -1,8 +1,12 @@
 import { __export } from "../_virtual/rolldown_runtime.js";
+import { getName } from "../shared/meta.js";
 import { UnknownData } from "../data/dataTypes.js";
 
 //#region src/tgsl/shaderGenerator_members.ts
-var shaderGenerator_members_exports = /* @__PURE__ */ __export({ UnknownData: () => UnknownData });
+var shaderGenerator_members_exports = /* @__PURE__ */ __export({
+	UnknownData: () => UnknownData,
+	getName: () => getName
+});
 
 //#endregion
 export { shaderGenerator_members_exports };

package/tgsl/shellless.js

@@ -1,5 +1,5 @@
-import { getMetaData, getName } from "../shared/meta.js";
 import { isPtr, isWgslArray, isWgslStruct } from "../data/wgslTypes.js";
+import { getFunctionMetadata, getName } from "../shared/meta.js";
 import { UnknownData } from "../data/dataTypes.js";
 import { WgslTypeError } from "../errors.js";
 import { RefOperator } from "../data/ref.js";
@@ -17,15 +17,15 @@ function shallowEqualSchemas(a, b) {
 var ShelllessRepository = class {
 	cache = /* @__PURE__ */ new Map();
 	get(fn, argSnippets) {
-		const meta = getMetaData(fn);
-		if (!meta?.ast) return void 0;
+		const meta = getFunctionMetadata(fn);
+		if (!meta) return;
 		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.`);
+			if (s.dataType === UnknownData) throw new Error(`Passed illegal value ${s.value} as the #${index} argument to ${getName(fn) ?? "<unnamed>"}(...)\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 (isPtr(type) && type.implicit) type = type.inner;
 			return type;

package/tgsl/wgslGenerator.d.ts

@@ -1,6 +1,6 @@
-import { Origin, ResolvedSnippet, Snippet } from "../data/snippet.js";
+import { ResolvedSnippet, Snippet } from "../data/snippet.js";
 import { GenerationCtx } from "./generationHelpers.js";
-import { FunctionDefinitionOptions } from "./shaderGenerator_members.js";
+import { ConstantDefinitionOptions, FunctionDefinitionOptions, VariableDefinitionOptions } from "./shaderGenerator_members.js";
 import { ShaderGenerator } from "./shaderGenerator.js";
 import { BaseData, StorableData } from "../data/wgslTypes.js";
 import { UnknownData } from "../data/dataTypes.js";
@@ -12,22 +12,23 @@ declare class WgslGenerator implements ShaderGenerator {
   #private;
   initGenerator(ctx: GenerationCtx): void;
   protected get ctx(): GenerationCtx;
-  _block([_, statements]: tinyest.Block, externalMap?: ExternalMap): string;
-  _blockStatement(block: tinyest.Block, externalMap?: ExternalMap): string;
+  protected _block([_, statements]: tinyest.Block, externalMap?: ExternalMap): string;
+  protected _blockStatement(block: tinyest.Block, externalMap?: ExternalMap): string;
   refVariable(id: string, dataType: StorableData): string;
-  blockVariable(varType: 'var' | 'let' | 'const' | '<deferred>', id: string, dataType: BaseData | UnknownData, origin: Origin): Snippet;
   /**
    * Creates a variable declaration string.
    * `keyword` may be a placeholder filled in later.
    */
-  protected emitVarDecl(pre: string, keyword: 'var' | 'let' | 'const' | `#VAR_${number}#`, name: string, _dataType: BaseData | UnknownData, rhsStr: string): string;
-  _identifier(id: string): Snippet;
+  protected _emitVarDecl(keyword: 'var' | 'let' | 'const' | `#VAR_${number}#`, name: string, _dataType: BaseData | UnknownData, rhsStr: string): string;
+  protected _identifier(id: string): Snippet;
   /**
    * A wrapper for `generateExpression` that updates `ctx.expectedType`
    * and tries to convert the result when it does not match the expected type.
    */
-  _typedExpression(expression: tinyest.Expression, expectedType: BaseData | BaseData[]): Snippet;
-  _expression(expression: tinyest.Expression): Snippet;
+  protected _typedExpression(expression: tinyest.Expression, expectedType: BaseData | BaseData[]): Snippet;
+  protected _expression(expression: tinyest.Expression): Snippet;
+  declareGlobalConst(options: ConstantDefinitionOptions): ResolvedSnippet;
+  declareGlobalVar(options: VariableDefinitionOptions): ResolvedSnippet;
   functionDefinition(options: FunctionDefinitionOptions): string;
   /**
    * Generates a WGSL type string for the given data type, and adds necessary
@@ -36,8 +37,11 @@ declare class WgslGenerator implements ShaderGenerator {
    */
   typeAnnotation(data: BaseData): string;
   typeInstantiation(schema: BaseData, args: readonly Snippet[]): ResolvedSnippet;
-  _return(statement: tinyest.Return): string;
-  _statement(statement: tinyest.Statement): string;
+  numericLiteral(value: number, schema: BaseData): ResolvedSnippet;
+  protected _return(statement: tinyest.Return): string;
+  protected _letStatement(statement: tinyest.Let): string;
+  protected _constStatement(statement: tinyest.Const): string;
+  protected _statement(statement: tinyest.Statement): string;
   /**
    * Attempts a member access lookup to mark a variable as modified.
    * @example