typegpu 0.10.1 → 0.10.2

package/shared/repr.d.ts

@@ -0,0 +1,108 @@
+import { $gpuRepr, $gpuValueOf, $invalidSchemaReason, $memIdent, $repr, $reprPartial, $validStorageSchema, $validUniformSchema, $validVertexSchema } from "./symbols.js";
+import { Default } from "./utilityTypes.js";
+import { U16, U32, WgslArray } from "../data/wgslTypes.js";
+import { ViewDimensionToDimension } from "../core/texture/textureFormats.js";
+import { WgslStorageTexture, WgslTexture } from "../data/texture.js";
+import { TgpuTexture } from "../core/texture/texture.js";
+import { Disarray, Undecorate } from "../data/dataTypes.js";
+
+//#region src/shared/repr.d.ts
+/**
+ * Extracts the inferred representation of a resource.
+ * For inferring types as seen by the GPU, see {@link InferGPU}
+ *
+ * @example
+ * type A = Infer<F32> // => number
+ * type B = Infer<WgslArray<F32>> // => number[]
+ * type C = Infer<Atomic<U32>> // => number
+ */
+type Infer<T> = T extends {
+  readonly [$repr]: infer TRepr;
+} ? TRepr : T;
+/**
+ * Extracts a sparse/partial inferred representation of a resource.
+ * Used by the `buffer.writePartial` API.
+ *
+ * @example
+ * type A = InferPartial<F32> // => number | undefined
+ * type B = InferPartial<WgslStruct<{ a: F32 }>> // => { a?: number | undefined }
+ * type C = InferPartial<WgslArray<F32>> // => { idx: number; value: number | undefined }[] | undefined
+ */
+type InferPartial<T> = T extends {
+  readonly [$reprPartial]: infer TRepr;
+} ? TRepr : T extends {
+  readonly [$repr]: infer TRepr;
+} ? TRepr | undefined : T;
+/**
+ * Extracts the inferred representation of a resource (as seen by the GPU).
+ *
+ * @example
+ * type A = InferGPU<F32> // => number
+ * type B = InferGPU<WgslArray<F32>> // => number[]
+ * type C = InferGPU<Atomic<U32>> // => atomicU32
+ */
+type InferGPU<T> = T extends {
+  readonly [$gpuRepr]: infer TRepr;
+} ? TRepr : Infer<T>;
+type InferRecord<T extends Record<string | number | symbol, unknown>> = { [Key in keyof T]: Infer<T[Key]> };
+type InferPartialRecord<T extends Record<string | number | symbol, unknown>> = { [Key in keyof T]?: InferPartial<T[Key]> };
+type InferGPURecord<T extends Record<string | number | symbol, unknown>> = { [Key in keyof T]: InferGPU<T[Key]> };
+type GPUValueOf<T> = T extends {
+  readonly [$gpuValueOf]: infer TValue;
+} ? TValue : T;
+type MemIdentity<T> = T extends {
+  readonly [$memIdent]: infer TMemIdent;
+} ? TMemIdent : T;
+type MemIdentityRecord<T extends Record<string | number | symbol, unknown>> = { [Key in keyof T]: MemIdentity<T[Key]> };
+type IsValidStorageSchema<T> = (T extends {
+  readonly [$validStorageSchema]: true;
+} ? true : false) extends false ? false : true;
+type IsValidUniformSchema<T> = (T extends {
+  readonly [$validUniformSchema]: true;
+} ? true : false) extends false ? false : true;
+type IsValidVertexSchema<T> = (T extends {
+  readonly [$validVertexSchema]: true;
+} ? true : false) extends false ? false : true;
+/**
+ * Accepts only arrays (or disarrays) of u32 or u16.
+ */
+type IsValidIndexSchema<T> = Undecorate<T> extends WgslArray | Disarray ? Undecorate<Undecorate<T>['elementType']> extends U32 | U16 ? true : false : false;
+/**
+ * Checks if a schema can be used in a buffer at all
+ */
+type IsValidBufferSchema<T> = IsValidStorageSchema<T> | IsValidUniformSchema<T> | IsValidVertexSchema<T> | IsValidIndexSchema<T> extends false ? false : true;
+/**
+ * Validates if a texture can be used as sampled texture
+ */
+type IsValidSampledTextureUsage<TTexture extends TgpuTexture> = TTexture['usableAsSampled'] extends true ? true : {
+  readonly invalidSampled: "Texture not usable as sampled, call $usage('sampled') first";
+};
+/**
+ * Validates if a texture can be used as storage texture
+ */
+type IsValidStorageTextureUsage<TTexture extends TgpuTexture> = TTexture['usableAsStorage'] extends true ? true : {
+  readonly invalidStorage: "Texture not usable as storage, call $usage('storage') first";
+};
+/**
+ * Validates if a texture view dimension is compatible with the texture dimension
+ */
+type IsValidSubdimension<TTexture extends TgpuTexture, TSchema extends WgslTexture | WgslStorageTexture> = ViewDimensionToDimension[TSchema['dimension']] extends infer TVDim ? TVDim extends Default<TTexture['props']['dimension'], '2d'> ? true : {
+  readonly invalidViewDim: `Texture dimension '${Default<TTexture['props']['dimension'], '2d'>}' incompatible with view dimension '${TSchema['dimension']}'`;
+} : never;
+type IsValidStorageFormat<TTexture extends TgpuTexture, TSchema extends WgslStorageTexture> = TSchema['format'] extends TTexture['props']['format'] ? true : TTexture['props']['viewFormats'] extends readonly unknown[] ? TSchema['format'] extends TTexture['props']['viewFormats'][number] ? true : FormatError<TSchema, TTexture> : FormatError<TSchema, TTexture>;
+type FormatError<TSchema extends WgslStorageTexture, TTexture extends TgpuTexture> = {
+  readonly invalidFormat: `Storage texture format '${TSchema['format']}' incompatible with texture format '${TTexture['props']['format']}'`;
+};
+type IsExactly<T, U> = [T] extends [U] ? ([U] extends [T] ? true : false) : false;
+type SelfOrErrors<TSelf, T> = IsExactly<T, true> extends true ? TSelf : `(Error) ${T[Extract<keyof T, `invalid${string}`>] & string}`;
+type ValidStorageUsage<TTexture extends TgpuTexture, TSchema extends WgslStorageTexture> = IsValidStorageTextureUsage<TTexture> & IsValidSubdimension<TTexture, TSchema> & IsValidStorageFormat<TTexture, TSchema>;
+type ValidSampledUsage<TTexture extends TgpuTexture, TSchema extends WgslTexture> = IsValidSampledTextureUsage<TTexture> & IsValidSubdimension<TTexture, TSchema>;
+/**
+ * Validates texture view schema against texture usage
+ */
+type ValidateTextureViewSchema<TTexture extends TgpuTexture, TSchema extends WgslTexture | WgslStorageTexture> = TSchema extends WgslStorageTexture ? SelfOrErrors<TSchema, ValidStorageUsage<TTexture, TSchema>> : TSchema extends WgslTexture ? SelfOrErrors<TSchema, ValidSampledUsage<TTexture, TSchema>> : never;
+type ExtractInvalidSchemaError<T, TPrefix extends string = ''> = [T] extends [{
+  readonly [$invalidSchemaReason]: string;
+}] ? `${TPrefix}${T[typeof $invalidSchemaReason]}` : never;
+//#endregion
+export { ExtractInvalidSchemaError, GPUValueOf, Infer, InferGPU, InferGPURecord, InferPartial, InferPartialRecord, InferRecord, IsValidBufferSchema, IsValidIndexSchema, IsValidStorageSchema, IsValidUniformSchema, IsValidVertexSchema, MemIdentity, MemIdentityRecord, ValidateTextureViewSchema };

package/shared/stringify.js

@@ -0,0 +1,22 @@
+import { isMatInstance, isVecInstance } from "../data/wgslTypes.js";
+
+//#region src/shared/stringify.ts
+function safeStringify(item) {
+	const asString = String(item);
+	if (asString !== "[object Object]") return asString;
+	try {
+		return JSON.stringify(item);
+	} catch (error) {
+		console.error("Error parsing JSON:", error);
+		return "<invalid json>";
+	}
+}
+function niceStringify(item) {
+	if (isVecInstance(item) || isMatInstance(item)) return item.toString();
+	if (Array.isArray(item)) return `[${item.map(niceStringify).join(", ")}]`;
+	if (item && typeof item === "object") return `{ ${Object.entries(item).map(([key, value]) => `${key}: ${niceStringify(value)}`).join(", ")} }`;
+	return String(item);
+}
+
+//#endregion
+export { niceStringify, safeStringify };

package/shared/symbols.d.ts

@@ -0,0 +1,61 @@
+//#region src/shared/symbols.d.ts
+declare const $internal: unique symbol;
+/**
+ * The getter to the value of this resource, accessible on the GPU
+ */
+declare const $gpuValueOf: unique symbol;
+/**
+ * If this symbol is present, this means that getName and setName
+ * will refer to object behind this property instead.
+ */
+declare const $getNameForward: unique symbol;
+/**
+ * Marks an object with slot-value bindings
+ */
+declare const $providing: unique symbol;
+declare const $resolve: unique symbol;
+/**
+ * A way for a schema to provide casting behavior, without the need to be explicitly
+ * callable by the end-user (e.g. vertex formats)
+ */
+declare const $cast: unique symbol;
+/**
+ * Can be called on the GPU
+ */
+declare const $gpuCallable: unique symbol;
+/**
+ * Type token for the inferred (CPU & GPU) representation of a resource
+ */
+declare const $repr: unique symbol;
+/**
+ * Type token for the inferred (GPU-side) representation of a resource
+ * If present, it shadows the value of `$repr` for GPU-side inference.
+ */
+declare const $gpuRepr: unique symbol;
+/**
+ * Type token for the inferred partial representation of a resource.
+ * If present, it shadows the value of `$repr` for use in partial IO.
+ */
+declare const $reprPartial: unique symbol;
+/**
+ * Type token holding schemas that are identical in memory layout.
+ */
+declare const $memIdent: unique symbol;
+/**
+ * Type token, signaling that a schema can be used in a storage buffer.
+ */
+declare const $validStorageSchema: unique symbol;
+/**
+ * Type token, signaling that a schema can be used in a uniform buffer.
+ */
+declare const $validUniformSchema: unique symbol;
+/**
+ * Type token, signaling that a schema can be used in a vertex buffer.
+ */
+declare const $validVertexSchema: unique symbol;
+/**
+ * Type token, containing a reason for why the schema is invalid (if it is).
+ */
+declare const $invalidSchemaReason: unique symbol;
+//#endregion
+export { $cast, $getNameForward, $gpuCallable, $gpuRepr, $gpuValueOf, $internal, $invalidSchemaReason, $memIdent, $providing, $repr, $reprPartial, $resolve, $validStorageSchema, $validUniformSchema, $validVertexSchema };

package/shared/symbols.js

@@ -0,0 +1,71 @@
+import { version } from "../package.js";
+
+//#region src/shared/symbols.ts
+const $internal = Symbol(`typegpu:${version}:$internal`);
+/**
+* The getter to the value of this resource, accessible on the GPU
+*/
+const $gpuValueOf = Symbol(`typegpu:${version}:$gpuValueOf`);
+/**
+* If this symbol is present, this means that getName and setName
+* will refer to object behind this property instead.
+*/
+const $getNameForward = Symbol(`typegpu:${version}:$getNameForward`);
+/**
+* Marks an object with slot-value bindings
+*/
+const $providing = Symbol(`typegpu:${version}:$providing`);
+/**
+* Objects can provide the snippet that represents them.
+*/
+const $ownSnippet = Symbol(`typegpu:${version}:$ownSnippet`);
+const $resolve = Symbol(`typegpu:${version}:$resolve`);
+/**
+* A way for a schema to provide casting behavior, without the need to be explicitly
+* callable by the end-user (e.g. vertex formats)
+*/
+const $cast = Symbol(`typegpu:${version}:$cast`);
+/**
+* Can be called on the GPU
+*/
+const $gpuCallable = Symbol(`typegpu:${version}:$gpuCallable`);
+/**
+* Type token for the inferred (CPU & GPU) representation of a resource
+*/
+const $repr = Symbol(`typegpu:${version}:$repr`);
+/**
+* Type token for the inferred (GPU-side) representation of a resource
+* If present, it shadows the value of `$repr` for GPU-side inference.
+*/
+const $gpuRepr = Symbol(`typegpu:${version}:$gpuRepr`);
+/**
+* Type token for the inferred partial representation of a resource.
+* If present, it shadows the value of `$repr` for use in partial IO.
+*/
+const $reprPartial = Symbol(`typegpu:${version}:$reprPartial`);
+/**
+* Type token holding schemas that are identical in memory layout.
+*/
+const $memIdent = Symbol(`typegpu:${version}:$memIdent`);
+/**
+* Type token, signaling that a schema can be used in a storage buffer.
+*/
+const $validStorageSchema = Symbol(`typegpu:${version}:$invalidStorageSchema`);
+/**
+* Type token, signaling that a schema can be used in a uniform buffer.
+*/
+const $validUniformSchema = Symbol(`typegpu:${version}:$validUniformSchema`);
+/**
+* Type token, signaling that a schema can be used in a vertex buffer.
+*/
+const $validVertexSchema = Symbol(`typegpu:${version}:$validVertexSchema`);
+/**
+* Type token, containing a reason for why the schema is invalid (if it is).
+*/
+const $invalidSchemaReason = Symbol(`typegpu:${version}:$invalidSchemaReason`);
+function isMarkedInternal(value) {
+	return !!value?.[$internal];
+}
+
+//#endregion
+export { $cast, $getNameForward, $gpuCallable, $gpuValueOf, $internal, $ownSnippet, $providing, $repr, $resolve, isMarkedInternal };

package/shared/utilityTypes.d.ts

@@ -0,0 +1,29 @@
+//#region src/shared/utilityTypes.d.ts
+type Default<T, TDefault> = unknown extends T ? TDefault : T extends undefined ? TDefault : T;
+type SwapNever<T, Replacement> = [T] extends [never] ? Replacement : T;
+type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never;
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+/**
+ * Utility type that merges a partial type with defaults, where defaults are used
+ * for properties not present in the partial type.
+ */
+type WithDefaults<TPartial, TDefaults> = Omit<TDefaults, keyof TPartial> & TPartial;
+/**
+ * Removes properties from record type that extend `Prop`
+ */
+type OmitProps<T extends Record<string, unknown>, Prop> = Pick<T, { [Key in keyof T]: T[Key] extends Prop ? never : Key }[keyof T]>;
+type NullableToOptional<T> = { [K in keyof T as T[K] extends null ? K : never]?: T[K] } & { [K in keyof T as T[K] extends null ? never : K]: T[K] };
+/**
+ * The opposite of Readonly<T>
+ */
+type Mutable<T> = { -readonly [P in keyof T]: T[P] };
+/**
+ * Source: https://code.lol/post/programming/higher-kinded-types/
+ */
+type Assume<T, U> = T extends U ? T : U;
+/**
+ * Any typed array
+ */
+type TypedArray = Uint8Array | Uint16Array | Uint32Array | Int32Array | Float32Array | Float64Array;
+//#endregion
+export { Assume, Default, Mutable, NullableToOptional, OmitProps, Prettify, SwapNever, TypedArray, UnionToIntersection, WithDefaults };

package/shared/utilityTypes.js

@@ -0,0 +1,7 @@
+//#region src/shared/utilityTypes.ts
+function assertExhaustive(x, location) {
+	throw new Error(`Failed to handle ${x} at ${location}`);
+}
+
+//#endregion
+export { assertExhaustive };

package/shared/vertexFormat.d.ts

@@ -0,0 +1,70 @@
+//#region src/shared/vertexFormat.d.ts
+declare const vertexFormats: readonly ["uint8", "uint8x2", "uint8x4", "sint8", "sint8x2", "sint8x4", "unorm8", "unorm8x2", "unorm8x4", "snorm8", "snorm8x2", "snorm8x4", "uint16", "uint16x2", "uint16x4", "sint16", "sint16x2", "sint16x4", "unorm16", "unorm16x2", "unorm16x4", "snorm16", "snorm16x2", "snorm16x4", "float16", "float16x2", "float16x4", "float32", "float32x2", "float32x3", "float32x4", "uint32", "uint32x2", "uint32x3", "uint32x4", "sint32", "sint32x2", "sint32x3", "sint32x4", "unorm10-10-10-2", "unorm8x4-bgra"];
+type VertexFormat = (typeof vertexFormats)[number];
+declare const kindToDefaultFormatMap: {
+  readonly f32: "float32";
+  readonly vec2f: "float32x2";
+  readonly vec3f: "float32x3";
+  readonly vec4f: "float32x4";
+  readonly f16: "float16";
+  readonly vec2h: "float16x2";
+  readonly vec4h: "float16x4";
+  readonly u32: "uint32";
+  readonly vec2u: "uint32x2";
+  readonly vec3u: "uint32x3";
+  readonly vec4u: "uint32x4";
+  readonly i32: "sint32";
+  readonly vec2i: "sint32x2";
+  readonly vec3i: "sint32x3";
+  readonly vec4i: "sint32x4";
+};
+type KindToDefaultFormatMap = typeof kindToDefaultFormatMap;
+interface TgpuVertexAttrib<TFormat extends VertexFormat = VertexFormat> {
+  readonly format: TFormat;
+  readonly offset: number;
+}
+type AnyVertexAttribs = Record<string, TgpuVertexAttrib> | TgpuVertexAttrib;
+/**
+ * All vertex attribute formats that can be interpreted as
+ * an single or multi component u32 in a shader.
+ * https://www.w3.org/TR/webgpu/#vertex-formats
+ */
+type U32CompatibleFormats = TgpuVertexAttrib<'uint8'> | TgpuVertexAttrib<'uint8x2'> | TgpuVertexAttrib<'uint8x4'> | TgpuVertexAttrib<'uint16'> | TgpuVertexAttrib<'uint16x2'> | TgpuVertexAttrib<'uint16x4'> | TgpuVertexAttrib<'uint32'> | TgpuVertexAttrib<'uint32x2'> | TgpuVertexAttrib<'uint32x3'> | TgpuVertexAttrib<'uint32x4'>;
+/**
+ * All vertex attribute formats that can be interpreted as
+ * an single or multi component i32 in a shader.
+ * https://www.w3.org/TR/webgpu/#vertex-formats
+ */
+type I32CompatibleFormats = TgpuVertexAttrib<'sint8'> | TgpuVertexAttrib<'sint8x2'> | TgpuVertexAttrib<'sint8x4'> | TgpuVertexAttrib<'sint16'> | TgpuVertexAttrib<'sint16x2'> | TgpuVertexAttrib<'sint16x4'> | TgpuVertexAttrib<'sint32'> | TgpuVertexAttrib<'sint32x2'> | TgpuVertexAttrib<'sint32x3'> | TgpuVertexAttrib<'sint32x4'>;
+/**
+ * All vertex attribute formats that can be interpreted as
+ * an single or multi component f32 in a shader.
+ * https://www.w3.org/TR/webgpu/#vertex-formats
+ */
+type F32CompatibleFormats = TgpuVertexAttrib<'unorm8'> | TgpuVertexAttrib<'unorm8x2'> | TgpuVertexAttrib<'unorm8x4'> | TgpuVertexAttrib<'snorm8'> | TgpuVertexAttrib<'snorm8x2'> | TgpuVertexAttrib<'snorm8x4'> | TgpuVertexAttrib<'unorm16'> | TgpuVertexAttrib<'unorm16x2'> | TgpuVertexAttrib<'unorm16x4'> | TgpuVertexAttrib<'snorm16'> | TgpuVertexAttrib<'snorm16x2'> | TgpuVertexAttrib<'snorm16x4'> | TgpuVertexAttrib<'float16'> | TgpuVertexAttrib<'float16x2'> | TgpuVertexAttrib<'float16x4'> | TgpuVertexAttrib<'float32'> | TgpuVertexAttrib<'float32x2'> | TgpuVertexAttrib<'float32x3'> | TgpuVertexAttrib<'float32x4'> | TgpuVertexAttrib<'unorm10-10-10-2'> | TgpuVertexAttrib<'unorm8x4-bgra'>;
+/**
+ * All vertex attribute formats that can be interpreted as
+ * a single or multi component f16 in a shader. (same as f32 on the shader side)
+ * https://www.w3.org/TR/webgpu/#vertex-formats
+ */
+type F16CompatibleFormats = F32CompatibleFormats;
+type KindToAcceptedAttribMap = {
+  u32: U32CompatibleFormats;
+  vec2u: U32CompatibleFormats;
+  vec3u: U32CompatibleFormats;
+  vec4u: U32CompatibleFormats;
+  i32: I32CompatibleFormats;
+  vec2i: I32CompatibleFormats;
+  vec3i: I32CompatibleFormats;
+  vec4i: I32CompatibleFormats;
+  f16: F16CompatibleFormats;
+  vec2h: F16CompatibleFormats;
+  vec3h: F16CompatibleFormats;
+  vec4h: F16CompatibleFormats;
+  f32: F32CompatibleFormats;
+  vec2f: F32CompatibleFormats;
+  vec3f: F32CompatibleFormats;
+  vec4f: F32CompatibleFormats;
+};
+//#endregion
+export { AnyVertexAttribs, KindToAcceptedAttribMap, KindToDefaultFormatMap, TgpuVertexAttrib, VertexFormat };

package/shared/vertexFormat.js

@@ -0,0 +1,64 @@
+//#region src/shared/vertexFormat.ts
+const vertexFormats = [
+	"uint8",
+	"uint8x2",
+	"uint8x4",
+	"sint8",
+	"sint8x2",
+	"sint8x4",
+	"unorm8",
+	"unorm8x2",
+	"unorm8x4",
+	"snorm8",
+	"snorm8x2",
+	"snorm8x4",
+	"uint16",
+	"uint16x2",
+	"uint16x4",
+	"sint16",
+	"sint16x2",
+	"sint16x4",
+	"unorm16",
+	"unorm16x2",
+	"unorm16x4",
+	"snorm16",
+	"snorm16x2",
+	"snorm16x4",
+	"float16",
+	"float16x2",
+	"float16x4",
+	"float32",
+	"float32x2",
+	"float32x3",
+	"float32x4",
+	"uint32",
+	"uint32x2",
+	"uint32x3",
+	"uint32x4",
+	"sint32",
+	"sint32x2",
+	"sint32x3",
+	"sint32x4",
+	"unorm10-10-10-2",
+	"unorm8x4-bgra"
+];
+const kindToDefaultFormatMap = {
+	f32: "float32",
+	vec2f: "float32x2",
+	vec3f: "float32x3",
+	vec4f: "float32x4",
+	f16: "float16",
+	vec2h: "float16x2",
+	vec4h: "float16x4",
+	u32: "uint32",
+	vec2u: "uint32x2",
+	vec3u: "uint32x3",
+	vec4u: "uint32x4",
+	i32: "sint32",
+	vec2i: "sint32x2",
+	vec3i: "sint32x3",
+	vec4i: "sint32x4"
+};
+
+//#endregion
+export { kindToDefaultFormatMap, vertexFormats };

package/std/array.d.ts

@@ -0,0 +1,7 @@
+import { DualFn } from "../types.js";
+import { _ref } from "../data/ref.js";
+
+//#region src/std/array.d.ts
+declare const arrayLength: DualFn<(a: unknown[] | _ref<unknown[]>) => number>;
+//#endregion
+export { arrayLength };

package/std/array.js

@@ -0,0 +1,27 @@
+import { isPtr, isWgslArray } from "../data/wgslTypes.js";
+import { stitch } from "../core/resolve/stitch.js";
+import { ptrFn } from "../data/ptr.js";
+import { isRef } from "../data/ref.js";
+import { abstractInt, u32 } from "../data/numeric.js";
+import { dualImpl } from "../core/function/dualImpl.js";
+
+//#region src/std/array.ts
+const sizeOfPointedToArray = (dataType) => isPtr(dataType) && isWgslArray(dataType.inner) ? dataType.inner.elementCount : 0;
+const arrayLength = dualImpl({
+	name: "arrayLength",
+	signature: (arg) => {
+		const ptrArg = isPtr(arg) ? arg : ptrFn(arg);
+		return {
+			argTypes: [ptrArg],
+			returnType: sizeOfPointedToArray(ptrArg) > 0 ? abstractInt : u32
+		};
+	},
+	normalImpl: (a) => isRef(a) ? a.$.length : a.length,
+	codegenImpl(_ctx, [a]) {
+		const length = sizeOfPointedToArray(a.dataType);
+		return length > 0 ? `${length}` : stitch`arrayLength(${a})`;
+	}
+});
+
+//#endregion
+export { arrayLength };

package/std/atomic.d.ts

@@ -0,0 +1,19 @@
+import { DualFn } from "../types.js";
+import { atomicI32, atomicU32 } from "../data/wgslTypes.js";
+
+//#region src/std/atomic.d.ts
+type AnyAtomic = atomicI32 | atomicU32;
+declare const workgroupBarrier: DualFn<(...args: never[]) => unknown>;
+declare const storageBarrier: DualFn<(...args: never[]) => unknown>;
+declare const textureBarrier: DualFn<(...args: never[]) => unknown>;
+declare const atomicLoad: DualFn<(<T extends AnyAtomic>(a: T) => number)>;
+declare const atomicStore: DualFn<(<T extends AnyAtomic>(a: T, value: number) => void)>;
+declare const atomicAdd: DualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
+declare const atomicSub: DualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
+declare const atomicMax: DualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
+declare const atomicMin: DualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
+declare const atomicAnd: DualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
+declare const atomicOr: DualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
+declare const atomicXor: DualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
+//#endregion
+export { atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, storageBarrier, textureBarrier, workgroupBarrier };

package/std/atomic.js

@@ -0,0 +1,113 @@
+import { Void, isAtomic } from "../data/wgslTypes.js";
+import { stitch } from "../core/resolve/stitch.js";
+import { safeStringify } from "../shared/stringify.js";
+import { i32, u32 } from "../data/numeric.js";
+import { dualImpl } from "../core/function/dualImpl.js";
+
+//#region src/std/atomic.ts
+const workgroupBarrier = dualImpl({
+	name: "workgroupBarrier",
+	normalImpl: "workgroupBarrier is a no-op outside of CODEGEN mode.",
+	signature: {
+		argTypes: [],
+		returnType: Void
+	},
+	codegenImpl: () => "workgroupBarrier()"
+});
+const storageBarrier = dualImpl({
+	name: "storageBarrier",
+	normalImpl: "storageBarrier is a no-op outside of CODEGEN mode.",
+	signature: {
+		argTypes: [],
+		returnType: Void
+	},
+	codegenImpl: () => "storageBarrier()"
+});
+const textureBarrier = dualImpl({
+	name: "textureBarrier",
+	normalImpl: "textureBarrier is a no-op outside of CODEGEN mode.",
+	signature: {
+		argTypes: [],
+		returnType: Void
+	},
+	codegenImpl: () => "textureBarrier()"
+});
+const atomicNormalError = "Atomic operations are not supported outside of CODEGEN mode.";
+const atomicLoad = dualImpl({
+	name: "atomicLoad",
+	normalImpl: atomicNormalError,
+	signature: (a) => {
+		if (!isAtomic(a)) throw new Error(`Invalid atomic type: ${safeStringify(a)}`);
+		return {
+			argTypes: [a],
+			returnType: a.inner
+		};
+	},
+	codegenImpl: (_ctx, [a]) => stitch`atomicLoad(&${a})`
+});
+const atomicActionSignature = (a) => {
+	if (!isAtomic(a)) throw new Error(`Invalid atomic type: ${safeStringify(a)}`);
+	return {
+		argTypes: [a, a.inner.type === "u32" ? u32 : i32],
+		returnType: Void
+	};
+};
+const atomicOpSignature = (a) => {
+	if (!isAtomic(a)) throw new Error(`Invalid atomic type: ${safeStringify(a)}`);
+	const paramType = a.inner.type === "u32" ? u32 : i32;
+	return {
+		argTypes: [a, paramType],
+		returnType: paramType
+	};
+};
+const atomicStore = dualImpl({
+	name: "atomicStore",
+	normalImpl: atomicNormalError,
+	signature: atomicActionSignature,
+	codegenImpl: (_ctx, [a, value]) => stitch`atomicStore(&${a}, ${value})`
+});
+const atomicAdd = dualImpl({
+	name: "atomicAdd",
+	normalImpl: atomicNormalError,
+	signature: atomicOpSignature,
+	codegenImpl: (_ctx, [a, value]) => stitch`atomicAdd(&${a}, ${value})`
+});
+const atomicSub = dualImpl({
+	name: "atomicSub",
+	normalImpl: atomicNormalError,
+	signature: atomicOpSignature,
+	codegenImpl: (_ctx, [a, value]) => stitch`atomicSub(&${a}, ${value})`
+});
+const atomicMax = dualImpl({
+	name: "atomicMax",
+	normalImpl: atomicNormalError,
+	signature: atomicOpSignature,
+	codegenImpl: (_ctx, [a, value]) => stitch`atomicMax(&${a}, ${value})`
+});
+const atomicMin = dualImpl({
+	name: "atomicMin",
+	normalImpl: atomicNormalError,
+	signature: atomicOpSignature,
+	codegenImpl: (_ctx, [a, value]) => stitch`atomicMin(&${a}, ${value})`
+});
+const atomicAnd = dualImpl({
+	name: "atomicAnd",
+	normalImpl: atomicNormalError,
+	signature: atomicOpSignature,
+	codegenImpl: (_ctx, [a, value]) => stitch`atomicAnd(&${a}, ${value})`
+});
+const atomicOr = dualImpl({
+	name: "atomicOr",
+	normalImpl: atomicNormalError,
+	signature: atomicOpSignature,
+	codegenImpl: (_ctx, [a, value]) => stitch`atomicOr(&${a}, ${value})`
+});
+const atomicXor = dualImpl({
+	name: "atomicXor",
+	normalImpl: atomicNormalError,
+	signature: atomicOpSignature,
+	codegenImpl: (_ctx, [a, value]) => stitch`atomicXor(&${a}, ${value})`
+});
+
+//#endregion
+export { atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, storageBarrier, textureBarrier, workgroupBarrier };

package/std/bitcast.d.ts

@@ -0,0 +1,10 @@
+import { DualFn } from "../types.js";
+import { v2f, v2i, v2u, v3f, v3i, v3u, v4f, v4i, v4u } from "../data/wgslTypes.js";
+
+//#region src/std/bitcast.d.ts
+type BitcastU32toF32Overload = ((value: number) => number) & ((value: v2u) => v2f) & ((value: v3u) => v3f) & ((value: v4u) => v4f);
+declare const bitcastU32toF32: DualFn<BitcastU32toF32Overload>;
+type BitcastU32toI32Overload = ((value: number) => number) & ((value: v2u) => v2i) & ((value: v3u) => v3i) & ((value: v4u) => v4i);
+declare const bitcastU32toI32: DualFn<BitcastU32toI32Overload>;
+//#endregion
+export { bitcastU32toF32, bitcastU32toI32 };

package/std/bitcast.js

@@ -0,0 +1,43 @@
+import { isVec } from "../data/wgslTypes.js";
+import { stitch } from "../core/resolve/stitch.js";
+import { unify } from "../tgsl/conversion.js";
+import { f32, i32, u32 } from "../data/numeric.js";
+import { vec2f, vec2i, vec3f, vec3i, vec4f, vec4i } from "../data/vector.js";
+import { dualImpl } from "../core/function/dualImpl.js";
+import { bitcastU32toF32Impl, bitcastU32toI32Impl } from "../data/numberOps.js";
+import { VectorOps } from "../data/vectorOps.js";
+
+//#region src/std/bitcast.ts
+const bitcastU32toF32 = dualImpl({
+	name: "bitcastU32toF32",
+	normalImpl: ((value) => {
+		if (typeof value === "number") return bitcastU32toF32Impl(value);
+		return VectorOps.bitcastU32toF32[value.kind](value);
+	}),
+	codegenImpl: (_ctx, [n]) => stitch`bitcast<f32>(${n})`,
+	signature: (...arg) => {
+		const uargs = unify(arg, [u32]) ?? arg;
+		return {
+			argTypes: uargs,
+			returnType: isVec(uargs[0]) ? uargs[0].type === "vec2u" ? vec2f : uargs[0].type === "vec3u" ? vec3f : vec4f : f32
+		};
+	}
+});
+const bitcastU32toI32 = dualImpl({
+	name: "bitcastU32toI32",
+	normalImpl: ((value) => {
+		if (typeof value === "number") return bitcastU32toI32Impl(value);
+		return VectorOps.bitcastU32toI32[value.kind](value);
+	}),
+	codegenImpl: (_ctx, [n]) => stitch`bitcast<i32>(${n})`,
+	signature: (...arg) => {
+		const uargs = unify(arg, [u32]) ?? arg;
+		return {
+			argTypes: uargs,
+			returnType: isVec(uargs[0]) ? uargs[0].type === "vec2u" ? vec2i : uargs[0].type === "vec3u" ? vec3i : vec4i : i32
+		};
+	}
+});
+
+//#endregion
+export { bitcastU32toF32, bitcastU32toI32 };