typegpu 0.10.1 → 0.11.0-rc.1

package/data/wgslTypes.js

@@ -0,0 +1,222 @@
+import { $internal, isMarkedInternal } from "../shared/symbols.js";
+import "tsover-runtime";
+//#region src/data/wgslTypes.ts
+const Void = {
+	[$internal]: {},
+	type: "void",
+	toString() {
+		return "void";
+	}
+};
+const wgslTypeLiterals = [
+	"bool",
+	"f32",
+	"f16",
+	"i32",
+	"u32",
+	"u16",
+	"vec2f",
+	"vec2h",
+	"vec2i",
+	"vec2u",
+	"vec2<bool>",
+	"vec3f",
+	"vec3h",
+	"vec3i",
+	"vec3u",
+	"vec3<bool>",
+	"vec4f",
+	"vec4h",
+	"vec4i",
+	"vec4u",
+	"vec4<bool>",
+	"mat2x2f",
+	"mat3x3f",
+	"mat4x4f",
+	"struct",
+	"array",
+	"ptr",
+	"atomic",
+	"decorated",
+	"abstractInt",
+	"abstractFloat",
+	"void",
+	"texture_1d",
+	"texture_storage_1d",
+	"texture_2d",
+	"texture_storage_2d",
+	"texture_multisampled_2d",
+	"texture_depth_2d",
+	"texture_depth_multisampled_2d",
+	"texture_2d_array",
+	"texture_storage_2d_array",
+	"texture_depth_2d_array",
+	"texture_cube",
+	"texture_depth_cube",
+	"texture_cube_array",
+	"texture_depth_cube_array",
+	"texture_3d",
+	"texture_storage_3d",
+	"texture_external",
+	"sampler",
+	"sampler_comparison"
+];
+function isVecInstance(value) {
+	const v = value;
+	return isMarkedInternal(v) && typeof v.kind === "string" && v.kind.startsWith("vec");
+}
+function isVec2(value) {
+	const v = value;
+	return isMarkedInternal(v) && typeof v.type === "string" && v.type.startsWith("vec2");
+}
+function isVec3(value) {
+	const v = value;
+	return isMarkedInternal(v) && typeof v.type === "string" && v.type.startsWith("vec3");
+}
+function isVec4(value) {
+	const v = value;
+	return isMarkedInternal(v) && typeof v.type === "string" && v.type.startsWith("vec4");
+}
+function isVec(value) {
+	return isVec2(value) || isVec3(value) || isVec4(value);
+}
+function isVecBool(value) {
+	return isVec(value) && value.type.includes("b");
+}
+function isMatInstance(value) {
+	const v = value;
+	return isMarkedInternal(v) && typeof v.kind?.startsWith === "function" && v.kind.startsWith("mat");
+}
+function isMat2x2f(value) {
+	return isMarkedInternal(value) && value?.type === "mat2x2f";
+}
+function isMat3x3f(value) {
+	return isMarkedInternal(value) && value?.type === "mat3x3f";
+}
+function isMat4x4f(value) {
+	return isMarkedInternal(value) && value?.type === "mat4x4f";
+}
+function isMat(value) {
+	return isMat2x2f(value) || isMat3x3f(value) || isMat4x4f(value);
+}
+function isFloat32VecInstance(element) {
+	return isVecInstance(element) && [
+		"vec2f",
+		"vec3f",
+		"vec4f"
+	].includes(element.kind);
+}
+function isInteger32VecInstance(value) {
+	return isVecInstance(value) && /[iu]$/.test(value.kind);
+}
+function isUint32VecInstance(value) {
+	return isVecInstance(value) && /[u]$/.test(value.kind);
+}
+function isWgslData(value) {
+	return isMarkedInternal(value) && wgslTypeLiterals.includes(value?.type);
+}
+/**
+* Checks whether passed in value is an array schema,
+* as opposed to, e.g., a disarray schema.
+*
+* Array schemas can be used to describe uniform and storage buffers,
+* whereas disarray schemas cannot.
+*
+* @example
+* isWgslArray(d.arrayOf(d.u32, 4)) // true
+* isWgslArray(d.disarray(d.u32, 4)) // false
+* isWgslArray(d.vec3f) // false
+*/
+function isWgslArray(schema) {
+	return isMarkedInternal(schema) && schema?.type === "array";
+}
+/**
+* Checks whether passed in value is a struct schema,
+* as opposed to, e.g., an unstruct schema.
+*
+* Struct schemas can be used to describe uniform and storage buffers,
+* whereas unstruct schemas cannot.
+*
+* @example
+* isWgslStruct(d.struct({ a: d.u32 })) // true
+* isWgslStruct(d.unstruct({ a: d.u32 })) // false
+* isWgslStruct(d.vec3f) // false
+*/
+function isWgslStruct(schema) {
+	return isMarkedInternal(schema) && schema?.type === "struct";
+}
+/**
+* Checks whether passed in value is a pointer schema.
+*
+* @example
+* isPtr(d.ptrFn(d.f32)) // true
+* isPtr(d.ptrPrivate(d.f32)) // true
+* isPtr(d.f32) // false
+*/
+function isPtr(schema) {
+	return isMarkedInternal(schema) && schema?.type === "ptr";
+}
+/**
+* Checks whether the passed in value is an atomic schema.
+*
+* @example
+* isAtomic(d.atomic(d.u32)) // true
+* isAtomic(d.u32) // false
+*/
+function isAtomic(schema) {
+	return isMarkedInternal(schema) && schema?.type === "atomic";
+}
+function isAlignAttrib(value) {
+	return isMarkedInternal(value) && value?.type === "@align";
+}
+function isSizeAttrib(value) {
+	return isMarkedInternal(value) && value?.type === "@size";
+}
+function isLocationAttrib(value) {
+	return isMarkedInternal(value) && value?.type === "@location";
+}
+function isInterpolateAttrib(value) {
+	return isMarkedInternal(value) && value?.type === "@interpolate";
+}
+function isBuiltinAttrib(value) {
+	return isMarkedInternal(value) && value?.type === "@builtin";
+}
+function isDecorated(value) {
+	return isMarkedInternal(value) && value?.type === "decorated";
+}
+function isVoid(value) {
+	return isMarkedInternal(value) && value.type === "void";
+}
+function isBool(value) {
+	return isMarkedInternal(value) && value.type === "bool";
+}
+function isNumericSchema(schema) {
+	const type = schema?.type;
+	return isMarkedInternal(schema) && (type === "abstractInt" || type === "abstractFloat" || type === "f32" || type === "f16" || type === "i32" || type === "u32");
+}
+function isHalfPrecisionSchema(schema) {
+	const type = schema?.type;
+	return isMarkedInternal(schema) && (type === "f16" || type === "vec2h" || type === "vec3h" || type === "vec4h");
+}
+const ephemeralTypes = [
+	"abstractInt",
+	"abstractFloat",
+	"f32",
+	"f16",
+	"i32",
+	"u32",
+	"bool"
+];
+/**
+* Returns true for schemas that are not naturally referential in JS (primitives).
+* @param schema
+* @returns
+*/
+function isNaturallyEphemeral(schema) {
+	return !isMarkedInternal(schema) || ephemeralTypes.includes(schema?.type);
+}
+function WORKAROUND_getSchema(vec) {
+	return vec.schema;
+}
+//#endregion
+export { Void, WORKAROUND_getSchema, isAlignAttrib, isAtomic, isBool, isBuiltinAttrib, isDecorated, isFloat32VecInstance, isHalfPrecisionSchema, isInteger32VecInstance, isInterpolateAttrib, isLocationAttrib, isMat, isMat2x2f, isMat3x3f, isMatInstance, isNaturallyEphemeral, isNumericSchema, isPtr, isSizeAttrib, isUint32VecInstance, isVec, isVecBool, isVecInstance, isVoid, isWgslArray, isWgslData, isWgslStruct };

package/errors.d.ts

@@ -0,0 +1,44 @@
+import { TgpuSlot } from "./core/slot/slotTypes.js";
+import { TgpuVertexLayout } from "./core/vertexLayout/vertexLayout.js";
+import { TgpuBindGroupLayout } from "./tgpuBindGroupLayout.js";
+import { TgpuBuffer } from "./core/buffer/buffer.js";
+import { BaseData } from "./data/wgslTypes.js";
+
+//#region src/errors.d.ts
+/**
+ * An error that happens during resolution of WGSL code.
+ * Contains a trace of all ancestor resolvables in
+ * which this error originated.
+ *
+ * @category Errors
+ */
+declare class ResolutionError extends Error {
+  readonly cause: unknown;
+  readonly trace: unknown[];
+  constructor(cause: unknown, trace: unknown[]);
+  appendToTrace(ancestor: unknown): ResolutionError;
+}
+/**
+ * @category Errors
+ */
+declare class MissingSlotValueError extends Error {
+  readonly slot: TgpuSlot<unknown>;
+  constructor(slot: TgpuSlot<unknown>);
+}
+/**
+ * @category Errors
+ */
+declare class NotUniformError extends Error {
+  constructor(value: TgpuBuffer<BaseData>);
+}
+declare class MissingLinksError extends Error {
+  constructor(fnLabel: string | undefined, externalNames: string[]);
+}
+declare class MissingBindGroupsError extends Error {
+  constructor(layouts: Iterable<TgpuBindGroupLayout>);
+}
+declare class MissingVertexBuffersError extends Error {
+  constructor(layouts: Iterable<TgpuVertexLayout>);
+}
+//#endregion
+export { MissingBindGroupsError, MissingLinksError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, ResolutionError };

package/errors.js

@@ -0,0 +1,131 @@
+import { DEV, TEST } from "./shared/env.js";
+import { getName, hasTinyestMetadata } from "./shared/meta.js";
+//#region src/errors.ts
+const prefix = "Invariant failed";
+/**
+* Inspired by: https://github.com/alexreardon/tiny-invariant/blob/master/src/tiny-invariant.ts
+*/
+function invariant(condition, message) {
+	if (condition) return;
+	if (!DEV && !TEST) throw new Error(prefix);
+	const provided = typeof message === "function" ? message() : message;
+	const value = provided ? `${prefix}: ${provided}` : prefix;
+	throw new Error(value);
+}
+/**
+* An error that happens during resolution of WGSL code.
+* Contains a trace of all ancestor resolvables in
+* which this error originated.
+*
+* @category Errors
+*/
+var ResolutionError = class ResolutionError extends Error {
+	cause;
+	trace;
+	constructor(cause, trace) {
+		let entries = trace.map((ancestor) => `- ${hasTinyestMetadata(ancestor) ? `fn*:${getName(ancestor)}` : ancestor}`);
+		if (entries.length > 20) entries = [
+			...entries.slice(0, 11),
+			"...",
+			...entries.slice(-10)
+		];
+		super(`Resolution of the following tree failed:\n${entries.join("\n")}: ${cause && typeof cause === "object" && "message" in cause ? cause.message : cause}`);
+		this.cause = cause;
+		this.trace = trace;
+		Object.setPrototypeOf(this, ResolutionError.prototype);
+	}
+	appendToTrace(ancestor) {
+		const newTrace = [ancestor, ...this.trace];
+		return new ResolutionError(this.cause, newTrace);
+	}
+};
+/**
+* An error that happens during execution of TypeGPU functions.
+* Contains a trace of all TypeGPU functions called along the way.
+*
+* @category Errors
+*/
+var ExecutionError = class ExecutionError extends Error {
+	cause;
+	trace;
+	constructor(cause, trace) {
+		let entries = trace.map((ancestor) => `- ${ancestor}`);
+		if (entries.length > 20) entries = [
+			...entries.slice(0, 11),
+			"...",
+			...entries.slice(-10)
+		];
+		super(`Execution of the following tree failed:\n${entries.join("\n")}: ${cause && typeof cause === "object" && "message" in cause ? cause.message : cause}`);
+		this.cause = cause;
+		this.trace = trace;
+		Object.setPrototypeOf(this, ExecutionError.prototype);
+	}
+	appendToTrace(ancestor) {
+		const newTrace = [ancestor, ...this.trace];
+		return new ExecutionError(this.cause, newTrace);
+	}
+};
+/**
+* @category Errors
+*/
+var MissingSlotValueError = class MissingSlotValueError extends Error {
+	slot;
+	constructor(slot) {
+		super(`Missing value for '${slot}'`);
+		this.slot = slot;
+		Object.setPrototypeOf(this, MissingSlotValueError.prototype);
+	}
+};
+/**
+* @category Errors
+*/
+var NotUniformError = class NotUniformError extends Error {
+	constructor(value) {
+		super(`Buffer '${getName(value) ?? "<unnamed>"}' is not bindable as a uniform. Use .$usage('uniform') to allow it.`);
+		Object.setPrototypeOf(this, NotUniformError.prototype);
+	}
+};
+var MissingLinksError = class MissingLinksError extends Error {
+	constructor(fnLabel, externalNames) {
+		super(`The function '${fnLabel ?? "<unnamed>"}' is missing links to the following external values: ${externalNames}.`);
+		Object.setPrototypeOf(this, MissingLinksError.prototype);
+	}
+};
+var MissingBindGroupsError = class MissingBindGroupsError extends Error {
+	constructor(layouts) {
+		super(`Missing bind groups for layouts: '${[...layouts].map((layout) => getName(layout) ?? "<unnamed>").join(", ")}'. Please provide it using pipeline.with(bindGroup).(...)`);
+		Object.setPrototypeOf(this, MissingBindGroupsError.prototype);
+	}
+};
+var MissingVertexBuffersError = class MissingVertexBuffersError extends Error {
+	constructor(layouts) {
+		super(`Missing vertex buffers for layouts: '${[...layouts].map((layout) => getName(layout) ?? "<unnamed>").join(", ")}'. Please provide it using pipeline.with(layout, buffer).(...)`);
+		Object.setPrototypeOf(this, MissingVertexBuffersError.prototype);
+	}
+};
+var IllegalVarAccessError = class IllegalVarAccessError extends Error {
+	constructor(msg) {
+		super(msg);
+		Object.setPrototypeOf(this, IllegalVarAccessError.prototype);
+	}
+};
+var IllegalBufferAccessError = class IllegalBufferAccessError extends Error {
+	constructor(msg) {
+		super(msg);
+		Object.setPrototypeOf(this, IllegalBufferAccessError.prototype);
+	}
+};
+var WgslTypeError = class WgslTypeError extends Error {
+	constructor(msg) {
+		super(msg);
+		Object.setPrototypeOf(this, WgslTypeError.prototype);
+	}
+};
+var SignatureNotSupportedError = class SignatureNotSupportedError extends Error {
+	constructor(actual, candidates) {
+		super(`Unsupported data types: ${actual.map((a) => a.type).join(", ")}. Supported types are: ${candidates.map((r) => r.type).join(", ")}.`);
+		Object.setPrototypeOf(this, SignatureNotSupportedError.prototype);
+	}
+};
+//#endregion
+export { ExecutionError, IllegalBufferAccessError, IllegalVarAccessError, MissingBindGroupsError, MissingLinksError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, ResolutionError, SignatureNotSupportedError, WgslTypeError, invariant };

package/execMode.js

@@ -0,0 +1,49 @@
+import { invariant } from "./errors.js";
+import { NormalState } from "./types.js";
+//#region src/execMode.ts
+/**
+* Used to track if the code we're currently
+* executing is inside an executing TypeGPU function.
+*
+* Helpful for providing better error messages.
+*/
+let insideTgpuFn = false;
+function provideInsideTgpuFn(callback) {
+	if (insideTgpuFn) return callback();
+	try {
+		insideTgpuFn = true;
+		return callback();
+	} finally {
+		insideTgpuFn = false;
+	}
+}
+function isInsideTgpuFn() {
+	return insideTgpuFn;
+}
+let resolutionCtx;
+function provideCtx(ctx, callback) {
+	invariant(resolutionCtx === void 0 || resolutionCtx === ctx, "Cannot nest context providers");
+	if (resolutionCtx === ctx) return callback();
+	resolutionCtx = ctx;
+	try {
+		return callback();
+	} finally {
+		resolutionCtx = void 0;
+	}
+}
+function getResolutionCtx() {
+	return resolutionCtx;
+}
+/**
+* Applicable when code is being executed outside of any
+* execution-altering APIs.
+*/
+const topLevelState = new NormalState();
+function getExecMode() {
+	return resolutionCtx?.mode ?? topLevelState;
+}
+function inCodegenMode() {
+	return resolutionCtx?.mode.type === "codegen";
+}
+//#endregion
+export { getExecMode, getResolutionCtx, inCodegenMode, isInsideTgpuFn, provideCtx, provideInsideTgpuFn, topLevelState };

package/extension.d.ts

@@ -0,0 +1,11 @@
+//#region src/extension.d.ts
+interface StorageFlag {
+  usableAsStorage: true;
+}
+/**
+ * @deprecated Use StorageFlag instead.
+ */
+type Storage = StorageFlag;
+declare function isUsableAsStorage<T>(value: T): value is T & StorageFlag;
+//#endregion
+export { Storage, StorageFlag, isUsableAsStorage };

package/extension.js

@@ -0,0 +1,16 @@
+import { getName } from "./shared/meta.js";
+//#region src/extension.ts
+function isUsableAsStorage(value) {
+	return !!value?.usableAsStorage;
+}
+/**
+* @category Errors
+*/
+var NotStorageError = class NotStorageError extends Error {
+	constructor(value) {
+		super(`Resource '${getName(value) ?? "<unnamed>"}' cannot be bound as 'storage'. Use .$usage('storage') to allow it.`);
+		Object.setPrototypeOf(this, NotStorageError.prototype);
+	}
+};
+//#endregion
+export { NotStorageError, isUsableAsStorage };

package/getGPUValue.js

@@ -0,0 +1,7 @@
+import { $gpuValueOf } from "./shared/symbols.js";
+//#region src/getGPUValue.ts
+function getGPUValue(object) {
+	return object?.[$gpuValueOf];
+}
+//#endregion
+export { getGPUValue };