typegpu 0.2.0-alpha.0 → 0.2.0

package/data/index.d.cts

@@ -1,7 +1,89 @@
-import { AnySchema, Schema, Unwrap, ISerialOutput, ParseUnwrapped, ISerialInput, MaxValue, IMeasurer, ISchema, UnwrapRecord } from 'typed-binary';
+import { Unwrap, AnySchema, Schema, ISerialOutput, ParseUnwrapped, ISerialInput, MaxValue, IMeasurer, ISchema, UnwrapRecord } from 'typed-binary';
 export { Parsed, Unwrap } from 'typed-binary';
-import { r as TgpuData, R as ResolutionCtx, A as AnyTgpuData, a as TgpuNamable, x as AnyTgpuLooseData, y as TgpuLooseData, z as vec2f, o as vec3f, C as vec4f, N as NumberArrayView, D as Vec2u, V as Vec4u, G as Vec2i, i as Vec4i, H as Vec2f, j as Vec4f, F as F32, J as Vec3f, h as U32, K as Vec3u, I as I32, L as Vec3i, M as TgpuPointer } from '../types-qmW7FFqN.cjs';
-export { P as Bool, Z as VecKind, Q as bool, Y as f32, X as i32, W as u32, _ as vec2i, $ as vec2u, p as vec3i, q as vec3u, a0 as vec4i, a1 as vec4u, v as vecBase } from '../types-qmW7FFqN.cjs';
+import { A as AnyTgpuData, x as AnyTgpuLooseData, r as TgpuData, y as TgpuLooseData, R as ResolutionCtx, a as TgpuNamable, z as vec2f, o as vec3f, C as vec4f, N as NumberArrayView, D as Vec2u, V as Vec4u, G as Vec2i, i as Vec4i, H as Vec2f, j as Vec4f, F as F32, J as Vec3f, h as U32, K as Vec3u, I as I32, L as Vec3i, M as TgpuPointer } from '../types-CGmVkuAt.cjs';
+export { P as Bool, Z as VecKind, Q as bool, Y as f32, X as i32, W as u32, _ as vec2i, $ as vec2u, p as vec3i, q as vec3u, a0 as vec4i, a1 as vec4u, v as vecBase } from '../types-CGmVkuAt.cjs';
+
+interface TgpuBaseArray<TElement extends AnyTgpuData | AnyTgpuLooseData = AnyTgpuData | AnyTgpuLooseData> {
+    readonly elementType: TElement;
+    readonly elementCount: number;
+    readonly stride: number;
+}
+/**
+ * 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 AnyTgpuData> extends TgpuBaseArray<TElement>, TgpuData<Unwrap<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 count The number of elements in the array.
+ */
+declare const arrayOf: <TElement extends AnyTgpuData>(elementType: TElement, count: number) => TgpuArray<TElement>;
+/**
+ * Array schema constructed via `d.looseArrayOf` function.
+ *
+ * Useful for defining vertex buffers.
+ * 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.
+ */
+interface TgpuLooseArray<TElement extends AnyTgpuData | AnyTgpuLooseData> extends TgpuBaseArray<TElement>, TgpuLooseData<Unwrap<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 looseArray = d.looseArrayOf(d.vec3f, 3); // packed array of vec3f
+ *
+ * @example
+ * const looseArray = d.looseArrayOf(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 looseArrayOf: <TElement extends AnyTgpuData | AnyTgpuLooseData>(elementType: TElement, count: number) => TgpuLooseArray<TElement>;
+/**
+ * Checks whether passed in value is an array schema,
+ * as opposed to, e.g., a looseArray schema.
+ *
+ * Array schemas can be used to describe uniform and storage buffers,
+ * whereas looseArray schemas cannot.
+ *
+ * @example
+ * isArraySchema(d.arrayOf(d.u32, 4)) // true
+ * isArraySchema(d.looseArrayOf(d.u32, 4)) // false
+ * isArraySchema(d.vec3f) // false
+ */
+declare function isArraySchema<T extends TgpuArray<AnyTgpuData>>(schema: T | unknown): schema is T;
+/**
+ * Checks whether the passed in value is a looseArray schema,
+ * as opposed to, e.g., a regular array schema.
+ *
+ * Array schemas can be used to describe uniform and storage buffers,
+ * whereas looseArray schemas cannot. Loose arrays are useful for
+ * defining vertex buffers instead.
+ *
+ * @example
+ * isLooseArraySchema(d.arrayOf(d.u32, 4)) // false
+ * isLooseArraySchema(d.looseArrayOf(d.u32, 4)) // true
+ * isLooseArraySchema(d.vec3f) // false
+ */
+declare function isLooseArraySchema<T extends TgpuLooseArray<AnyTgpuData>>(schema: T | unknown): schema is T;
 
 declare class SimpleTgpuData<TSchema extends AnySchema> extends Schema<Unwrap<TSchema>> implements TgpuData<Unwrap<TSchema>> {
     readonly size: number;
@@ -106,88 +188,6 @@ declare function isStructSchema<T extends TgpuStruct<Record<string, AnyTgpuData>
  */
 declare function isLooseStructSchema<T extends TgpuLooseStruct<Record<string, AnyTgpuData | AnyTgpuLooseData>>>(schema: T | unknown): schema is T;
 
-interface TgpuBaseArray<TElement extends AnyTgpuData | AnyTgpuLooseData = AnyTgpuData | AnyTgpuLooseData> {
-    readonly elementType: TElement;
-    readonly elementCount: number;
-    readonly stride: number;
-}
-/**
- * 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 AnyTgpuData> extends TgpuBaseArray<TElement>, TgpuData<Unwrap<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 count The number of elements in the array.
- */
-declare const arrayOf: <TElement extends AnyTgpuData>(elementType: TElement, count: number) => TgpuArray<TElement>;
-/**
- * Array schema constructed via `d.looseArrayOf` function.
- *
- * Useful for defining vertex buffers.
- * 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.
- */
-interface TgpuLooseArray<TElement extends AnyTgpuData | AnyTgpuLooseData> extends TgpuBaseArray<TElement>, TgpuLooseData<Unwrap<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 looseArray = d.looseArrayOf(d.vec3f, 3); // packed array of vec3f
- *
- * @example
- * const looseArray = d.looseArrayOf(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 looseArrayOf: <TElement extends AnyTgpuData | AnyTgpuLooseData>(elementType: TElement, count: number) => TgpuLooseArray<TElement>;
-/**
- * Checks whether passed in value is an array schema,
- * as opposed to, e.g., a looseArray schema.
- *
- * Array schemas can be used to describe uniform and storage buffers,
- * whereas looseArray schemas cannot.
- *
- * @example
- * isArraySchema(d.arrayOf(d.u32, 4)) // true
- * isArraySchema(d.looseArrayOf(d.u32, 4)) // false
- * isArraySchema(d.vec3f) // false
- */
-declare function isArraySchema<T extends TgpuArray<AnyTgpuData>>(schema: T | unknown): schema is T;
-/**
- * Checks whether the passed in value is a looseArray schema,
- * as opposed to, e.g., a regular array schema.
- *
- * Array schemas can be used to describe uniform and storage buffers,
- * whereas looseArray schemas cannot. Loose arrays are useful for
- * defining vertex buffers instead.
- *
- * @example
- * isLooseArraySchema(d.arrayOf(d.u32, 4)) // false
- * isLooseArraySchema(d.looseArrayOf(d.u32, 4)) // true
- * isLooseArraySchema(d.vec3f) // false
- */
-declare function isLooseArraySchema<T extends TgpuLooseArray<AnyTgpuData>>(schema: T | unknown): schema is T;
-
 interface matBase<TColumn> extends NumberArrayView {
     readonly columns: readonly TColumn[];
     elements(): Iterable<number>;

package/data/index.d.ts

@@ -1,7 +1,89 @@
-import { AnySchema, Schema, Unwrap, ISerialOutput, ParseUnwrapped, ISerialInput, MaxValue, IMeasurer, ISchema, UnwrapRecord } from 'typed-binary';
+import { Unwrap, AnySchema, Schema, ISerialOutput, ParseUnwrapped, ISerialInput, MaxValue, IMeasurer, ISchema, UnwrapRecord } from 'typed-binary';
 export { Parsed, Unwrap } from 'typed-binary';
-import { r as TgpuData, R as ResolutionCtx, A as AnyTgpuData, a as TgpuNamable, x as AnyTgpuLooseData, y as TgpuLooseData, z as vec2f, o as vec3f, C as vec4f, N as NumberArrayView, D as Vec2u, V as Vec4u, G as Vec2i, i as Vec4i, H as Vec2f, j as Vec4f, F as F32, J as Vec3f, h as U32, K as Vec3u, I as I32, L as Vec3i, M as TgpuPointer } from '../types-qmW7FFqN.js';
-export { P as Bool, Z as VecKind, Q as bool, Y as f32, X as i32, W as u32, _ as vec2i, $ as vec2u, p as vec3i, q as vec3u, a0 as vec4i, a1 as vec4u, v as vecBase } from '../types-qmW7FFqN.js';
+import { A as AnyTgpuData, x as AnyTgpuLooseData, r as TgpuData, y as TgpuLooseData, R as ResolutionCtx, a as TgpuNamable, z as vec2f, o as vec3f, C as vec4f, N as NumberArrayView, D as Vec2u, V as Vec4u, G as Vec2i, i as Vec4i, H as Vec2f, j as Vec4f, F as F32, J as Vec3f, h as U32, K as Vec3u, I as I32, L as Vec3i, M as TgpuPointer } from '../types-CGmVkuAt.js';
+export { P as Bool, Z as VecKind, Q as bool, Y as f32, X as i32, W as u32, _ as vec2i, $ as vec2u, p as vec3i, q as vec3u, a0 as vec4i, a1 as vec4u, v as vecBase } from '../types-CGmVkuAt.js';
+
+interface TgpuBaseArray<TElement extends AnyTgpuData | AnyTgpuLooseData = AnyTgpuData | AnyTgpuLooseData> {
+    readonly elementType: TElement;
+    readonly elementCount: number;
+    readonly stride: number;
+}
+/**
+ * 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 AnyTgpuData> extends TgpuBaseArray<TElement>, TgpuData<Unwrap<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 count The number of elements in the array.
+ */
+declare const arrayOf: <TElement extends AnyTgpuData>(elementType: TElement, count: number) => TgpuArray<TElement>;
+/**
+ * Array schema constructed via `d.looseArrayOf` function.
+ *
+ * Useful for defining vertex buffers.
+ * 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.
+ */
+interface TgpuLooseArray<TElement extends AnyTgpuData | AnyTgpuLooseData> extends TgpuBaseArray<TElement>, TgpuLooseData<Unwrap<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 looseArray = d.looseArrayOf(d.vec3f, 3); // packed array of vec3f
+ *
+ * @example
+ * const looseArray = d.looseArrayOf(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 looseArrayOf: <TElement extends AnyTgpuData | AnyTgpuLooseData>(elementType: TElement, count: number) => TgpuLooseArray<TElement>;
+/**
+ * Checks whether passed in value is an array schema,
+ * as opposed to, e.g., a looseArray schema.
+ *
+ * Array schemas can be used to describe uniform and storage buffers,
+ * whereas looseArray schemas cannot.
+ *
+ * @example
+ * isArraySchema(d.arrayOf(d.u32, 4)) // true
+ * isArraySchema(d.looseArrayOf(d.u32, 4)) // false
+ * isArraySchema(d.vec3f) // false
+ */
+declare function isArraySchema<T extends TgpuArray<AnyTgpuData>>(schema: T | unknown): schema is T;
+/**
+ * Checks whether the passed in value is a looseArray schema,
+ * as opposed to, e.g., a regular array schema.
+ *
+ * Array schemas can be used to describe uniform and storage buffers,
+ * whereas looseArray schemas cannot. Loose arrays are useful for
+ * defining vertex buffers instead.
+ *
+ * @example
+ * isLooseArraySchema(d.arrayOf(d.u32, 4)) // false
+ * isLooseArraySchema(d.looseArrayOf(d.u32, 4)) // true
+ * isLooseArraySchema(d.vec3f) // false
+ */
+declare function isLooseArraySchema<T extends TgpuLooseArray<AnyTgpuData>>(schema: T | unknown): schema is T;
 
 declare class SimpleTgpuData<TSchema extends AnySchema> extends Schema<Unwrap<TSchema>> implements TgpuData<Unwrap<TSchema>> {
     readonly size: number;
@@ -106,88 +188,6 @@ declare function isStructSchema<T extends TgpuStruct<Record<string, AnyTgpuData>
  */
 declare function isLooseStructSchema<T extends TgpuLooseStruct<Record<string, AnyTgpuData | AnyTgpuLooseData>>>(schema: T | unknown): schema is T;
 
-interface TgpuBaseArray<TElement extends AnyTgpuData | AnyTgpuLooseData = AnyTgpuData | AnyTgpuLooseData> {
-    readonly elementType: TElement;
-    readonly elementCount: number;
-    readonly stride: number;
-}
-/**
- * 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 AnyTgpuData> extends TgpuBaseArray<TElement>, TgpuData<Unwrap<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 count The number of elements in the array.
- */
-declare const arrayOf: <TElement extends AnyTgpuData>(elementType: TElement, count: number) => TgpuArray<TElement>;
-/**
- * Array schema constructed via `d.looseArrayOf` function.
- *
- * Useful for defining vertex buffers.
- * 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.
- */
-interface TgpuLooseArray<TElement extends AnyTgpuData | AnyTgpuLooseData> extends TgpuBaseArray<TElement>, TgpuLooseData<Unwrap<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 looseArray = d.looseArrayOf(d.vec3f, 3); // packed array of vec3f
- *
- * @example
- * const looseArray = d.looseArrayOf(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 looseArrayOf: <TElement extends AnyTgpuData | AnyTgpuLooseData>(elementType: TElement, count: number) => TgpuLooseArray<TElement>;
-/**
- * Checks whether passed in value is an array schema,
- * as opposed to, e.g., a looseArray schema.
- *
- * Array schemas can be used to describe uniform and storage buffers,
- * whereas looseArray schemas cannot.
- *
- * @example
- * isArraySchema(d.arrayOf(d.u32, 4)) // true
- * isArraySchema(d.looseArrayOf(d.u32, 4)) // false
- * isArraySchema(d.vec3f) // false
- */
-declare function isArraySchema<T extends TgpuArray<AnyTgpuData>>(schema: T | unknown): schema is T;
-/**
- * Checks whether the passed in value is a looseArray schema,
- * as opposed to, e.g., a regular array schema.
- *
- * Array schemas can be used to describe uniform and storage buffers,
- * whereas looseArray schemas cannot. Loose arrays are useful for
- * defining vertex buffers instead.
- *
- * @example
- * isLooseArraySchema(d.arrayOf(d.u32, 4)) // false
- * isLooseArraySchema(d.looseArrayOf(d.u32, 4)) // true
- * isLooseArraySchema(d.vec3f) // false
- */
-declare function isLooseArraySchema<T extends TgpuLooseArray<AnyTgpuData>>(schema: T | unknown): schema is T;
-
 interface matBase<TColumn> extends NumberArrayView {
     readonly columns: readonly TColumn[];
     elements(): Iterable<number>;