typegpu 0.10.0 → 0.10.2

package/data/dataTypes.js

@@ -0,0 +1,97 @@
+import { $internal, isMarkedInternal } from "../shared/symbols.js";
+import { setName } from "../shared/meta.js";
+import { vertexFormats } from "../shared/vertexFormat.js";
+import { isAlignAttrib, isDecorated, isLocationAttrib, isPtr, isSizeAttrib, isWgslData } from "./wgslTypes.js";
+
+//#region src/data/dataTypes.ts
+/**
+* Runtime function to extract the inner data type from decorated types.
+* If the data is not decorated, returns the data as-is.
+*/
+function undecorate(data) {
+	if (isDecorated(data) || isLooseDecorated(data)) return data.inner;
+	return data;
+}
+function unptr(data) {
+	if (isPtr(data)) return data.inner;
+	return data;
+}
+const looseTypeLiterals = [
+	"unstruct",
+	"disarray",
+	"loose-decorated",
+	...vertexFormats
+];
+function isLooseData(data) {
+	return isMarkedInternal(data) && looseTypeLiterals.includes(data?.type);
+}
+/**
+* Checks whether the passed in value is a disarray schema,
+* as opposed to, e.g., a regular array schema.
+*
+* Array schemas can be used to describe uniform and storage buffers,
+* whereas disarray schemas cannot. Disarrays are useful for
+* defining vertex buffers instead.
+*
+* @example
+* isDisarray(d.arrayOf(d.u32, 4)) // false
+* isDisarray(d.disarrayOf(d.u32, 4)) // true
+* isDisarray(d.vec3f) // false
+*/
+function isDisarray(schema) {
+	return isMarkedInternal(schema) && schema?.type === "disarray";
+}
+/**
+* Checks whether passed in value is a unstruct schema,
+* as opposed to, e.g., a struct schema.
+*
+* Struct schemas can be used to describe uniform and storage buffers,
+* whereas unstruct schemas cannot. Unstructs are useful for
+* defining vertex buffers instead.
+*
+* @example
+* isUnstruct(d.struct({ a: d.u32 })) // false
+* isUnstruct(d.unstruct({ a: d.u32 })) // true
+* isUnstruct(d.vec3f) // false
+*/
+function isUnstruct(schema) {
+	return isMarkedInternal(schema) && schema?.type === "unstruct";
+}
+function isLooseDecorated(value) {
+	return isMarkedInternal(value) && value?.type === "loose-decorated";
+}
+function getCustomAlignment(data) {
+	return data.attribs?.find(isAlignAttrib)?.params[0];
+}
+function getCustomSize(data) {
+	return data.attribs?.find(isSizeAttrib)?.params[0];
+}
+function getCustomLocation(data) {
+	return data.attribs?.find(isLocationAttrib)?.params[0];
+}
+function isData(value) {
+	return isWgslData(value) || isLooseData(value);
+}
+const UnknownData = Symbol("UNKNOWN");
+var InfixDispatch = class {
+	constructor(name, lhs, operator) {
+		this.name = name;
+		this.lhs = lhs;
+		this.operator = operator;
+	}
+};
+var MatrixColumnsAccess = class {
+	constructor(matrix) {
+		this.matrix = matrix;
+	}
+};
+var ConsoleLog = class {
+	[$internal] = true;
+	constructor(op) {
+		this.op = op;
+		setName(this, "consoleLog");
+	}
+};
+
+//#endregion
+export { ConsoleLog, InfixDispatch, MatrixColumnsAccess, UnknownData, getCustomAlignment, getCustomLocation, getCustomSize, isData, isDisarray, isLooseData, isLooseDecorated, isUnstruct, undecorate, unptr };

package/data/deepEqual.d.ts

@@ -0,0 +1,25 @@
+import { AnyData } from "./dataTypes.js";
+
+//#region src/data/deepEqual.d.ts
+/**
+ * Performs a deep comparison of two TypeGPU data schemas.
+ *
+ * @param a The first data schema to compare.
+ * @param b The second data schema to compare.
+ * @returns `true` if the schemas are deeply equal, `false` otherwise.
+ *
+ * @example
+ * ```ts
+ * import { vec3f, struct, deepEqual } from 'typegpu/data';
+ *
+ * const schema1 = struct({ a: vec3f });
+ * const schema2 = struct({ a: vec3f });
+ * const schema3 = struct({ b: vec3f });
+ *
+ * console.log(deepEqual(schema1, schema2)); // true
+ * console.log(deepEqual(schema1, schema3)); // false
+ * ```
+ */
+declare function deepEqual(a: AnyData, b: AnyData): boolean;
+//#endregion
+export { deepEqual };

package/data/deepEqual.js

@@ -0,0 +1,58 @@
+import { isAtomic, isDecorated, isPtr, isWgslArray, isWgslStruct } from "./wgslTypes.js";
+import { isDisarray, isLooseDecorated, isUnstruct } from "./dataTypes.js";
+
+//#region src/data/deepEqual.ts
+/**
+* Performs a deep comparison of two TypeGPU data schemas.
+*
+* @param a The first data schema to compare.
+* @param b The second data schema to compare.
+* @returns `true` if the schemas are deeply equal, `false` otherwise.
+*
+* @example
+* ```ts
+* import { vec3f, struct, deepEqual } from 'typegpu/data';
+*
+* const schema1 = struct({ a: vec3f });
+* const schema2 = struct({ a: vec3f });
+* const schema3 = struct({ b: vec3f });
+*
+* console.log(deepEqual(schema1, schema2)); // true
+* console.log(deepEqual(schema1, schema3)); // false
+* ```
+*/
+function deepEqual(a, b) {
+	if (a === b) return true;
+	if (a.type !== b.type) return false;
+	if (isWgslStruct(a) && isWgslStruct(b) || isUnstruct(a) && isUnstruct(b)) {
+		const aProps = a.propTypes;
+		const bProps = b.propTypes;
+		const aKeys = Object.keys(aProps);
+		const bKeys = Object.keys(bProps);
+		if (aKeys.length !== bKeys.length) return false;
+		for (let i = 0; i < aKeys.length; i++) {
+			const keyA = aKeys[i];
+			const keyB = bKeys[i];
+			if (keyA !== keyB || !keyA || !keyB || !deepEqual(aProps[keyA], bProps[keyB])) return false;
+		}
+		return true;
+	}
+	if (isWgslArray(a) && isWgslArray(b) || isDisarray(a) && isDisarray(b)) return a.elementCount === b.elementCount && deepEqual(a.elementType, b.elementType);
+	if (isPtr(a) && isPtr(b)) return a.addressSpace === b.addressSpace && a.access === b.access && deepEqual(a.inner, b.inner);
+	if (isAtomic(a) && isAtomic(b)) return deepEqual(a.inner, b.inner);
+	if (isDecorated(a) && isDecorated(b) || isLooseDecorated(a) && isLooseDecorated(b)) {
+		if (!deepEqual(a.inner, b.inner)) return false;
+		if (a.attribs.length !== b.attribs.length) return false;
+		const getAttrKey = (attr) => {
+			const anyAttr = attr;
+			return `${anyAttr.type}(${(anyAttr.params ?? []).join(",")})`;
+		};
+		const attrsA = a.attribs.map(getAttrKey);
+		const attrsB = b.attribs.map(getAttrKey);
+		for (let i = 0; i < attrsA.length; i++) if (attrsA[i] !== attrsB[i]) return false;
+	}
+	return true;
+}
+
+//#endregion
+export { deepEqual };

package/data/disarray.d.ts

@@ -0,0 +1,34 @@
+import { AnyData, Disarray } from "./dataTypes.js";
+import { TgpuComptime } from "../core/function/comptime.js";
+import "../indexNamedExports.js";
+
+//#region src/data/disarray.d.ts
+interface DisarrayConstructor {
+  <TElement extends AnyData>(elementType: TElement): (elementCount: number) => Disarray<TElement>;
+  <TElement extends AnyData>(elementType: TElement, elementCount: number): Disarray<TElement>;
+}
+/**
+ * Creates an array schema that can be used to construct vertex buffers.
+ * Describes arrays with fixed-size length, storing elements of the same type.
+ *
+ * Elements in the schema are not aligned in respect to their `byteAlignment`,
+ * unless they are explicitly decorated with the custom align attribute
+ * via `d.align` function.
+ *
+ * @example
+ * const disarray = d.disarrayOf(d.vec3f, 3); // packed array of vec3f
+ *
+ * @example
+ * const disarray = d.disarrayOf(d.align(16, d.vec3f), 3);
+ *
+ * If `elementCount` is not specified, a partially applied function is returned.
+ * @example
+ * const disarray = d.disarrayOf(d.vec3f);
+ * //    ^? (n: number) => Disarray<d.Vec3f>
+ *
+ * @param elementType The type of elements in the array.
+ * @param elementCount The number of elements in the array.
+ */
+declare const disarrayOf: TgpuComptime<DisarrayConstructor>;
+//#endregion
+export { disarrayOf };

package/data/disarray.js

@@ -0,0 +1,52 @@
+import { $internal } from "../shared/symbols.js";
+import { schemaCallWrapper } from "./schemaCallWrapper.js";
+import { comptime } from "../core/function/comptime.js";
+
+//#region src/data/disarray.ts
+/**
+* Creates an array schema that can be used to construct vertex buffers.
+* Describes arrays with fixed-size length, storing elements of the same type.
+*
+* Elements in the schema are not aligned in respect to their `byteAlignment`,
+* unless they are explicitly decorated with the custom align attribute
+* via `d.align` function.
+*
+* @example
+* const disarray = d.disarrayOf(d.vec3f, 3); // packed array of vec3f
+*
+* @example
+* const disarray = d.disarrayOf(d.align(16, d.vec3f), 3);
+*
+* If `elementCount` is not specified, a partially applied function is returned.
+* @example
+* const disarray = d.disarrayOf(d.vec3f);
+* //    ^? (n: number) => Disarray<d.Vec3f>
+*
+* @param elementType The type of elements in the array.
+* @param elementCount The number of elements in the array.
+*/
+const disarrayOf = comptime(((elementType, elementCount) => {
+	if (elementCount === void 0) return (count) => cpu_disarrayOf(elementType, count);
+	return cpu_disarrayOf(elementType, elementCount);
+})).$name("disarrayOf");
+function cpu_disarrayOf(elementType, elementCount) {
+	const disarraySchema = (elements) => {
+		if (elements && elements.length !== elementCount) throw new Error(`Disarray schema of ${elementCount} elements of type ${elementType.type} called with ${elements.length} argument(s).`);
+		return Array.from({ length: elementCount }, (_, i) => schemaCallWrapper(elementType, elements?.[i]));
+	};
+	Object.setPrototypeOf(disarraySchema, DisarrayImpl);
+	disarraySchema.elementType = elementType;
+	if (!Number.isInteger(elementCount) || elementCount < 0) throw new Error(`Cannot create disarray schema with invalid element count: ${elementCount}.`);
+	disarraySchema.elementCount = elementCount;
+	return disarraySchema;
+}
+const DisarrayImpl = {
+	[$internal]: true,
+	type: "disarray",
+	toString() {
+		return `disarrayOf(${this.elementType}, ${this.elementCount})`;
+	}
+};
+
+//#endregion
+export { disarrayOf };

package/data/getLongestContiguousPrefix.d.ts

@@ -0,0 +1,10 @@
+import "./wgslTypes.js";
+import { AnyData } from "./dataTypes.js";
+
+//#region src/data/getLongestContiguousPrefix.d.ts
+/**
+ * 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 };

package/data/getLongestContiguousPrefix.js

@@ -0,0 +1,15 @@
+import { getLayoutInfo } from "./schemaMemoryLayout.js";
+
+//#region src/data/getLongestContiguousPrefix.ts
+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);
+}
+
+//#endregion
+export { PUBLIC_getLongestContiguousPrefix, getLongestContiguousPrefix };

package/data/index.d.ts

@@ -1,9 +1,31 @@
-import { $a as m3x3f, $c as align, $i as textureStorage2dArray, $n as atomic, $s as uint32x2, Aa as Vec3h, Ai as WgslTextureCube, Ar as ptrHandle, As as formatToWGSLType, Ba as WgslStruct, Bi as texture2dArray, Br as i32, Bs as sint8, Ca as Vec2b, Ci as WgslStorageTexture3d, Cl as BuiltinNumWorkgroups, Cr as vec3u, Cs as float16, Da as Vec2u, Di as WgslTexture2d, Dl as BuiltinVertexIndex, Dr as vec4i, Ds as float32x2, Ea as Vec2i, Ei as WgslTexture1d, El as BuiltinSampleMask, Er as vec4h, Es as float32, Fa as Vec4h, Fi as WgslTextureDepthCubeArray, Fl as comparisonSampler, Fr as arrayOf, Fs as sint16x4, Ga as isInterpolateAttrib, Gi as textureDepth2dArray, Gs as snorm16x4, Ha as isAtomic, Hi as textureCube, Hr as u32, Hs as sint8x4, Ia as Vec4i, Ii as WgslTextureDepthMultisampled2d, Il as sampler, Ir as struct, Is as sint32, Ja as isSizeAttrib, Ji as textureDepthMultisampled2d, Jn as deepEqual, Js as snorm8x4, Ka as isLocationAttrib, Ki as textureDepthCube, Ks as snorm8, La as Vec4u, Li as WgslTextureMultisampled2d, Lr as bool, Ls as sint32x2, Ma as Vec3u, Mi as WgslTextureDepth2d, Mr as ptrStorage, Ms as packedFormats, Na as Vec4b, Ni as WgslTextureDepth2dArray, Nl as WgslComparisonSampler, Nr as ptrUniform, Ns as sint16, Oa as Vec3b, Oi as WgslTexture2dArray, Ol as BuiltinWorkgroupId, Or as vec4u, Os as float32x3, Pa as Vec4f, Pi as WgslTextureDepthCube, Pl as WgslSampler, Pr as ptrWorkgroup, Ps as sint16x2, Qa as m2x2f, Qc as IsBuiltin, Qi as textureStorage2d, Qn as PUBLIC_sizeOf, Qs as uint32, Ra as Void, Ri as texture1d, Rr as f16, Rs as sint32x3, Sa as U32, Si as WgslStorageTexture2dArray, Sl as BuiltinLocalInvocationIndex, Sr as vec3i, Ss as TgpuVertexFormatData, Ta as Vec2h, Ti as WgslTexture, Tl as BuiltinSampleIndex, Tr as vec4f, Ts as float16x4, Ua as isBuiltinAttrib, Ui as textureCubeArray, Us as snorm16, Va as isAlignAttrib, Vi as texture3d, Vr as u16, Vs as sint8x2, Wa as isDecorated, Wi as textureDepth2d, Ws as snorm16x2, Xa as isWgslData, Xc as AnyAttribute, Xi as textureMultisampled2d, Xn as PUBLIC_getLongestContiguousPrefix, Xs as uint16x2, Ya as isWgslArray, Yi as textureExternal, Yn as PUBLIC_alignmentOf, Ys as uint16, Za as isWgslStruct, Zc as HasCustomLocation, Zi as textureStorage1d, Zn as PUBLIC_isContiguous, Zs as uint16x4, _a as Mat4x4f, _l as BuiltinFragDepth, _r as vec2i, aa as Atomic, ac as unorm10_10_10_2, ai as LooseDecorated, ao as v2u, ar as mat4x4f, ba as StorableData, bi as WgslStorageTexture1d, bl as BuiltinInstanceIndex, br as vec3f, bs as FormatToWGSLType, ca as Builtin, cc as unorm16x4, ci as isDisarray, co as v3i, da as F32, dc as unorm8x4, di as isUnstruct, do as v4f, ea as textureStorage3d, ec as uint32x3, el as interpolate, eo as m4x4f, fa as I32, fc as unorm8x4_bgra, fi as Infer, fo as v4i, fr as unstruct, ga as Mat3x3f, gl as BuiltinClipDistances, gr as vec2h, ha as Mat2x2f, hl as AnyBuiltin, ho as _ref, hr as vec2f, ia as AnyWgslStruct, ic as uint8x4, ii as Disarray, il as size, io as v2i, ir as mat3x3f, ja as Vec3i, jc as memoryLayoutOf, ji as WgslTextureCubeArray, jr as ptrPrivate, js as isPackedData, ka as Vec3f, ki as WgslTexture3d, kl as builtin, kr as ptrFn, ks as float32x4, la as Decorated, lc as unorm8, li as isLooseData, lo as v3u, ma as Location, mi as InferPartial, mo as vecBase, mr as vec2b, na as AnyVecInstance, nc as uint8, ni as AnyData, nl as isBuiltin, no as v2b, oa as BaseData, oc as unorm16, oi as Unstruct, oo as v3b, or as matToArray, pa as Interpolate, pi as InferGPU, po as v4u, pr as disarrayOf, qa as isPtr, qi as textureDepthCubeArray, qs as snorm8x2, ra as AnyWgslData, rc as uint8x2, ri as AnyLooseData, rl as location, ro as v2f, rr as mat2x2f, sa as Bool, sc as unorm16x2, si as isData, so as v3f, ta as Align, tc as uint32x4, tl as invariant, to as matBase, ua as F16, uc as unorm8x2, ui as isLooseDecorated, uo as v4b, va as Ptr, vi as WgslExternalTexture, vl as BuiltinFrontFacing, vr as vec2u, wa as Vec2f, wi as WgslStorageTextureProps, wl as BuiltinPosition, wr as vec4b, ws as float16x2, xa as U16, xi as WgslStorageTexture2d, xl as BuiltinLocalInvocationId, xr as vec3h, xs as PackedData, ya as Size, yi as WgslStorageTexture, yl as BuiltinGlobalInvocationId, yr as vec3b, ys as FormatToAcceptedData, za as WgslArray, zi as texture2d, zr as f32, zs as sint32x4 } from "../indexNamedExports-Cdy7USiY.js";
+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, v2i, v2u, v3b, v3f, v3i, v3u, v4b, v4f, 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, InferPartial } 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, InferPartial, 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, 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, v2i, v2u, v3b, v3f, v3i, v3u, v4b, v4f, v4i, v4u, vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u, vecBase };
+  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, InferPartial, 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, v2i, v2u, v3b, v3f, v3i, v3u, v4b, v4f, 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 InferPartial, 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, 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, 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, index_d_exports as t, 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 v2i, type v2u, type v3b, type v3f, type v3i, type v3u, type v4b, type v4f, type v4i, type v4u, vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u, type vecBase };
-//# sourceMappingURL=index.d.ts.map
+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 InferPartial, 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 v2i, type v2u, type v3b, type v3f, type v3i, type v3u, type v4b, type v4f, type v4i, type v4u, vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u, type vecBase };

package/data/index.js

@@ -1,8 +1,29 @@
-import { t as __exportAll } from "../chunk-BYypO7fO.js";
-import { $ as VecBase, An as isAlignAttrib, B as vec2h, Cn as isDisarray, Dt as ptrStorage, En as isUnstruct, Et as ptrPrivate, Fn as isInterpolateAttrib, G as vec3h, H as vec2u, Hn as isSizeAttrib, In as isLocationAttrib, J as vec4b, Jn as isWgslData, K as vec3i, Mn as isBuiltinAttrib, Nn as isDecorated, Ot as ptrUniform, P as struct, Q as vec4u, R as vec2b, Sn as isData, Tn as isLooseDecorated, Tt as ptrHandle, U as vec3b, V as vec2i, Vn as isPtr, W as vec3f, X as vec4h, Y as vec4f, Yn as isWgslStruct, Z as vec4i, _ as mat4x4f, at as i32, d as MatBase, g as mat3x3f, h as mat2x2f, it as f32, jn as isAtomic, kn as Void, kt as ptrWorkgroup, nt as bool, ot as u16, q as vec3u, qn as isWgslArray, rt as f16, st as u32, v as matToArray, wn as isLooseData, wt as ptrFn, yt as _ref, z as vec2f } from "../operators-HTxa_0k9.js";
-import { $ as uint32x4, A as packedFormats, B as sint8x4, C as float16x4, D as float32x4, E as float32x3, F as sint32x2, G as snorm8x2, H as snorm16x2, I as sint32x3, J as uint16x2, K as snorm8x4, L as sint32x4, M as sint16x2, N as sint16x4, O as formatToWGSLType, P as sint32, Q as uint32x3, R as sint8, S as float16x2, T as float32x2, U as snorm16x4, V as snorm16, W as snorm8, X as uint32, Y as uint16x4, Z as uint32x2, at as unorm16x2, ct as unorm8x2, d as isBuiltin, et as uint8, f as location, i as infixOperators, it as unorm16, j as sint16, k as isPackedData, l as interpolate, lt as unorm8x4, m as PUBLIC_sizeOf, n as arrayOf, nt as uint8x4, ot as unorm16x4, p as size, q as uint16, rt as unorm10_10_10_2, s as align, st as unorm8, t as builtin, tt as uint8x2, u as invariant, ut as unorm8x4_bgra, v as PUBLIC_alignmentOf, w as float32, x as float16, z as sint8x2 } from "../builtin-ClEnM-Ye.js";
-import { a as PUBLIC_getLongestContiguousPrefix, i as memoryLayoutOf, n as unstruct, o as PUBLIC_isContiguous, p as sampler, r as disarrayOf, s as atomic, t as deepEqual, u as comparisonSampler } from "../deepEqual-yZXvaV2C.js";
-import { _ as textureMultisampled2d, a as texture2d, b as textureStorage2dArray, c as textureCube, d as textureDepth2dArray, f as textureDepthCube, g as textureExternal, i as texture1d, l as textureCubeArray, m as textureDepthMultisampled2d, o as texture2dArray, p as textureDepthCubeArray, s as texture3d, u as textureDepth2d, v as textureStorage1d, x as textureStorage3d, y as textureStorage2d } from "../texture-Dg5ybJro.js";
+import { __exportAll } 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";
+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 { infixOperators } from "../tgsl/accessProp.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
@@ -161,5 +182,4 @@ assignInfixOperator(MatBase, "sub", Operator.minus);
 assignInfixOperator(MatBase, "mul", Operator.star);
 
 //#endregion
-export { Void, align, PUBLIC_alignmentOf as alignmentOf, arrayOf, atomic, 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, 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, data_exports as t, 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 };
-//# sourceMappingURL=index.js.map
+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 };

package/data/instanceToSchema.d.ts

@@ -0,0 +1,33 @@
+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
+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;
+};
+/**
+ * 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;
+} ? KindToSchemaMap[TKind] : T;
+//#endregion
+export { InstanceToSchema };

package/data/isContiguous.d.ts

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

package/data/isContiguous.js

@@ -0,0 +1,15 @@
+import { getLayoutInfo } from "./schemaMemoryLayout.js";
+
+//#region src/data/isContiguous.ts
+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);
+}
+
+//#endregion
+export { PUBLIC_isContiguous, isContiguous };

package/data/matrix.d.ts

@@ -0,0 +1,126 @@
+import { DualFn } from "../types.js";
+import { Mat2x2f, Mat3x3f, Mat4x4f, m2x2f, m3x3f, m4x4f, v3f } from "./wgslTypes.js";
+import { TgpuComptime } from "../core/function/comptime.js";
+import "../indexNamedExports.js";
+
+//#region src/data/matrix.d.ts
+/**
+ * Returns a 2-by-2 identity matrix.
+ * @returns {m2x2f} The result matrix.
+ */
+declare const identity2: TgpuComptime<() => m2x2f>;
+/**
+ * Returns a 3-by-3 identity matrix.
+ * @returns {m3x3f} The result matrix.
+ */
+declare const identity3: TgpuComptime<() => m3x3f>;
+/**
+ * Returns a 4-by-4 identity matrix.
+ * @returns {m4x4f} The result matrix.
+ */
+declare const identity4: TgpuComptime<() => m4x4f>;
+/**
+ * Creates a 4-by-4 matrix which translates by the given vector v.
+ * @param {v3f} vector - The vector by which to translate.
+ * @returns {m4x4f} The translation matrix.
+ */
+declare const translation4: DualFn<(vector: v3f) => m4x4f>;
+/**
+ * Creates a 4-by-4 matrix which scales in each dimension by an amount given by the corresponding entry in the given vector.
+ * @param {v3f} vector - A vector of three entries specifying the factor by which to scale in each dimension.
+ * @returns {m4x4f} The scaling matrix.
+ */
+declare const scaling4: DualFn<(vector: v3f) => m4x4f>;
+/**
+ * Creates a 4-by-4 matrix which rotates around the x-axis by the given angle.
+ * @param {number} angle - The angle by which to rotate (in radians).
+ * @returns {m4x4f} The rotation matrix.
+ */
+declare const rotationX4: DualFn<(a: number) => m4x4f>;
+/**
+ * Creates a 4-by-4 matrix which rotates around the y-axis by the given angle.
+ * @param {number} angle - The angle by which to rotate (in radians).
+ * @returns {m4x4f} The rotation matrix.
+ */
+declare const rotationY4: DualFn<(a: number) => m4x4f>;
+/**
+ * Creates a 4-by-4 matrix which rotates around the z-axis by the given angle.
+ * @param {number} angle - The angle by which to rotate (in radians).
+ * @returns {m4x4f} The rotation matrix.
+ */
+declare const rotationZ4: DualFn<(a: number) => m4x4f>;
+/**
+ * Schema representing mat2x2f - a matrix with 2 rows and 2 columns, with elements of type f32.
+ * Also a constructor function for this matrix type.
+ *
+ * @example
+ * const zero2x2 = mat2x2f(); // filled with zeros
+ *
+ * @example
+ * const mat = mat2x2f(0, 1, 2, 3);
+ * mat.columns[0] // vec2f(0, 1)
+ * mat.columns[1] // vec2f(2, 3)
+ *
+ * @example
+ * const mat = mat2x2f(
+ *  vec2f(0, 1), // column 0
+ *  vec2f(1, 2), // column 1
+ * );
+ *
+ * @example
+ * const buffer = root.createBuffer(d.mat2x2f, d.mat2x2f(0, 1, 2, 3)); // buffer holding a d.mat2x2f value, with an initial value of ((0, 1), (2, 3))
+ */
+declare const mat2x2f: Mat2x2f;
+/**
+ * Schema representing mat3x3f - a matrix with 3 rows and 3 columns, with elements of type f32.
+ * Also a constructor function for this matrix type.
+ *
+ * @example
+ * const zero3x3 = mat3x3f(); // filled with zeros
+ *
+ * @example
+ * const mat = mat3x3f(0, 1, 2, 3, 4, 5, 6, 7, 8);
+ * mat.columns[0] // vec3f(0, 1, 2)
+ * mat.columns[1] // vec3f(3, 4, 5)
+ * mat.columns[2] // vec3f(6, 7, 8)
+ *
+ * @example
+ * const mat = mat3x3f(
+ *  vec3f(0, 1, 2), // column 0
+ *  vec3f(2, 3, 4), // column 1
+ *  vec3f(5, 6, 7), // column 2
+ * );
+ *
+ * @example
+ * const buffer = root.createBuffer(d.mat3x3f, d.mat3x3f()); // buffer holding a d.mat3x3f value, with an initial value of mat3x3f filled with zeros
+ */
+declare const mat3x3f: Mat3x3f;
+/**
+ * Schema representing mat4x4f - a matrix with 4 rows and 4 columns, with elements of type f32.
+ * Also a constructor function for this matrix type.
+ *
+ * @example
+ * const zero4x4 = mat4x4f(); // filled with zeros
+ *
+ * @example
+ * const mat = mat4x4f(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+ * mat.columns[0] // vec4f(0, 1, 2, 3)
+ * mat.columns[1] // vec4f(4, 5, 6, 7)
+ * mat.columns[2] // vec4f(8, 9, 10, 11)
+ * mat.columns[3] // vec4f(12, 13, 14, 15)
+ *
+ * @example
+ * const mat = mat4x4f(
+ *  vec4f(0, 1, 2, 3),     // column 0
+ *  vec4f(4, 5, 6, 7),     // column 1
+ *  vec4f(8, 9, 10, 11),   // column 2
+ *  vec4f(12, 13, 14, 15), // column 3
+ * );
+ *
+ * @example
+ * const buffer = root.createBuffer(d.mat4x4f, d.mat4x4f()); // buffer holding a d.mat4x4f value, with an initial value of mat4x4f filled with zeros
+ */
+declare const mat4x4f: Mat4x4f;
+declare function matToArray(mat: m2x2f | m3x3f | m4x4f): number[];
+//#endregion
+export { identity2, identity3, identity4, mat2x2f, mat3x3f, mat4x4f, matToArray, rotationX4, rotationY4, rotationZ4, scaling4, translation4 };