typegpu 0.11.9 → 0.12.1

package/shared/vertexFormat.d.ts

@@ -1,29 +1,28 @@
-//#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";
+export 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"];
+export type VertexFormat = (typeof vertexFormats)[number];
+export 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;
+export type KindToDefaultFormatMap = typeof kindToDefaultFormatMap;
+export interface TgpuVertexAttrib<TFormat extends VertexFormat = VertexFormat> {
+    readonly format: TFormat;
+    readonly offset: number;
 }
-type AnyVertexAttribs = Record<string, TgpuVertexAttrib> | TgpuVertexAttrib;
+export type AnyVertexAttribs = Record<string, TgpuVertexAttrib> | TgpuVertexAttrib;
 /**
  * All vertex attribute formats that can be interpreted as
  * an single or multi component u32 in a shader.
@@ -48,23 +47,22 @@ type F32CompatibleFormats = TgpuVertexAttrib<'unorm8'> | TgpuVertexAttrib<'unorm
  * 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;
+export 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 };
+export {};

package/shared/vertexFormat.js

@@ -1,64 +1,61 @@
-//#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"
+export 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"
+export const kindToDefaultFormatMap = {
+    f32: 'float32',
+    vec2f: 'float32x2',
+    vec3f: 'float32x3',
+    vec4f: 'float32x4',
+    f16: 'float16',
+    vec2h: 'float16x2',
+    // vec3h has no direct equivalent in the spec
+    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

@@ -1,7 +1,2 @@
-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 };
+import { type _ref as ref } from '../data/ref.ts';
+export declare const arrayLength: import("../types.ts").DualFn<(a: unknown[] | ref<unknown[]>) => number>;

package/std/array.js

@@ -1,27 +1,22 @@
-import { isPtr, isWgslArray } from "../data/wgslTypes.js";
-import { stitch } from "../core/resolve/stitch.js";
+import { dualImpl } from "../core/function/dualImpl.js";
+import { abstractInt, u32 } from "../data/numeric.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
+import { isPtr, isWgslArray } from "../data/wgslTypes.js";
 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})`;
-	}
+export 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}` : ctx.gen.emitCall('arrayLength', [], [a]);
+    },
+    sideEffects: false,
 });
-
-//#endregion
-export { arrayLength };

package/std/atomic.d.ts

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

package/std/atomic.js

@@ -1,113 +1,114 @@
-import { Void, isAtomic } from "../data/wgslTypes.js";
-import { safeStringify } from "../shared/stringify.js";
+import { dualImpl } from "../core/function/dualImpl.js";
 import { stitch } from "../core/resolve/stitch.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()"
+import { isAtomic, Void, } from "../data/wgslTypes.js";
+import { safeStringify } from "../shared/stringify.js";
+export const workgroupBarrier = dualImpl({
+    name: 'workgroupBarrier',
+    normalImpl: 'workgroupBarrier is a no-op outside of CODEGEN mode.',
+    signature: { argTypes: [], returnType: Void },
+    codegenImpl: () => 'workgroupBarrier()',
+    sideEffects: true,
 });
-const storageBarrier = dualImpl({
-	name: "storageBarrier",
-	normalImpl: "storageBarrier is a no-op outside of CODEGEN mode.",
-	signature: {
-		argTypes: [],
-		returnType: Void
-	},
-	codegenImpl: () => "storageBarrier()"
+export const storageBarrier = dualImpl({
+    name: 'storageBarrier',
+    normalImpl: 'storageBarrier is a no-op outside of CODEGEN mode.',
+    signature: { argTypes: [], returnType: Void },
+    codegenImpl: () => 'storageBarrier()',
+    sideEffects: true,
 });
-const textureBarrier = dualImpl({
-	name: "textureBarrier",
-	normalImpl: "textureBarrier is a no-op outside of CODEGEN mode.",
-	signature: {
-		argTypes: [],
-		returnType: Void
-	},
-	codegenImpl: () => "textureBarrier()"
+export const textureBarrier = dualImpl({
+    name: 'textureBarrier',
+    normalImpl: 'textureBarrier is a no-op outside of CODEGEN mode.',
+    signature: { argTypes: [], returnType: Void },
+    codegenImpl: () => 'textureBarrier()',
+    sideEffects: true,
 });
-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 atomicNormalError = 'Atomic operations are not supported outside of CODEGEN mode.';
+export 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})`,
+    sideEffects: true,
 });
 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
-	};
+    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
-	};
+    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})`
+export const atomicStore = dualImpl({
+    name: 'atomicStore',
+    normalImpl: atomicNormalError,
+    signature: atomicActionSignature,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicStore(&${a}, ${value})`,
+    sideEffects: true,
 });
-const atomicAdd = dualImpl({
-	name: "atomicAdd",
-	normalImpl: atomicNormalError,
-	signature: atomicOpSignature,
-	codegenImpl: (_ctx, [a, value]) => stitch`atomicAdd(&${a}, ${value})`
+export const atomicAdd = dualImpl({
+    name: 'atomicAdd',
+    normalImpl: atomicNormalError,
+    signature: atomicOpSignature,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicAdd(&${a}, ${value})`,
+    sideEffects: true,
 });
-const atomicSub = dualImpl({
-	name: "atomicSub",
-	normalImpl: atomicNormalError,
-	signature: atomicOpSignature,
-	codegenImpl: (_ctx, [a, value]) => stitch`atomicSub(&${a}, ${value})`
+export const atomicSub = dualImpl({
+    name: 'atomicSub',
+    normalImpl: atomicNormalError,
+    signature: atomicOpSignature,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicSub(&${a}, ${value})`,
+    sideEffects: true,
 });
-const atomicMax = dualImpl({
-	name: "atomicMax",
-	normalImpl: atomicNormalError,
-	signature: atomicOpSignature,
-	codegenImpl: (_ctx, [a, value]) => stitch`atomicMax(&${a}, ${value})`
+export const atomicMax = dualImpl({
+    name: 'atomicMax',
+    normalImpl: atomicNormalError,
+    signature: atomicOpSignature,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicMax(&${a}, ${value})`,
+    sideEffects: true,
 });
-const atomicMin = dualImpl({
-	name: "atomicMin",
-	normalImpl: atomicNormalError,
-	signature: atomicOpSignature,
-	codegenImpl: (_ctx, [a, value]) => stitch`atomicMin(&${a}, ${value})`
+export const atomicMin = dualImpl({
+    name: 'atomicMin',
+    normalImpl: atomicNormalError,
+    signature: atomicOpSignature,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicMin(&${a}, ${value})`,
+    sideEffects: true,
 });
-const atomicAnd = dualImpl({
-	name: "atomicAnd",
-	normalImpl: atomicNormalError,
-	signature: atomicOpSignature,
-	codegenImpl: (_ctx, [a, value]) => stitch`atomicAnd(&${a}, ${value})`
+export const atomicAnd = dualImpl({
+    name: 'atomicAnd',
+    normalImpl: atomicNormalError,
+    signature: atomicOpSignature,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicAnd(&${a}, ${value})`,
+    sideEffects: true,
 });
-const atomicOr = dualImpl({
-	name: "atomicOr",
-	normalImpl: atomicNormalError,
-	signature: atomicOpSignature,
-	codegenImpl: (_ctx, [a, value]) => stitch`atomicOr(&${a}, ${value})`
+export const atomicOr = dualImpl({
+    name: 'atomicOr',
+    normalImpl: atomicNormalError,
+    signature: atomicOpSignature,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicOr(&${a}, ${value})`,
+    sideEffects: true,
 });
-const atomicXor = dualImpl({
-	name: "atomicXor",
-	normalImpl: atomicNormalError,
-	signature: atomicOpSignature,
-	codegenImpl: (_ctx, [a, value]) => stitch`atomicXor(&${a}, ${value})`
+export const atomicXor = dualImpl({
+    name: 'atomicXor',
+    normalImpl: atomicNormalError,
+    signature: atomicOpSignature,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicXor(&${a}, ${value})`,
+    sideEffects: true,
 });
-
-//#endregion
-export { atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, storageBarrier, textureBarrier, workgroupBarrier };