typegpu 0.11.9 → 0.12.1

package/data/generalizeFn.d.ts

@@ -0,0 +1,25 @@
+import { type AnyBooleanVecInstance, type AnyMatInstance, type AnyVec2Instance, type AnyVec3Instance, type AnyVec4Instance, type AnyVecInstance, type v2b, type v3b, type v4b } from './wgslTypes.ts';
+type Vec = AnyVecInstance;
+type Mat = AnyMatInstance;
+type Algebraic = number | boolean | Vec | Mat;
+export type ToBool<T extends Algebraic> = T extends number | boolean ? boolean : T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : T extends AnyVec4Instance ? v4b : never;
+/**
+ * Generalizes function of 1 to 3 arguments to work component-wise on vectors and matrices.
+ * Assumes the types are already correct (in particular, that they have the same length),
+ * and performs no additional checks.
+ * The return type is the same as the first argument's type.
+ */
+export declare function generalizeFn<T extends Algebraic>(fn: (a: number) => number, args: [T]): T;
+export declare function generalizeFn<T extends Algebraic>(fn: (a: number, b: number) => number, args: [T, T]): T;
+export declare function generalizeFn<T extends Algebraic>(fn: (a: number, b: number, c: number) => number, args: [T, T, T]): T;
+/**
+ * Analogous to `generalizeFn`, but the return type is a boolean vector instead.
+ */
+export declare function generalizeBoolFn<T extends Algebraic>(fn: (a: number, b: number) => boolean, args: [T, T]): ToBool<T>;
+export declare function generalizeBoolFn<T extends boolean | AnyBooleanVecInstance>(fn: (a: boolean, b: boolean) => boolean, args: [T, T]): ToBool<T>;
+/**
+ * If one of the arguments is a vector and other is a number,
+ * the number is up-cased to a vector.
+ */
+export declare function upCast<T extends number | Vec>(args: [T, T]): [Exclude<T, number>, Exclude<T, number>];
+export {};

package/data/generalizeFn.js

@@ -0,0 +1,89 @@
+import { vec2b, vec3b, vec4b, vecTypeToConstructor } from "./vector.js";
+import { mat2x2f, mat3x3f, mat4x4f } from "./matrix.js";
+import { isVecInstance, } from "./wgslTypes.js";
+import { invariant } from "../errors.js";
+const booleanFor = {
+    vec2f: vec2b,
+    vec2h: vec2b,
+    vec2i: vec2b,
+    vec2u: vec2b,
+    'vec2<bool>': vec2b,
+    vec3f: vec3b,
+    vec3h: vec3b,
+    vec3i: vec3b,
+    vec3u: vec3b,
+    'vec3<bool>': vec3b,
+    vec4f: vec4b,
+    vec4h: vec4b,
+    vec4i: vec4b,
+    vec4u: vec4b,
+    'vec4<bool>': vec4b,
+};
+const constructorFor = {
+    ...vecTypeToConstructor,
+    mat2x2f,
+    mat3x3f,
+    mat4x4f,
+};
+function getConstructorFor(mode, kind) {
+    const map = mode === 'boolean' ? booleanFor : constructorFor;
+    if (kind in map) {
+        return map[kind];
+    }
+    throw new Error(`No corresponding vector/matrix type for '${kind}' kind in '${mode}' mode.`);
+}
+function makeIterable(item) {
+    if (item.kind.startsWith('vec')) {
+        return item;
+    }
+    return item.columns.flat();
+}
+function applyArgs(fn, args, mode) {
+    // I'm sorry, TypeScript, I swear I won't lie to you no more ;-;
+    const kinds = args.map(kindOf);
+    if (kinds.every((type) => type === 'boolean' || type === 'number')) {
+        return fn(...args);
+    }
+    const kind = kinds[0];
+    invariant(kind, `Expected kind of the first argument to be present.`);
+    const constructor = getConstructorFor(mode, kind);
+    const iterableArgs = args.map(makeIterable);
+    const length = iterableArgs[0]?.length;
+    invariant(length !== undefined, `Expected constructor to have at least one argument.`);
+    const constructorArgs = Array.from({ length }, (_, i) => {
+        const args = iterableArgs.map((arg) => arg[i]);
+        return fn(...args);
+    });
+    return constructor(...constructorArgs);
+}
+export function generalizeFn(fn, args) {
+    return applyArgs(fn, args, 'first');
+}
+export function generalizeBoolFn(fn, args) {
+    return applyArgs(fn, args, 'boolean');
+}
+function kindOf(v) {
+    if (typeof v === 'number') {
+        return 'number';
+    }
+    if (typeof v === 'boolean') {
+        return 'boolean';
+    }
+    return v.kind;
+}
+/**
+ * If one of the arguments is a vector and other is a number,
+ * the number is up-cased to a vector.
+ */
+export function upCast(args) {
+    const [lhs, rhs] = args;
+    if (typeof lhs === 'number' && isVecInstance(rhs)) {
+        const schema = constructorFor[rhs.kind];
+        return [schema(lhs), rhs];
+    }
+    else if (isVecInstance(lhs) && typeof rhs === 'number') {
+        const schema = constructorFor[lhs.kind];
+        return [lhs, schema(rhs)];
+    }
+    return [lhs, rhs];
+}

package/data/getLongestContiguousPrefix.d.ts

@@ -1,11 +1,7 @@
-import "./wgslTypes.js";
-import { AnyData } from "./dataTypes.js";
-
-//#region src/data/getLongestContiguousPrefix.d.ts
-
+import type { AnyData } from './dataTypes.ts';
+import type { BaseData } from './wgslTypes.ts';
+export declare function getLongestContiguousPrefix(schema: BaseData): number;
 /**
  * Returns the size (in bytes) of the longest contiguous memory prefix of data represented by the `schema`.
  */
-declare function PUBLIC_getLongestContiguousPrefix(schema: AnyData): number;
-//#endregion
-export { PUBLIC_getLongestContiguousPrefix };
+export declare function PUBLIC_getLongestContiguousPrefix(schema: AnyData): number;

package/data/getLongestContiguousPrefix.js

@@ -1,15 +1,10 @@
 import { getLayoutInfo } from "./schemaMemoryLayout.js";
-
-//#region src/data/getLongestContiguousPrefix.ts
-function getLongestContiguousPrefix(schema) {
-	return getLayoutInfo(schema, "longestContiguousPrefix");
+export function getLongestContiguousPrefix(schema) {
+    return getLayoutInfo(schema, 'longestContiguousPrefix');
 }
 /**
-* Returns the size (in bytes) of the longest contiguous memory prefix of data represented by the `schema`.
-*/
-function PUBLIC_getLongestContiguousPrefix(schema) {
-	return getLongestContiguousPrefix(schema);
+ * Returns the size (in bytes) of the longest contiguous memory prefix of data represented by the `schema`.
+ */
+export function PUBLIC_getLongestContiguousPrefix(schema) {
+    return getLongestContiguousPrefix(schema);
 }
-
-//#endregion
-export { PUBLIC_getLongestContiguousPrefix, getLongestContiguousPrefix };

package/data/index.d.ts

@@ -1,31 +1,30 @@
-import { WgslComparisonSampler, WgslSampler, comparisonSampler, sampler } from "./sampler.js";
-import { AnyBuiltin, BuiltinClipDistances, BuiltinFragDepth, BuiltinFrontFacing, BuiltinGlobalInvocationId, BuiltinInstanceIndex, BuiltinLocalInvocationId, BuiltinLocalInvocationIndex, BuiltinNumWorkgroups, BuiltinPosition, BuiltinSampleIndex, BuiltinSampleMask, BuiltinVertexIndex, BuiltinWorkgroupId, builtin } from "../builtin.js";
-import { AnyAttribute, HasCustomLocation, IsBuiltin, align, interpolate, invariant, isBuiltin, location, size } from "./attributes.js";
-import { memoryLayoutOf } from "./offsetUtils.js";
-import { FormatToAcceptedData, FormatToWGSLType, PackedData, TgpuVertexFormatData, float16, float16x2, float16x4, float32, float32x2, float32x3, float32x4, formatToWGSLType, isPackedData, packedFormats, sint16, sint16x2, sint16x4, sint32, sint32x2, sint32x3, sint32x4, sint8, sint8x2, sint8x4, snorm16, snorm16x2, snorm16x4, snorm8, snorm8x2, snorm8x4, uint16, uint16x2, uint16x4, uint32, uint32x2, uint32x3, uint32x4, uint8, uint8x2, uint8x4, unorm10_10_10_2, unorm16, unorm16x2, unorm16x4, unorm8, unorm8x2, unorm8x4, unorm8x4_bgra } from "./vertexFormatData.js";
-import { _ref } from "./ref.js";
-import { Align, AnyVecInstance, AnyWgslData, AnyWgslStruct, Atomic, BaseData, Bool, Builtin, Decorated, F16, F32, I32, Interpolate, Location, Mat2x2f, Mat3x3f, Mat4x4f, Ptr, Size, StorableData, U16, U32, Vec2b, Vec2f, Vec2h, Vec2i, Vec2u, Vec3b, Vec3f, Vec3h, Vec3i, Vec3u, Vec4b, Vec4f, Vec4h, Vec4i, Vec4u, Void, WgslArray, WgslStruct, atomicI32, atomicU32, isAlignAttrib, isAtomic, isBuiltinAttrib, isDecorated, isInterpolateAttrib, isLocationAttrib, isPtr, isSizeAttrib, isWgslArray, isWgslData, isWgslStruct, m2x2f, m3x3f, m4x4f, matBase, v2b, v2f, v2h, v2i, v2u, v3b, v3f, v3h, v3i, v3u, v4b, v4f, v4h, v4i, v4u, vecBase } from "./wgslTypes.js";
-import { WgslExternalTexture, WgslStorageTexture, WgslStorageTexture1d, WgslStorageTexture2d, WgslStorageTexture2dArray, WgslStorageTexture3d, WgslStorageTextureProps, WgslTexture, WgslTexture1d, WgslTexture2d, WgslTexture2dArray, WgslTexture3d, WgslTextureCube, WgslTextureCubeArray, WgslTextureDepth2d, WgslTextureDepth2dArray, WgslTextureDepthCube, WgslTextureDepthCubeArray, WgslTextureDepthMultisampled2d, WgslTextureMultisampled2d, texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d } from "./texture.js";
-import { Infer, InferGPU, InferInput, InferPartial, InferPatch } from "../shared/repr.js";
-import { AnyData, AnyLooseData, Disarray, LooseDecorated, Unstruct, isData, isDisarray, isLooseData, isLooseDecorated, isUnstruct } from "./dataTypes.js";
-import { bool, f16, f32, i32, u16, u32 } from "./numeric.js";
-import { struct } from "./struct.js";
-import { arrayOf } from "./array.js";
-import { ptrFn, ptrHandle, ptrPrivate, ptrStorage, ptrUniform, ptrWorkgroup } from "./ptr.js";
-import { vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u } from "./vector.js";
-import { disarrayOf } from "./disarray.js";
-import { unstruct } from "./unstruct.js";
-import { mat2x2f, mat3x3f, mat4x4f, matToArray } from "./matrix.js";
-import { atomic } from "./atomic.js";
-import { PUBLIC_sizeOf } from "./sizeOf.js";
-import { PUBLIC_isContiguous } from "./isContiguous.js";
-import { PUBLIC_getLongestContiguousPrefix } from "./getLongestContiguousPrefix.js";
-import { PUBLIC_alignmentOf } from "./alignmentOf.js";
-import { deepEqual } from "./deepEqual.js";
-
-//#region src/data/index.d.ts
-declare namespace index_d_exports {
-  export { Align, AnyAttribute, AnyBuiltin, AnyData, AnyLooseData, AnyVecInstance, AnyWgslData, AnyWgslStruct, Atomic, BaseData, BaseData as BaseWgslData, Bool, Builtin, BuiltinClipDistances, BuiltinFragDepth, BuiltinFrontFacing, BuiltinGlobalInvocationId, BuiltinInstanceIndex, BuiltinLocalInvocationId, BuiltinLocalInvocationIndex, BuiltinNumWorkgroups, BuiltinPosition, BuiltinSampleIndex, BuiltinSampleMask, BuiltinVertexIndex, BuiltinWorkgroupId, Decorated, Disarray, F16, F32, FormatToAcceptedData, FormatToWGSLType, HasCustomLocation, I32, Infer, InferGPU, InferInput, InferPartial, InferPatch, Interpolate, IsBuiltin, Location, LooseDecorated, Mat2x2f, Mat3x3f, Mat4x4f, PackedData, Ptr, Size, StorableData, TgpuVertexFormatData, U16, U32, Unstruct, Vec2b, Vec2f, Vec2h, Vec2i, Vec2u, Vec3b, Vec3f, Vec3h, Vec3i, Vec3u, Vec4b, Vec4f, Vec4h, Vec4i, Vec4u, Void, WgslArray, WgslComparisonSampler, WgslExternalTexture, WgslSampler, WgslStorageTexture, WgslStorageTexture1d, WgslStorageTexture2d, WgslStorageTexture2dArray, WgslStorageTexture3d, WgslStorageTextureProps, WgslStruct, WgslTexture, WgslTexture1d, WgslTexture2d, WgslTexture2dArray, WgslTexture3d, WgslTextureCube, WgslTextureCubeArray, WgslTextureDepth2d, WgslTextureDepth2dArray, WgslTextureDepthCube, WgslTextureDepthCubeArray, WgslTextureDepthMultisampled2d, WgslTextureMultisampled2d, align, PUBLIC_alignmentOf as alignmentOf, arrayOf, atomic, atomicI32, atomicU32, bool, builtin, comparisonSampler, deepEqual, disarrayOf, f16, f32, float16, float16x2, float16x4, float32, float32x2, float32x3, float32x4, formatToWGSLType, PUBLIC_getLongestContiguousPrefix as getLongestContiguousPrefix, i32, interpolate, invariant, isAlignAttrib, isAtomic, isBuiltin, isBuiltinAttrib, PUBLIC_isContiguous as isContiguous, isData, isDecorated, isDisarray, isInterpolateAttrib, isLocationAttrib, isLooseData, isLooseDecorated, isPackedData, isPtr, isSizeAttrib, isUnstruct, isWgslArray, isWgslData, isWgslStruct, location, m2x2f, m3x3f, m4x4f, mat2x2f, mat3x3f, mat4x4f, matBase, matToArray, memoryLayoutOf, packedFormats, ptrFn, ptrHandle, ptrPrivate, ptrStorage, ptrUniform, ptrWorkgroup, _ref as ref, sampler, sint16, sint16x2, sint16x4, sint32, sint32x2, sint32x3, sint32x4, sint8, sint8x2, sint8x4, size, PUBLIC_sizeOf as sizeOf, snorm16, snorm16x2, snorm16x4, snorm8, snorm8x2, snorm8x4, struct, texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d, u16, u32, uint16, uint16x2, uint16x4, uint32, uint32x2, uint32x3, uint32x4, uint8, uint8x2, uint8x4, unorm10_10_10_2, unorm16, unorm16x2, unorm16x4, unorm8, unorm8x2, unorm8x4, unorm8x4_bgra, unstruct, v2b, v2f, v2h, v2i, v2u, v3b, v3f, v3h, v3i, v3u, v4b, v4f, v4h, v4i, v4u, vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u, vecBase };
-}
-//#endregion
-export { type Align, type AnyAttribute, type AnyBuiltin, type AnyData, type AnyLooseData, type AnyVecInstance, type AnyWgslData, type AnyWgslStruct, type Atomic, type BaseData, type BaseData as BaseWgslData, type Bool, type Builtin, type BuiltinClipDistances, type BuiltinFragDepth, type BuiltinFrontFacing, type BuiltinGlobalInvocationId, type BuiltinInstanceIndex, type BuiltinLocalInvocationId, type BuiltinLocalInvocationIndex, type BuiltinNumWorkgroups, type BuiltinPosition, type BuiltinSampleIndex, type BuiltinSampleMask, type BuiltinVertexIndex, type BuiltinWorkgroupId, type Decorated, type Disarray, type F16, type F32, FormatToAcceptedData, FormatToWGSLType, type HasCustomLocation, type I32, type Infer, type InferGPU, type InferInput, type InferPartial, type InferPatch, type Interpolate, type IsBuiltin, type Location, type LooseDecorated, type Mat2x2f, type Mat3x3f, type Mat4x4f, PackedData, type Ptr, type Size, type StorableData, TgpuVertexFormatData, type U16, type U32, type Unstruct, type Vec2b, type Vec2f, type Vec2h, type Vec2i, type Vec2u, type Vec3b, type Vec3f, type Vec3h, type Vec3i, type Vec3u, type Vec4b, type Vec4f, type Vec4h, type Vec4i, type Vec4u, Void, type WgslArray, type WgslComparisonSampler, type WgslExternalTexture, type WgslSampler, type WgslStorageTexture, type WgslStorageTexture1d, type WgslStorageTexture2d, type WgslStorageTexture2dArray, type WgslStorageTexture3d, type WgslStorageTextureProps, type WgslStruct, type WgslTexture, type WgslTexture1d, type WgslTexture2d, type WgslTexture2dArray, type WgslTexture3d, type WgslTextureCube, type WgslTextureCubeArray, type WgslTextureDepth2d, type WgslTextureDepth2dArray, type WgslTextureDepthCube, type WgslTextureDepthCubeArray, type WgslTextureDepthMultisampled2d, type WgslTextureMultisampled2d, align, PUBLIC_alignmentOf as alignmentOf, arrayOf, atomic, type atomicI32, type atomicU32, bool, builtin, comparisonSampler, deepEqual, disarrayOf, f16, f32, float16, float16x2, float16x4, float32, float32x2, float32x3, float32x4, formatToWGSLType, PUBLIC_getLongestContiguousPrefix as getLongestContiguousPrefix, i32, index_d_exports, interpolate, invariant, isAlignAttrib, isAtomic, isBuiltin, isBuiltinAttrib, PUBLIC_isContiguous as isContiguous, isData, isDecorated, isDisarray, isInterpolateAttrib, isLocationAttrib, isLooseData, isLooseDecorated, isPackedData, isPtr, isSizeAttrib, isUnstruct, isWgslArray, isWgslData, isWgslStruct, location, type m2x2f, type m3x3f, type m4x4f, mat2x2f, mat3x3f, mat4x4f, type matBase, matToArray, memoryLayoutOf, packedFormats, ptrFn, ptrHandle, ptrPrivate, ptrStorage, ptrUniform, ptrWorkgroup, _ref as ref, sampler, sint16, sint16x2, sint16x4, sint32, sint32x2, sint32x3, sint32x4, sint8, sint8x2, sint8x4, size, PUBLIC_sizeOf as sizeOf, snorm16, snorm16x2, snorm16x4, snorm8, snorm8x2, snorm8x4, struct, texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d, u16, u32, uint16, uint16x2, uint16x4, uint32, uint32x2, uint32x3, uint32x4, uint8, uint8x2, uint8x4, unorm10_10_10_2, unorm16, unorm16x2, unorm16x4, unorm8, unorm8x2, unorm8x4, unorm8x4_bgra, unstruct, type v2b, type v2f, type v2h, type v2i, type v2u, type v3b, type v3f, type v3h, type v3i, type v3u, type v4b, type v4f, type v4h, type v4i, type v4u, vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u, type vecBase };
+/**
+ * @module typegpu/data
+ */
+export { bool, f16, f32, i32, u16, u32 } from './numeric.ts';
+export { isAlignAttrib, isAtomic, isBuiltinAttrib, isDecorated, isInterpolateAttrib, isInvariantAttrib, isLocationAttrib, isPtr, isSizeAttrib, isWgslArray, isWgslData, isWgslStruct, Void, } from './wgslTypes.ts';
+export type { Align, AnyVecInstance, AnyWgslData, AnyWgslStruct, Atomic, atomicI32, atomicU32, BaseData, BaseData as BaseWgslData, Bool, Builtin, Decorated, F16, F32, I32, Interpolate, Invariant, Location, m2x2f, m3x3f, m4x4f, Mat2x2f, Mat3x3f, Mat4x4f, matBase, Ptr, Size, StorableData, U16, U32, v2b, v2f, v2h, v2i, v2u, v3b, v3f, v3h, v3i, v3u, v4b, v4f, v4h, v4i, v4u, Vec2b, Vec2f, Vec2h, Vec2i, Vec2u, Vec3b, Vec3f, Vec3h, Vec3i, Vec3u, Vec4b, Vec4f, Vec4h, Vec4i, Vec4u, vecBase, WgslArray, WgslStruct, } from './wgslTypes.ts';
+export { struct } from './struct.ts';
+export { arrayOf } from './array.ts';
+export { ptrFn, ptrHandle, ptrPrivate, ptrStorage, ptrUniform, ptrWorkgroup } from './ptr.ts';
+export type { AnyData, AnyLooseData, Disarray, LooseDecorated, Unstruct } from './dataTypes.ts';
+export { texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d, type WgslExternalTexture, type WgslStorageTexture, type WgslStorageTexture1d, type WgslStorageTexture2d, type WgslStorageTexture2dArray, type WgslStorageTexture3d, type WgslStorageTextureProps, type WgslTexture, type WgslTexture1d, type WgslTexture2d, type WgslTexture2dArray, type WgslTexture3d, type WgslTextureCube, type WgslTextureCubeArray, type WgslTextureDepth2d, type WgslTextureDepth2dArray, type WgslTextureDepthCube, type WgslTextureDepthCubeArray, type WgslTextureDepthMultisampled2d, type WgslTextureMultisampled2d, } from './texture.ts';
+export { comparisonSampler, sampler, type WgslComparisonSampler, type WgslSampler, } from './sampler.ts';
+export { vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u, } from './vector.ts';
+export { disarrayOf } from './disarray.ts';
+export { unstruct } from './unstruct.ts';
+export { mat2x2f, mat3x3f, mat4x4f, matToArray } from './matrix.ts';
+export * from './vertexFormatData.ts';
+export { atomic } from './atomic.ts';
+export { _ref as ref } from './ref.ts';
+export { align, type AnyAttribute, type HasCustomLocation, interpolate, invariant, type IsBuiltin, isBuiltin, location, size, } from './attributes.ts';
+export { isData, isDisarray, isLooseData, isLooseDecorated, isUnstruct } from './dataTypes.ts';
+export { PUBLIC_sizeOf as sizeOf } from './sizeOf.ts';
+export { PUBLIC_isContiguous as isContiguous } from './isContiguous.ts';
+export { PUBLIC_getLongestContiguousPrefix as getLongestContiguousPrefix } from './getLongestContiguousPrefix.ts';
+export { memoryLayoutOf } from './offsetUtils.ts';
+export { PUBLIC_alignmentOf as alignmentOf } from './alignmentOf.ts';
+export { builtin } from '../builtin.ts';
+export { deepEqual } from './deepEqual.ts';
+export type { AnyBuiltin, BuiltinClipDistances, BuiltinFragDepth, BuiltinFrontFacing, BuiltinGlobalInvocationId, BuiltinGlobalInvocationIndex, BuiltinInstanceIndex, BuiltinLocalInvocationId, BuiltinLocalInvocationIndex, BuiltinNumSubgroups, BuiltinNumWorkgroups, BuiltinPosition, BuiltinPrimitiveIndex, BuiltinSampleIndex, BuiltinSampleMask, BuiltinSubgroupId, BuiltinSubgroupInvocationId, BuiltinSubgroupSize, BuiltinVertexIndex, BuiltinWorkgroupId, BuiltinWorkgroupIndex, } from '../builtin.ts';
+export type { Infer, InferGPU, InferInput, InferPartial, InferPatch, MemIdentity, } from '../shared/repr.ts';

package/data/index.js

@@ -1,174 +1,41 @@
-import { __export } from "../_virtual/rolldown_runtime.js";
-import { Void, isAlignAttrib, isAtomic, isBuiltinAttrib, isDecorated, isInterpolateAttrib, isLocationAttrib, isPtr, isSizeAttrib, isWgslArray, isWgslData, isWgslStruct } from "./wgslTypes.js";
-import { isData, isDisarray, isLooseData, isLooseDecorated, isUnstruct } from "./dataTypes.js";
-import { ptrFn, ptrHandle, ptrPrivate, ptrStorage, ptrUniform, ptrWorkgroup } from "./ptr.js";
-import { _ref } from "./ref.js";
-import { bool, f16, f32, i32, u16, u32 } from "./numeric.js";
+/**
+ * @module typegpu/data
+ */
+// NOTE: This is a barrel file, internal files should not import things from this file
+import { Operator } from 'tsover-runtime';
+import { MatBase } from "./matrix.js";
 import { VecBase } from "./vectorImpl.js";
-import { vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u } from "./vector.js";
-import { float16, float16x2, float16x4, float32, float32x2, float32x3, float32x4, formatToWGSLType, isPackedData, packedFormats, sint16, sint16x2, sint16x4, sint32, sint32x2, sint32x3, sint32x4, sint8, sint8x2, sint8x4, snorm16, snorm16x2, snorm16x4, snorm8, snorm8x2, snorm8x4, uint16, uint16x2, uint16x4, uint32, uint32x2, uint32x3, uint32x4, uint8, uint8x2, uint8x4, unorm10_10_10_2, unorm16, unorm16x2, unorm16x4, unorm8, unorm8x2, unorm8x4, unorm8x4_bgra } from "./vertexFormatData.js";
-import { PUBLIC_alignmentOf } from "./alignmentOf.js";
-import { PUBLIC_sizeOf } from "./sizeOf.js";
-import { align, interpolate, invariant, isBuiltin, location, size } from "./attributes.js";
-import { struct } from "./struct.js";
-import { MatBase, mat2x2f, mat3x3f, mat4x4f, matToArray } from "./matrix.js";
 import { assignInfixOperator } from "../tgsl/infixDispatch.js";
-import { comparisonSampler, sampler } from "./sampler.js";
-import { texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d } from "./texture.js";
-import { arrayOf } from "./array.js";
-import { atomic } from "./atomic.js";
-import { builtin } from "../builtin.js";
-import { PUBLIC_isContiguous } from "./isContiguous.js";
-import { PUBLIC_getLongestContiguousPrefix } from "./getLongestContiguousPrefix.js";
-import { memoryLayoutOf } from "./offsetUtils.js";
-import { disarrayOf } from "./disarray.js";
-import { unstruct } from "./unstruct.js";
-import { deepEqual } from "./deepEqual.js";
-import { Operator } from "tsover-runtime";
-
-//#region src/data/index.ts
-var data_exports = /* @__PURE__ */ __export({
-	Void: () => Void,
-	align: () => align,
-	alignmentOf: () => PUBLIC_alignmentOf,
-	arrayOf: () => arrayOf,
-	atomic: () => atomic,
-	bool: () => bool,
-	builtin: () => builtin,
-	comparisonSampler: () => comparisonSampler,
-	deepEqual: () => deepEqual,
-	disarrayOf: () => disarrayOf,
-	f16: () => f16,
-	f32: () => f32,
-	float16: () => float16,
-	float16x2: () => float16x2,
-	float16x4: () => float16x4,
-	float32: () => float32,
-	float32x2: () => float32x2,
-	float32x3: () => float32x3,
-	float32x4: () => float32x4,
-	formatToWGSLType: () => formatToWGSLType,
-	getLongestContiguousPrefix: () => PUBLIC_getLongestContiguousPrefix,
-	i32: () => i32,
-	interpolate: () => interpolate,
-	invariant: () => invariant,
-	isAlignAttrib: () => isAlignAttrib,
-	isAtomic: () => isAtomic,
-	isBuiltin: () => isBuiltin,
-	isBuiltinAttrib: () => isBuiltinAttrib,
-	isContiguous: () => PUBLIC_isContiguous,
-	isData: () => isData,
-	isDecorated: () => isDecorated,
-	isDisarray: () => isDisarray,
-	isInterpolateAttrib: () => isInterpolateAttrib,
-	isLocationAttrib: () => isLocationAttrib,
-	isLooseData: () => isLooseData,
-	isLooseDecorated: () => isLooseDecorated,
-	isPackedData: () => isPackedData,
-	isPtr: () => isPtr,
-	isSizeAttrib: () => isSizeAttrib,
-	isUnstruct: () => isUnstruct,
-	isWgslArray: () => isWgslArray,
-	isWgslData: () => isWgslData,
-	isWgslStruct: () => isWgslStruct,
-	location: () => location,
-	mat2x2f: () => mat2x2f,
-	mat3x3f: () => mat3x3f,
-	mat4x4f: () => mat4x4f,
-	matToArray: () => matToArray,
-	memoryLayoutOf: () => memoryLayoutOf,
-	packedFormats: () => packedFormats,
-	ptrFn: () => ptrFn,
-	ptrHandle: () => ptrHandle,
-	ptrPrivate: () => ptrPrivate,
-	ptrStorage: () => ptrStorage,
-	ptrUniform: () => ptrUniform,
-	ptrWorkgroup: () => ptrWorkgroup,
-	ref: () => _ref,
-	sampler: () => sampler,
-	sint16: () => sint16,
-	sint16x2: () => sint16x2,
-	sint16x4: () => sint16x4,
-	sint32: () => sint32,
-	sint32x2: () => sint32x2,
-	sint32x3: () => sint32x3,
-	sint32x4: () => sint32x4,
-	sint8: () => sint8,
-	sint8x2: () => sint8x2,
-	sint8x4: () => sint8x4,
-	size: () => size,
-	sizeOf: () => PUBLIC_sizeOf,
-	snorm16: () => snorm16,
-	snorm16x2: () => snorm16x2,
-	snorm16x4: () => snorm16x4,
-	snorm8: () => snorm8,
-	snorm8x2: () => snorm8x2,
-	snorm8x4: () => snorm8x4,
-	struct: () => struct,
-	texture1d: () => texture1d,
-	texture2d: () => texture2d,
-	texture2dArray: () => texture2dArray,
-	texture3d: () => texture3d,
-	textureCube: () => textureCube,
-	textureCubeArray: () => textureCubeArray,
-	textureDepth2d: () => textureDepth2d,
-	textureDepth2dArray: () => textureDepth2dArray,
-	textureDepthCube: () => textureDepthCube,
-	textureDepthCubeArray: () => textureDepthCubeArray,
-	textureDepthMultisampled2d: () => textureDepthMultisampled2d,
-	textureExternal: () => textureExternal,
-	textureMultisampled2d: () => textureMultisampled2d,
-	textureStorage1d: () => textureStorage1d,
-	textureStorage2d: () => textureStorage2d,
-	textureStorage2dArray: () => textureStorage2dArray,
-	textureStorage3d: () => textureStorage3d,
-	u16: () => u16,
-	u32: () => u32,
-	uint16: () => uint16,
-	uint16x2: () => uint16x2,
-	uint16x4: () => uint16x4,
-	uint32: () => uint32,
-	uint32x2: () => uint32x2,
-	uint32x3: () => uint32x3,
-	uint32x4: () => uint32x4,
-	uint8: () => uint8,
-	uint8x2: () => uint8x2,
-	uint8x4: () => uint8x4,
-	unorm10_10_10_2: () => unorm10_10_10_2,
-	unorm16: () => unorm16,
-	unorm16x2: () => unorm16x2,
-	unorm16x4: () => unorm16x4,
-	unorm8: () => unorm8,
-	unorm8x2: () => unorm8x2,
-	unorm8x4: () => unorm8x4,
-	unorm8x4_bgra: () => unorm8x4_bgra,
-	unstruct: () => unstruct,
-	vec2b: () => vec2b,
-	vec2f: () => vec2f,
-	vec2h: () => vec2h,
-	vec2i: () => vec2i,
-	vec2u: () => vec2u,
-	vec3b: () => vec3b,
-	vec3f: () => vec3f,
-	vec3h: () => vec3h,
-	vec3i: () => vec3i,
-	vec3u: () => vec3u,
-	vec4b: () => vec4b,
-	vec4f: () => vec4f,
-	vec4h: () => vec4h,
-	vec4i: () => vec4i,
-	vec4u: () => vec4u
-});
-assignInfixOperator(VecBase, "add", Operator.plus);
-assignInfixOperator(MatBase, "add", Operator.plus);
-assignInfixOperator(VecBase, "sub", Operator.minus);
-assignInfixOperator(MatBase, "sub", Operator.minus);
-assignInfixOperator(VecBase, "mul", Operator.star);
-assignInfixOperator(MatBase, "mul", Operator.star);
-assignInfixOperator(VecBase, "div", Operator.slash);
-assignInfixOperator(VecBase, "mod", Operator.percent);
-assignInfixOperator(VecBase, "bitShiftLeft", Symbol());
-assignInfixOperator(VecBase, "bitShiftRight", Symbol());
-
-//#endregion
-export { Void, align, PUBLIC_alignmentOf as alignmentOf, arrayOf, atomic, bool, builtin, comparisonSampler, data_exports, deepEqual, disarrayOf, f16, f32, float16, float16x2, float16x4, float32, float32x2, float32x3, float32x4, formatToWGSLType, PUBLIC_getLongestContiguousPrefix as getLongestContiguousPrefix, i32, interpolate, invariant, isAlignAttrib, isAtomic, isBuiltin, isBuiltinAttrib, PUBLIC_isContiguous as isContiguous, isData, isDecorated, isDisarray, isInterpolateAttrib, isLocationAttrib, isLooseData, isLooseDecorated, isPackedData, isPtr, isSizeAttrib, isUnstruct, isWgslArray, isWgslData, isWgslStruct, location, mat2x2f, mat3x3f, mat4x4f, matToArray, memoryLayoutOf, packedFormats, ptrFn, ptrHandle, ptrPrivate, ptrStorage, ptrUniform, ptrWorkgroup, _ref as ref, sampler, sint16, sint16x2, sint16x4, sint32, sint32x2, sint32x3, sint32x4, sint8, sint8x2, sint8x4, size, PUBLIC_sizeOf as sizeOf, snorm16, snorm16x2, snorm16x4, snorm8, snorm8x2, snorm8x4, struct, texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d, u16, u32, uint16, uint16x2, uint16x4, uint32, uint32x2, uint32x3, uint32x4, uint8, uint8x2, uint8x4, unorm10_10_10_2, unorm16, unorm16x2, unorm16x4, unorm8, unorm8x2, unorm8x4, unorm8x4_bgra, unstruct, vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u };
+assignInfixOperator(VecBase, 'add', Operator.plus);
+assignInfixOperator(MatBase, 'add', Operator.plus);
+assignInfixOperator(VecBase, 'sub', Operator.minus);
+assignInfixOperator(MatBase, 'sub', Operator.minus);
+assignInfixOperator(VecBase, 'mul', Operator.star);
+assignInfixOperator(MatBase, 'mul', Operator.star);
+assignInfixOperator(VecBase, 'div', Operator.slash);
+assignInfixOperator(VecBase, 'mod', Operator.percent);
+assignInfixOperator(VecBase, 'bitShiftLeft', Symbol()); // bitShift does not yet have tsover operator symbol
+assignInfixOperator(VecBase, 'bitShiftRight', Symbol()); // bitShift does not yet have tsover operator symbol
+export { bool, f16, f32, i32, u16, u32 } from "./numeric.js";
+export { isAlignAttrib, isAtomic, isBuiltinAttrib, isDecorated, isInterpolateAttrib, isInvariantAttrib, isLocationAttrib, isPtr, isSizeAttrib, isWgslArray, isWgslData, isWgslStruct, Void, } from "./wgslTypes.js";
+export { struct } from "./struct.js";
+export { arrayOf } from "./array.js";
+export { ptrFn, ptrHandle, ptrPrivate, ptrStorage, ptrUniform, ptrWorkgroup } from "./ptr.js";
+export { texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d, } from "./texture.js";
+export { comparisonSampler, sampler, } from "./sampler.js";
+export { vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u, } from "./vector.js";
+export { disarrayOf } from "./disarray.js";
+export { unstruct } from "./unstruct.js";
+export { mat2x2f, mat3x3f, mat4x4f, matToArray } from "./matrix.js";
+export * from "./vertexFormatData.js";
+export { atomic } from "./atomic.js";
+export { _ref as ref } from "./ref.js";
+export { align, interpolate, invariant, isBuiltin, location, size, } from "./attributes.js";
+export { isData, isDisarray, isLooseData, isLooseDecorated, isUnstruct } from "./dataTypes.js";
+export { PUBLIC_sizeOf as sizeOf } from "./sizeOf.js";
+export { PUBLIC_isContiguous as isContiguous } from "./isContiguous.js";
+export { PUBLIC_getLongestContiguousPrefix as getLongestContiguousPrefix } from "./getLongestContiguousPrefix.js";
+export { memoryLayoutOf } from "./offsetUtils.js";
+export { PUBLIC_alignmentOf as alignmentOf } from "./alignmentOf.js";
+export { builtin } from "../builtin.js";
+export { deepEqual } from "./deepEqual.js";

package/data/instanceToSchema.d.ts

@@ -1,33 +1,30 @@
-import { $internal } from "../shared/symbols.js";
-import { Bool, F16, F32, I32, Mat2x2f, Mat3x3f, Mat4x4f, U16, U32, Vec2b, Vec2f, Vec2h, Vec2i, Vec2u, Vec3b, Vec3f, Vec3h, Vec3i, Vec3u, Vec4b, Vec4f, Vec4h, Vec4i, Vec4u, Void } from "./wgslTypes.js";
-
-//#region src/data/instanceToSchema.d.ts
+import { $internal } from '../shared/symbols.ts';
+import type { Bool, F16, F32, I32, Mat2x2f, Mat3x3f, Mat4x4f, U16, U32, Vec2b, Vec2f, Vec2h, Vec2i, Vec2u, Vec3b, Vec3f, Vec3h, Vec3i, Vec3u, Vec4b, Vec4f, Vec4h, Vec4i, Vec4u, Void } from './wgslTypes.ts';
 type KindToSchemaMap = {
-  vec2f: Vec2f;
-  vec3f: Vec3f;
-  vec4f: Vec4f;
-  vec2h: Vec2h;
-  vec3h: Vec3h;
-  vec4h: Vec4h;
-  vec2i: Vec2i;
-  vec3i: Vec3i;
-  vec4i: Vec4i;
-  vec2u: Vec2u;
-  vec3u: Vec3u;
-  vec4u: Vec4u;
-  'vec2<bool>': Vec2b;
-  'vec3<bool>': Vec3b;
-  'vec4<bool>': Vec4b;
-  mat2x2f: Mat2x2f;
-  mat3x3f: Mat3x3f;
-  mat4x4f: Mat4x4f;
+    vec2f: Vec2f;
+    vec3f: Vec3f;
+    vec4f: Vec4f;
+    vec2h: Vec2h;
+    vec3h: Vec3h;
+    vec4h: Vec4h;
+    vec2i: Vec2i;
+    vec3i: Vec3i;
+    vec4i: Vec4i;
+    vec2u: Vec2u;
+    vec3u: Vec3u;
+    vec4u: Vec4u;
+    'vec2<bool>': Vec2b;
+    'vec3<bool>': Vec3b;
+    'vec4<bool>': Vec4b;
+    mat2x2f: Mat2x2f;
+    mat3x3f: Mat3x3f;
+    mat4x4f: Mat4x4f;
 };
 /**
  * Inverse operation to d.Infer<T>
  */
-type InstanceToSchema<T> = T extends number ? U32 | U16 | I32 | F32 | F16 : T extends boolean ? Bool : T extends undefined ? Void : T extends {
-  readonly [$internal]: unknown;
-  readonly kind: infer TKind extends keyof KindToSchemaMap;
+export type InstanceToSchema<T> = T extends number ? U32 | U16 | I32 | F32 | F16 : T extends boolean ? Bool : T extends undefined ? Void : T extends {
+    readonly [$internal]: unknown;
+    readonly kind: infer TKind extends keyof KindToSchemaMap;
 } ? KindToSchemaMap[TKind] : T;
-//#endregion
-export { InstanceToSchema };
+export {};

package/data/instanceToSchema.js

@@ -0,0 +1 @@
+import { $internal } from "../shared/symbols.js";

package/data/isContiguous.d.ts

@@ -1,11 +1,7 @@
-import "./wgslTypes.js";
-import { AnyData } from "./dataTypes.js";
-
-//#region src/data/isContiguous.d.ts
-
+import type { AnyData } from './dataTypes.ts';
+import type { BaseData } from './wgslTypes.ts';
+export declare function isContiguous(schema: BaseData): boolean;
 /**
  * Returns `true` if data represented by the `schema` doesn't have padding.
  */
-declare function PUBLIC_isContiguous(schema: AnyData): boolean;
-//#endregion
-export { PUBLIC_isContiguous };
+export declare function PUBLIC_isContiguous(schema: AnyData): boolean;

package/data/isContiguous.js

@@ -1,15 +1,10 @@
 import { getLayoutInfo } from "./schemaMemoryLayout.js";
-
-//#region src/data/isContiguous.ts
-function isContiguous(schema) {
-	return getLayoutInfo(schema, "isContiguous");
+export function isContiguous(schema) {
+    return getLayoutInfo(schema, 'isContiguous');
 }
 /**
-* Returns `true` if data represented by the `schema` doesn't have padding.
-*/
-function PUBLIC_isContiguous(schema) {
-	return isContiguous(schema);
+ * Returns `true` if data represented by the `schema` doesn't have padding.
+ */
+export function PUBLIC_isContiguous(schema) {
+    return isContiguous(schema);
 }
-
-//#endregion
-export { PUBLIC_isContiguous, isContiguous };