typegpu 0.3.3 → 0.3.4

package/data/index.js

@@ -1,193 +1,2 @@
-import {
-  PUBLIC_alignmentOf,
-  PUBLIC_sizeOf,
-  align,
-  arrayOf,
-  atomic,
-  bool,
-  builtin,
-  disarrayOf,
-  f16,
-  f32,
-  float16,
-  float16x2,
-  float16x4,
-  float32,
-  float32x2,
-  float32x3,
-  float32x4,
-  i32,
-  interpolate,
-  isAlignAttrib,
-  isAtomic,
-  isBuiltin,
-  isBuiltinAttrib,
-  isData,
-  isDecorated,
-  isDisarray,
-  isInterpolateAttrib,
-  isLocationAttrib,
-  isLooseData,
-  isLooseDecorated,
-  isPtrFn,
-  isSizeAttrib,
-  isUnstruct,
-  isWgslArray,
-  isWgslData,
-  isWgslStruct,
-  location,
-  mat2x2f,
-  mat3x3f,
-  mat4x4f,
-  matToArray,
-  packedFormats,
-  ptrFn,
-  sint16,
-  sint16x2,
-  sint16x4,
-  sint32,
-  sint32x2,
-  sint32x3,
-  sint32x4,
-  sint8,
-  sint8x2,
-  sint8x4,
-  size,
-  snorm16,
-  snorm16x2,
-  snorm16x4,
-  snorm8,
-  snorm8x2,
-  snorm8x4,
-  struct,
-  u32,
-  uint16,
-  uint16x2,
-  uint16x4,
-  uint32,
-  uint32x2,
-  uint32x3,
-  uint32x4,
-  uint8,
-  uint8x2,
-  uint8x4,
-  unorm10_10_10_2,
-  unorm16,
-  unorm16x2,
-  unorm16x4,
-  unorm8,
-  unorm8x2,
-  unorm8x4,
-  unorm8x4_bgra,
-  unstruct
-} from "../chunk-2ZAQFPSX.js";
-import {
-  vec2f,
-  vec2h,
-  vec2i,
-  vec2u,
-  vec3f,
-  vec3h,
-  vec3i,
-  vec3u,
-  vec4f,
-  vec4h,
-  vec4i,
-  vec4u
-} from "../chunk-DDEF2Y4S.js";
-export {
-  align,
-  PUBLIC_alignmentOf as alignmentOf,
-  arrayOf,
-  atomic,
-  bool,
-  builtin,
-  disarrayOf,
-  f16,
-  f32,
-  float16,
-  float16x2,
-  float16x4,
-  float32,
-  float32x2,
-  float32x3,
-  float32x4,
-  i32,
-  interpolate,
-  isAlignAttrib,
-  isAtomic,
-  isBuiltin,
-  isBuiltinAttrib,
-  isData,
-  isDecorated,
-  isDisarray,
-  isInterpolateAttrib,
-  isLocationAttrib,
-  isLooseData,
-  isLooseDecorated,
-  isPtrFn,
-  isSizeAttrib,
-  isUnstruct,
-  isWgslArray,
-  isWgslData,
-  isWgslStruct,
-  location,
-  mat2x2f,
-  mat3x3f,
-  mat4x4f,
-  matToArray,
-  packedFormats,
-  ptrFn,
-  sint16,
-  sint16x2,
-  sint16x4,
-  sint32,
-  sint32x2,
-  sint32x3,
-  sint32x4,
-  sint8,
-  sint8x2,
-  sint8x4,
-  size,
-  PUBLIC_sizeOf as sizeOf,
-  snorm16,
-  snorm16x2,
-  snorm16x4,
-  snorm8,
-  snorm8x2,
-  snorm8x4,
-  struct,
-  u32,
-  uint16,
-  uint16x2,
-  uint16x4,
-  uint32,
-  uint32x2,
-  uint32x3,
-  uint32x4,
-  uint8,
-  uint8x2,
-  uint8x4,
-  unorm10_10_10_2,
-  unorm16,
-  unorm16x2,
-  unorm16x4,
-  unorm8,
-  unorm8x2,
-  unorm8x4,
-  unorm8x4_bgra,
-  unstruct,
-  vec2f,
-  vec2h,
-  vec2i,
-  vec2u,
-  vec3f,
-  vec3h,
-  vec3i,
-  vec3u,
-  vec4f,
-  vec4h,
-  vec4i,
-  vec4u
-};
+import{$ as ha,A as I,Aa as Fa,B as J,Ba as Ga,C as K,D as L,Da as Ha,E as M,Ea as Ia,F as N,Fa as Ja,G as O,Ga as Ka,H as P,Ha as La,I as Q,J as R,Ja as Ma,K as S,L as T,M as U,N as V,O as W,P as X,Q as Y,R as Z,S as _,T as $,U as aa,V as ba,W as ca,X as da,Y as ea,Z as fa,_ as ga,a,aa as ia,b,ba as ja,c,ca as ka,d,da as la,e,ea as ma,f,fa as na,g,ga as oa,h,ha as pa,i,ia as qa,j,ja as ra,k,ka as sa,l,la as ta,m,ma as ua,n,na as va,o,p,q,qa as wa,sa as xa,ta as ya,u as r,ua as za,v as s,va as Aa,w as t,wa as Ba,x as u,xa as Ca,ya as Da,z as v,za as Ea}from"../chunk-RW6OZYQI.js";import{n as w,o as x,p as y,q as z,r as A,s as B,t as C,u as D,v as E,w as F,x as G,y as H}from"../chunk-A2QB4MSZ.js";export{Ha as align,wa as alignmentOf,ya as arrayOf,Ga as atomic,l as bool,Ma as builtin,Aa as disarrayOf,p as f16,o as f32,fa as float16,ga as float16x2,ha as float16x4,ia as float32,ja as float32x2,ka as float32x3,la as float32x4,n as i32,Ka as interpolate,f as isAlignAttrib,e as isAtomic,La as isBuiltin,j as isBuiltinAttrib,v as isData,k as isDecorated,s as isDisarray,i as isInterpolateAttrib,h as isLocationAttrib,r as isLooseData,u as isLooseDecorated,d as isPtrFn,g as isSizeAttrib,t as isUnstruct,b as isWgslArray,a as isWgslData,c as isWgslStruct,Ja as location,Ca as mat2x2f,Da as mat3x3f,Ea as mat4x4f,Fa as matToArray,I as packedFormats,za as ptrFn,Y as sint16,Z as sint16x2,_ as sint16x4,qa as sint32,ra as sint32x2,sa as sint32x3,ta as sint32x4,M as sint8,N as sint8x2,O as sint8x4,Ia as size,xa as sizeOf,ca as snorm16,da as snorm16x2,ea as snorm16x4,S as snorm8,T as snorm8x2,U as snorm8x4,q as struct,m as u32,V as uint16,W as uint16x2,X as uint16x4,ma as uint32,na as uint32x2,oa as uint32x3,pa as uint32x4,J as uint8,K as uint8x2,L as uint8x4,ua as unorm10_10_10_2,$ as unorm16,aa as unorm16x2,ba as unorm16x4,P as unorm8,Q as unorm8x2,R as unorm8x4,va as unorm8x4_bgra,Ba as unstruct,w as vec2f,x as vec2h,y as vec2i,z as vec2u,A as vec3f,B as vec3h,C as vec3i,D as vec3u,E as vec4f,F as vec4h,G as vec4i,H as vec4u};
 //# sourceMappingURL=index.js.map

package/index-DtGAMBfJ.d.cts

@@ -0,0 +1,407 @@
+import { D as Decorated, U as U32, w as Builtin, d as Vec4f, W as WgslArray, F as F32, l as Vec3u, B as BaseWgslData, x as Align, S as Size, L as Location, y as Interpolate, z as InterpolationType, o as AnyData, P as PerspectiveOrLinearInterpolationType, C as PerspectiveOrLinearInterpolatableData, E as FlatInterpolationType, G as FlatInterpolatableData, A as AnyWgslData, H as LooseDecorated, J as AnyLooseData, t as WgslTypeLiteral, N as LooseTypeLiteral, O as WgslStruct, Q as PtrFn, p as Disarray, q as Unstruct, R as m2x2f, X as m3x3f, Y as m4x4f, Z as Mat2x2f, _ as v2f, $ as Mat3x3f, a0 as v3f, a1 as Mat4x4f, a2 as v4f, b as I32, a3 as Atomic, I as Infer$1 } from './wgslTypes-DHAmU620.cjs';
+
+/**
+ * Can be assigned a name. Not to be confused with
+ * being able to HAVE a name.
+ */
+interface TgpuNamable {
+    $name(label?: string | undefined): this;
+}
+
+/**
+ * Strips schema types down to their most basic forms. (native -> exotic)
+ * This is used by schema constructors to be able to ingest native schemas (created by TypeGPU), and
+ * spit out a type that matches non-native schemas as well.
+ */
+type Exotic<T> = T extends {
+    readonly '~exotic': infer TExotic;
+} ? TExotic : T;
+type ExoticArray<T> = T extends unknown[] | [] ? {
+    [Key in keyof T]: Exotic<T[Key]>;
+} : T;
+type ExoticRecord<T> = T extends Record<string | number | symbol, unknown> ? {
+    [Key in keyof T]: Exotic<T[Key]>;
+} : T;
+
+type BuiltinVertexIndex = Decorated<U32, [Builtin<'vertex_index'>]>;
+type BuiltinInstanceIndex = Decorated<U32, [Builtin<'instance_index'>]>;
+type BuiltinPosition = Decorated<Vec4f, [Builtin<'position'>]>;
+type BuiltinClipDistances = Decorated<WgslArray<U32>, [
+    Builtin<'clip_distances'>
+]>;
+type BuiltinFrontFacing = Decorated<F32, [Builtin<'front_facing'>]>;
+type BuiltinFragDepth = Decorated<F32, [Builtin<'frag_depth'>]>;
+type BuiltinSampleIndex = Decorated<U32, [Builtin<'sample_index'>]>;
+type BuiltinSampleMask = Decorated<U32, [Builtin<'sample_mask'>]>;
+type BuiltinLocalInvocationId = Decorated<Vec3u, [
+    Builtin<'local_invocation_id'>
+]>;
+type BuiltinLocalInvocationIndex = Decorated<U32, [
+    Builtin<'local_invocation_index'>
+]>;
+type BuiltinGlobalInvocationId = Decorated<Vec3u, [
+    Builtin<'global_invocation_id'>
+]>;
+type BuiltinWorkgroupId = Decorated<Vec3u, [Builtin<'workgroup_id'>]>;
+type BuiltinNumWorkgroups = Decorated<Vec3u, [
+    Builtin<'num_workgroups'>
+]>;
+declare const builtin: {
+    readonly vertexIndex: BuiltinVertexIndex;
+    readonly instanceIndex: BuiltinInstanceIndex;
+    readonly position: BuiltinPosition;
+    readonly clipDistances: BuiltinClipDistances;
+    readonly frontFacing: BuiltinFrontFacing;
+    readonly fragDepth: BuiltinFragDepth;
+    readonly sampleIndex: BuiltinSampleIndex;
+    readonly sampleMask: BuiltinSampleMask;
+    readonly localInvocationId: BuiltinLocalInvocationId;
+    readonly localInvocationIndex: BuiltinLocalInvocationIndex;
+    readonly globalInvocationId: BuiltinGlobalInvocationId;
+    readonly workgroupId: BuiltinWorkgroupId;
+    readonly numWorkgroups: BuiltinNumWorkgroups;
+};
+type AnyBuiltin = (typeof builtin)[keyof typeof builtin];
+type AnyComputeBuiltin = BuiltinLocalInvocationId | BuiltinLocalInvocationIndex | BuiltinGlobalInvocationId | BuiltinWorkgroupId | BuiltinNumWorkgroups;
+type OmitBuiltins<S> = S extends AnyBuiltin ? never : S extends BaseWgslData ? S : {
+    [Key in keyof S as S[Key] extends AnyBuiltin ? never : Key]: S[Key];
+};
+
+declare const builtinNames: readonly ["vertex_index", "instance_index", "position", "clip_distances", "front_facing", "frag_depth", "sample_index", "sample_mask", "fragment", "local_invocation_id", "local_invocation_index", "global_invocation_id", "workgroup_id", "num_workgroups"];
+type BuiltinName = (typeof builtinNames)[number];
+type AnyAttribute = Align<number> | Size<number> | Location<number> | Builtin<BuiltinName> | Interpolate<InterpolationType>;
+type ExtractAttributes<T> = T extends {
+    readonly attribs: unknown[];
+} ? T['attribs'] : [];
+type Undecorate<T> = T extends {
+    readonly inner: infer TInner;
+} ? TInner : T;
+/**
+ * Decorates a data-type `TData` with an attribute `TAttrib`.
+ *
+ * - if `TData` is loose
+ *   - if `TData` is already `LooseDecorated`
+ *     - Prepend `TAttrib` to the existing attribute tuple.
+ *   - else
+ *     - Wrap `TData` with `LooseDecorated` and a single attribute `[TAttrib]`
+ * - else
+ *   - if `TData` is already `Decorated`
+ *     - Prepend `TAttrib` to the existing attribute tuple.
+ *   - else
+ *     - Wrap `TData` with `Decorated` and a single attribute `[TAttrib]`
+ */
+type Decorate<TData extends BaseWgslData, TAttrib extends AnyAttribute> = TData['type'] extends WgslTypeLiteral ? Decorated<Undecorate<TData>, [TAttrib, ...ExtractAttributes<TData>]> : TData['type'] extends LooseTypeLiteral ? LooseDecorated<Undecorate<TData>, [TAttrib, ...ExtractAttributes<TData>]> : never;
+type IsBuiltin<T> = ExtractAttributes<T>[number] extends [] ? false : ExtractAttributes<T>[number] extends Builtin<BuiltinName> ? true : false;
+type HasCustomLocation<T> = ExtractAttributes<T>[number] extends [] ? false : ExtractAttributes<T>[number] extends Location<number> ? true : false;
+/**
+ * Gives the wrapped data-type a custom byte alignment. Useful in order to
+ * fulfill uniform alignment requirements.
+ *
+ * @example
+ * const Data = d.struct({
+ *   a: u32, // takes up 4 bytes
+ *   // 12 bytes of padding, because `b` is custom aligned to multiples of 16 bytes
+ *   b: d.align(16, u32),
+ * });
+ *
+ * @param alignment The multiple of bytes this data should align itself to.
+ * @param data The data-type to align.
+ */
+declare function align<TAlign extends number, TData extends AnyData>(alignment: TAlign, data: TData): Decorate<Exotic<TData>, Align<TAlign>>;
+/**
+ * Adds padding bytes after the wrapped data-type, until the whole value takes up `size` bytes.
+ *
+ * @example
+ * const Data = d.struct({
+ *   a: d.size(16, u32), // takes up 16 bytes, instead of 4
+ *   b: u32, // starts at byte 16, because `a` has a custom size
+ * });
+ *
+ * @param size The amount of bytes that should be reserved for this data-type.
+ * @param data The data-type to wrap.
+ */
+declare function size<TSize extends number, TData extends AnyData>(size: TSize, data: TData): Decorate<Exotic<TData>, Size<TSize>>;
+/**
+ * Assigns an explicit numeric location to a struct member or a parameter that has this type.
+ *
+ * @example
+ * const VertexOutput = {
+ *   a: d.u32, // has implicit location 0
+ *   b: d.location(5, d.u32),
+ *   c: d.u32, // has implicit location 6
+ * };
+ *
+ * @param location The explicit numeric location.
+ * @param data The data-type to wrap.
+ */
+declare function location<TLocation extends number, TData extends AnyData>(location: TLocation, data: TData): Decorate<Exotic<TData>, Location<TLocation>>;
+/**
+ * Specifies how user-defined vertex shader output (fragment shader input)
+ * must be interpolated.
+ *
+ * Tip: Integer outputs cannot be interpolated.
+ *
+ * @example
+ * const VertexOutput = {
+ *   a: d.f32, // has implicit 'perspective, center' interpolation
+ *   b: d.interpolate('linear, sample', d.f32),
+ * };
+ *
+ * @param interpolationType How data should be interpolated.
+ * @param data The data-type to wrap.
+ */
+declare function interpolate<TInterpolation extends PerspectiveOrLinearInterpolationType, TData extends PerspectiveOrLinearInterpolatableData>(interpolationType: TInterpolation, data: TData): Decorate<Exotic<TData>, Interpolate<TInterpolation>>;
+/**
+ * Specifies how user-defined vertex shader output (fragment shader input)
+ * must be interpolated.
+ *
+ * Tip: Default sampling method of `flat` is `first`. Unless you specifically
+ * need deterministic behavior provided by `'flat, first'`, prefer explicit
+ * `'flat, either'` as it could be slightly faster in hardware.
+ *
+ * @example
+ * const VertexOutput = {
+ *   a: d.f32, // has implicit 'perspective, center' interpolation
+ *   b: d.interpolate('flat, either', d.u32), // integer outputs cannot interpolate
+ * };
+ *
+ * @param interpolationType How data should be interpolated.
+ * @param data The data-type to wrap.
+ */
+declare function interpolate<TInterpolation extends FlatInterpolationType, TData extends FlatInterpolatableData>(interpolationType: TInterpolation, data: TData): Decorate<Exotic<TData>, Interpolate<TInterpolation>>;
+declare function isBuiltin<T extends Decorated<AnyWgslData, AnyAttribute[]> | LooseDecorated<AnyLooseData, AnyAttribute[]>>(value: T | unknown): value is T;
+
+type Default<T, TDefault> = unknown extends T ? TDefault : T extends undefined ? TDefault : T;
+type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * Removes properties from record type that extend `Prop`
+ */
+type OmitProps<T extends Record<string, unknown>, Prop> = Pick<T, {
+    [Key in keyof T]: T[Key] extends Prop ? never : Key;
+}[keyof T]>;
+/**
+ * The opposite of Readonly<T>
+ */
+type Mutable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+
+/**
+ * Struct schema constructed via `d.struct` function.
+ *
+ * Responsible for handling reading and writing struct values
+ * between binary and JS representation. Takes into account
+ * the `byteAlignment` requirement of its members.
+ */
+interface TgpuStruct<TProps extends Record<string, BaseWgslData>> extends WgslStruct<TProps>, TgpuNamable {
+    readonly '~exotic': WgslStruct<TProps>;
+}
+/**
+ * Creates a struct schema that can be used to construct GPU buffers.
+ * Ensures proper alignment and padding of properties (as opposed to a `d.unstruct` schema).
+ * The order of members matches the passed in properties object.
+ *
+ * @example
+ * const CircleStruct = d.struct({ radius: d.f32, pos: d.vec3f });
+ *
+ * @param props Record with `string` keys and `TgpuData` values,
+ * each entry describing one struct member.
+ */
+declare const struct: <TProps extends Record<string, AnyWgslData>>(props: TProps) => TgpuStruct<Prettify<ExoticRecord<TProps>>>;
+
+/**
+ * Array schema constructed via `d.arrayOf` function.
+ *
+ * Responsible for handling reading and writing array values
+ * between binary and JS representation. Takes into account
+ * the `byteAlignment` requirement of its elementType.
+ */
+interface TgpuArray<TElement extends AnyWgslData> extends WgslArray<TElement> {
+    readonly '~exotic': WgslArray<Exotic<TElement>>;
+}
+/**
+ * Creates an array schema that can be used to construct gpu buffers.
+ * Describes arrays with fixed-size length, storing elements of the same type.
+ *
+ * @example
+ * const LENGTH = 3;
+ * const array = d.arrayOf(d.u32, LENGTH);
+ *
+ * @param elementType The type of elements in the array.
+ * @param elementCount The number of elements in the array.
+ */
+declare const arrayOf: <TElement extends AnyWgslData>(elementType: TElement, elementCount: number) => TgpuArray<Exotic<TElement>>;
+
+declare function ptrFn<T extends AnyData>(inner: T): PtrFn<Exotic<T>>;
+
+/**
+ * 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);
+ *
+ * @param elementType The type of elements in the array.
+ * @param count The number of elements in the array.
+ */
+declare const disarrayOf: <TElement extends AnyData>(elementType: TElement, count: number) => Disarray<Exotic<TElement>>;
+
+/**
+ * Creates a loose struct schema that can be used to construct vertex buffers.
+ * Describes structs with members of both loose and non-loose types.
+ *
+ * The order of members matches the passed in properties object.
+ * Members are not aligned in respect to their `byteAlignment`,
+ * unless they are explicitly decorated with the custom align attribute
+ * via `d.align` function.
+ *
+ * @example
+ * const CircleStruct = d.unstruct({ radius: d.f32, pos: d.vec3f }); // packed struct with no padding
+ *
+ * @example
+ * const CircleStruct = d.unstruct({ radius: d.f32, pos: d.align(16, d.vec3f) });
+ *
+ * @param properties Record with `string` keys and `TgpuData` or `TgpuLooseData` values,
+ * each entry describing one struct member.
+ */
+declare const unstruct: <TProps extends Record<string, BaseWgslData>>(properties: TProps) => Unstruct<ExoticRecord<TProps>>;
+
+/**
+ * Type of the `d.mat2x2f` object/function: matrix data type schema/constructor
+ */
+type NativeMat2x2f = Mat2x2f & {
+    '~exotic': Mat2x2f;
+} & ((...elements: number[]) => m2x2f) & ((...columns: v2f[]) => m2x2f) & (() => m2x2f);
+/**
+ *
+ * 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[0] // vec2f(0, 1)
+ * mat[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: NativeMat2x2f;
+/**
+ * Type of the `d.mat3x3f` object/function: matrix data type schema/constructor
+ */
+type NativeMat3x3f = Mat3x3f & {
+    '~exotic': Mat3x3f;
+} & ((...elements: number[]) => m3x3f) & ((...columns: v3f[]) => m3x3f) & (() => m3x3f);
+/**
+ *
+ * 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[0] // vec3f(0, 1, 2)
+ * mat[1] // vec3f(3, 4, 5)
+ * mat[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: NativeMat3x3f;
+/**
+ * Type of the `d.mat4x4f` object/function: matrix data type schema/constructor
+ */
+type NativeMat4x4f = Mat4x4f & {
+    '~exotic': Mat4x4f;
+} & ((...elements: number[]) => m4x4f) & ((...columns: v4f[]) => m4x4f) & (() => m4x4f);
+/**
+ *
+ * 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 = mat3x3f(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+ * mat[0] // vec4f(0, 1, 2, 3)
+ * mat[1] // vec4f(4, 5, 6, 7)
+ * mat[2] // vec4f(8, 9, 10, 11)
+ * mat[3] // vec4f(12, 13, 14, 15)
+ *
+ * @example
+ * const mat = mat3x3f(
+ *  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: NativeMat4x4f;
+declare function matToArray(mat: m2x2f | m3x3f | m4x4f): number[];
+
+/**
+ * Marks a concrete integer scalar type schema (u32 or i32) as a WGSL atomic.
+ *
+ * @example
+ * const atomicU32 = d.atomic(d.u32);
+ * const atomicI32 = d.atomic(d.i32);
+ *
+ * @param data Underlying type schema.
+ */
+declare function atomic<TSchema extends U32 | I32>(data: TSchema): Atomic<Exotic<TSchema>>;
+
+/**
+ * Returns the size (in bytes) of data represented by the `schema`.
+ */
+declare function PUBLIC_sizeOf(schema: AnyData): number;
+
+/**
+ * Returns the alignment (in bytes) of data represented by the `schema`.
+ */
+declare function PUBLIC_alignmentOf(schema: AnyData): number;
+
+/**
+ * @module typegpu/data
+ */
+
+/**
+ * Extracts the inferred representation of a resource.
+ * @example
+ * type A = Infer<F32> // => number
+ * type B = Infer<TgpuArray<F32>> // => number[]
+ */
+type Infer<T> = Infer$1<Exotic<T>>;
+
+export { type AnyAttribute as A, type BuiltinVertexIndex as B, type BuiltinPosition as C, type Default as D, type Exotic as E, type BuiltinClipDistances as F, type BuiltinFrontFacing as G, type HasCustomLocation as H, type IsBuiltin as I, type BuiltinFragDepth as J, type BuiltinSampleIndex as K, type BuiltinSampleMask as L, type Mutable as M, type BuiltinLocalInvocationId as N, type OmitBuiltins as O, type Prettify as P, type BuiltinLocalInvocationIndex as Q, type BuiltinGlobalInvocationId as R, type BuiltinWorkgroupId as S, type TgpuNamable as T, type UnionToIntersection as U, type BuiltinNumWorkgroups as V, type AnyBuiltin as W, type AnyComputeBuiltin as a, type Decorate as b, type TgpuStruct as c, type OmitProps as d, type Infer as e, type ExoticArray as f, type TgpuArray as g, arrayOf as h, disarrayOf as i, mat3x3f as j, mat4x4f as k, matToArray as l, mat2x2f as m, atomic as n, align as o, ptrFn as p, size as q, location as r, struct as s, interpolate as t, unstruct as u, isBuiltin as v, PUBLIC_sizeOf as w, PUBLIC_alignmentOf as x, builtin as y, type BuiltinInstanceIndex as z };