typegpu 0.10.0 → 0.10.2

package/data/texture.d.ts

@@ -0,0 +1,292 @@
+import { $internal, $repr } from "../shared/symbols.js";
+import { WithDefaults } from "../shared/utilityTypes.js";
+import { BaseData, F32, TextureSampleTypes } from "./wgslTypes.js";
+import { StorageTextureFormats } from "../core/texture/textureFormats.js";
+
+//#region src/data/texture.d.ts
+type StorageTextureDimension = '1d' | '2d' | '2d-array' | '3d';
+type WgslTextureProps = {
+  dimension: GPUTextureViewDimension;
+  sampleType: TextureSampleTypes;
+  multisampled: boolean;
+};
+type WgslStorageTextureProps = {
+  dimension: StorageTextureDimension;
+  format: StorageTextureFormats;
+  access: GPUStorageTextureAccess;
+};
+type ResolvedTextureProps<TProps extends Partial<WgslTextureProps>> = WithDefaults<TProps, WgslTextureProps>;
+type ResolvedStorageTextureProps<TProps extends Partial<WgslStorageTextureProps>> = WithDefaults<TProps, WgslStorageTextureProps>;
+type SampledTextureLiteral = `texture_${'1d' | '2d' | '2d_array' | '3d' | 'cube' | 'cube_array' | 'multisampled_2d' | 'depth_multisampled_2d' | 'depth_2d' | 'depth_2d_array' | 'depth_cube' | 'depth_cube_array'}`;
+type StorageTextureLiteral = `texture_storage_${'1d' | '2d' | '2d_array' | '3d'}`;
+interface WgslTexture<TProps extends Partial<WgslTextureProps> = WgslTextureProps> extends BaseData {
+  readonly [$repr]: unknown;
+  readonly type: SampledTextureLiteral;
+  readonly sampleType: ResolvedTextureProps<TProps>['sampleType'];
+  readonly dimension: ResolvedTextureProps<TProps>['dimension'];
+  readonly multisampled: ResolvedTextureProps<TProps>['multisampled'];
+  readonly bindingSampleType: [GPUTextureSampleType, ...GPUTextureSampleType[]];
+}
+interface WgslStorageTexture<TProps extends Partial<WgslStorageTextureProps> = WgslStorageTextureProps> extends BaseData {
+  readonly [$repr]: unknown;
+  readonly type: StorageTextureLiteral;
+  readonly format: ResolvedStorageTextureProps<TProps>['format'];
+  readonly dimension: ResolvedStorageTextureProps<TProps>['dimension'];
+  readonly access: ResolvedStorageTextureProps<TProps>['access'];
+}
+interface WgslExternalTexture extends BaseData {
+  readonly [$repr]: textureExternal;
+  readonly type: 'texture_external';
+  readonly dimension: '2d';
+}
+interface WgslTexture1d<TSample extends TextureSampleTypes = TextureSampleTypes> extends WgslTexture<{
+  dimension: '1d';
+  sampleType: TSample;
+  multisampled: false;
+}> {
+  readonly type: 'texture_1d';
+  readonly [$repr]: texture1d<TSample>;
+}
+interface WgslTexture2d<TSample extends TextureSampleTypes = TextureSampleTypes> extends WgslTexture<{
+  dimension: '2d';
+  sampleType: TSample;
+  multisampled: false;
+}> {
+  readonly type: 'texture_2d';
+  readonly [$repr]: texture2d<TSample>;
+}
+interface WgslTextureMultisampled2d<TSample extends TextureSampleTypes = TextureSampleTypes> extends WgslTexture<{
+  dimension: '2d';
+  sampleType: TSample;
+  multisampled: true;
+}> {
+  readonly type: 'texture_multisampled_2d';
+  readonly [$repr]: textureMultisampled2d<TSample>;
+}
+interface WgslTexture2dArray<TSample extends TextureSampleTypes = TextureSampleTypes> extends WgslTexture<{
+  dimension: '2d-array';
+  sampleType: TSample;
+  multisampled: false;
+}> {
+  readonly type: 'texture_2d_array';
+  readonly [$repr]: texture2dArray<TSample>;
+}
+interface WgslTextureCube<TSample extends TextureSampleTypes = TextureSampleTypes> extends WgslTexture<{
+  dimension: 'cube';
+  sampleType: TSample;
+  multisampled: false;
+}> {
+  readonly type: 'texture_cube';
+  readonly [$repr]: textureCube<TSample>;
+}
+interface WgslTextureCubeArray<TSample extends TextureSampleTypes = TextureSampleTypes> extends WgslTexture<{
+  dimension: 'cube-array';
+  sampleType: TSample;
+  multisampled: false;
+}> {
+  readonly type: 'texture_cube_array';
+  readonly [$repr]: textureCubeArray<TSample>;
+}
+interface WgslTexture3d<TSample extends TextureSampleTypes = TextureSampleTypes> extends WgslTexture<{
+  dimension: '3d';
+  sampleType: TSample;
+  multisampled: false;
+}> {
+  readonly type: 'texture_3d';
+  readonly [$repr]: texture3d<TSample>;
+}
+interface WgslTextureDepth2d extends WgslTexture<{
+  dimension: '2d';
+  sampleType: F32;
+  multisampled: false;
+}> {
+  readonly type: 'texture_depth_2d';
+  readonly [$repr]: textureDepth2d;
+}
+interface WgslTextureDepthMultisampled2d extends WgslTexture<{
+  dimension: '2d';
+  sampleType: F32;
+  multisampled: true;
+}> {
+  readonly type: 'texture_depth_multisampled_2d';
+  readonly [$repr]: textureDepthMultisampled2d;
+}
+interface WgslTextureDepth2dArray extends WgslTexture<{
+  dimension: '2d-array';
+  sampleType: F32;
+  multisampled: false;
+}> {
+  readonly type: 'texture_depth_2d_array';
+  readonly [$repr]: textureDepth2dArray;
+}
+interface WgslTextureDepthCube extends WgslTexture<{
+  dimension: 'cube';
+  sampleType: F32;
+  multisampled: false;
+}> {
+  readonly type: 'texture_depth_cube';
+  readonly [$repr]: textureDepthCube;
+}
+interface WgslTextureDepthCubeArray extends WgslTexture<{
+  dimension: 'cube-array';
+  sampleType: F32;
+  multisampled: false;
+}> {
+  readonly type: 'texture_depth_cube_array';
+  readonly [$repr]: textureDepthCubeArray;
+}
+interface WgslStorageTexture1d<TFormat extends StorageTextureFormats = StorageTextureFormats, TAccess extends GPUStorageTextureAccess = GPUStorageTextureAccess> extends WgslStorageTexture<{
+  dimension: '1d';
+  format: TFormat;
+  access: TAccess;
+}> {
+  readonly type: 'texture_storage_1d';
+  readonly [$repr]: textureStorage1d<TFormat, TAccess>;
+}
+interface WgslStorageTexture2d<TFormat extends StorageTextureFormats = StorageTextureFormats, TAccess extends GPUStorageTextureAccess = GPUStorageTextureAccess> extends WgslStorageTexture<{
+  dimension: '2d';
+  format: TFormat;
+  access: TAccess;
+}> {
+  readonly type: 'texture_storage_2d';
+  readonly [$repr]: textureStorage2d<TFormat, TAccess>;
+}
+interface WgslStorageTexture2dArray<TFormat extends StorageTextureFormats = StorageTextureFormats, TAccess extends GPUStorageTextureAccess = GPUStorageTextureAccess> extends WgslStorageTexture<{
+  dimension: '2d-array';
+  format: TFormat;
+  access: TAccess;
+}> {
+  readonly type: 'texture_storage_2d_array';
+  readonly [$repr]: textureStorage2dArray<TFormat, TAccess>;
+}
+interface WgslStorageTexture3d<TFormat extends StorageTextureFormats = StorageTextureFormats, TAccess extends GPUStorageTextureAccess = GPUStorageTextureAccess> extends WgslStorageTexture<{
+  dimension: '3d';
+  format: TFormat;
+  access: TAccess;
+}> {
+  readonly type: 'texture_storage_3d';
+  readonly [$repr]: textureStorage3d<TFormat, TAccess>;
+}
+type SampledTextureSchemaMap<T extends WgslTextureProps> = {
+  multisampled: {
+    '1d': never;
+    '2d': WgslTextureMultisampled2d<T['sampleType']>;
+    '2d-array': never;
+    '3d': never;
+    cube: never;
+    'cube-array': never;
+  };
+  sampled: {
+    '1d': WgslTexture1d<T['sampleType']>;
+    '2d': WgslTexture2d<T['sampleType']>;
+    '2d-array': WgslTexture2dArray<T['sampleType']>;
+    '3d': WgslTexture3d<T['sampleType']>;
+    cube: WgslTextureCube<T['sampleType']>;
+    'cube-array': WgslTextureCubeArray<T['sampleType']>;
+  };
+};
+type StorageTextureSchemaMap<T extends WgslStorageTextureProps> = {
+  '1d': WgslStorageTexture1d<T['format'], T['access']>;
+  '2d': WgslStorageTexture2d<T['format'], T['access']>;
+  '2d-array': WgslStorageTexture2dArray<T['format'], T['access']>;
+  '3d': WgslStorageTexture3d<T['format'], T['access']>;
+};
+type TextureSchemaForDescriptor<T extends WgslTextureProps | WgslStorageTextureProps> = T extends WgslTextureProps ? T['multisampled'] extends true ? SampledTextureSchemaMap<T>['multisampled'][T['dimension']] : SampledTextureSchemaMap<T>['sampled'][T['dimension']] : T extends WgslStorageTextureProps ? StorageTextureSchemaMap<T>[T['dimension']] : never;
+interface texture1d<T extends TextureSampleTypes = TextureSampleTypes> {
+  readonly kind: `texture_1d<${T['type']}>`;
+  [$internal]: T;
+}
+declare function texture1d<T extends TextureSampleTypes>(sampleType: T): WgslTexture1d<T>;
+declare function texture1d(): WgslTexture1d<F32>;
+interface texture2d<T extends TextureSampleTypes = TextureSampleTypes> {
+  readonly kind: `texture_2d<${T['type']}>`;
+  [$internal]: T;
+}
+declare function texture2d<T extends TextureSampleTypes>(sampleType: T): WgslTexture2d<T>;
+declare function texture2d(): WgslTexture2d<F32>;
+interface textureMultisampled2d<T extends TextureSampleTypes = TextureSampleTypes> {
+  readonly kind: `texture_multisampled_2d<${T['type']}>`;
+  [$internal]: T;
+}
+declare function textureMultisampled2d<T extends TextureSampleTypes>(sampleType: T): WgslTextureMultisampled2d<T>;
+declare function textureMultisampled2d(): WgslTextureMultisampled2d<F32>;
+interface texture2dArray<T extends TextureSampleTypes = TextureSampleTypes> {
+  readonly kind: `texture_2d_array<${T['type']}>`;
+  [$internal]: T;
+}
+declare function texture2dArray<T extends TextureSampleTypes>(sampleType: T): WgslTexture2dArray<T>;
+declare function texture2dArray(): WgslTexture2dArray<F32>;
+interface textureCube<T extends TextureSampleTypes = TextureSampleTypes> {
+  readonly kind: `texture_cube<${T['type']}>`;
+  [$internal]: T;
+}
+declare function textureCube<T extends TextureSampleTypes>(sampleType: T): WgslTextureCube<T>;
+declare function textureCube(): WgslTextureCube<F32>;
+interface textureCubeArray<T extends TextureSampleTypes = TextureSampleTypes> {
+  readonly kind: `texture_cube_array<${T['type']}>`;
+  [$internal]: T;
+}
+declare function textureCubeArray<T extends TextureSampleTypes>(sampleType: T): WgslTextureCubeArray<T>;
+declare function textureCubeArray(): WgslTextureCubeArray<F32>;
+interface texture3d<T extends TextureSampleTypes = TextureSampleTypes> {
+  readonly kind: `texture_3d<${T['type']}>`;
+  [$internal]: T;
+}
+declare function texture3d<T extends TextureSampleTypes>(sampleType: T): WgslTexture3d<T>;
+declare function texture3d(): WgslTexture3d<F32>;
+interface textureStorage1d<TFormat extends StorageTextureFormats = StorageTextureFormats, TAccess extends GPUStorageTextureAccess = GPUStorageTextureAccess> {
+  readonly kind: `texture_storage_1d<${TFormat}, ${TAccess}>`;
+  [$internal]: [TFormat, TAccess];
+}
+declare function textureStorage1d<TFormat extends StorageTextureFormats, TAccess extends GPUStorageTextureAccess>(format: TFormat, access: TAccess): WgslStorageTexture1d<TFormat, TAccess>;
+declare function textureStorage1d<TFormat extends StorageTextureFormats>(format: TFormat): WgslStorageTexture1d<TFormat, 'write-only'>;
+interface textureStorage2d<TFormat extends StorageTextureFormats = StorageTextureFormats, TAccess extends GPUStorageTextureAccess = GPUStorageTextureAccess> {
+  readonly kind: `texture_storage_2d<${TFormat}, ${TAccess}>`;
+  [$internal]: [TFormat, TAccess];
+}
+declare function textureStorage2d<TFormat extends StorageTextureFormats, TAccess extends GPUStorageTextureAccess>(format: TFormat, access: TAccess): WgslStorageTexture2d<TFormat, TAccess>;
+declare function textureStorage2d<TFormat extends StorageTextureFormats>(format: TFormat): WgslStorageTexture2d<TFormat, 'write-only'>;
+interface textureStorage2dArray<TFormat extends StorageTextureFormats = StorageTextureFormats, TAccess extends GPUStorageTextureAccess = GPUStorageTextureAccess> {
+  readonly kind: `texture_storage_2d_array<${TFormat}, ${TAccess}>`;
+  [$internal]: [TFormat, TAccess];
+}
+declare function textureStorage2dArray<TFormat extends StorageTextureFormats, TAccess extends GPUStorageTextureAccess>(format: TFormat, access: TAccess): WgslStorageTexture2dArray<TFormat, TAccess>;
+declare function textureStorage2dArray<TFormat extends StorageTextureFormats>(format: TFormat): WgslStorageTexture2dArray<TFormat, 'write-only'>;
+interface textureStorage3d<TFormat extends StorageTextureFormats = StorageTextureFormats, TAccess extends GPUStorageTextureAccess = GPUStorageTextureAccess> {
+  readonly kind: `texture_storage_3d<${TFormat}, ${TAccess}>`;
+  [$internal]: [TFormat, TAccess];
+}
+declare function textureStorage3d<TFormat extends StorageTextureFormats, TAccess extends GPUStorageTextureAccess>(format: TFormat, access: TAccess): WgslStorageTexture3d<TFormat, TAccess>;
+declare function textureStorage3d<TFormat extends StorageTextureFormats>(format: TFormat): WgslStorageTexture3d<TFormat, 'write-only'>;
+interface textureDepth2d {
+  readonly kind: 'texture_depth_2d';
+  [$internal]: F32;
+}
+declare function textureDepth2d(): WgslTextureDepth2d;
+interface textureDepthMultisampled2d {
+  readonly kind: 'texture_depth_multisampled_2d';
+  [$internal]: F32;
+}
+declare function textureDepthMultisampled2d(): WgslTextureDepthMultisampled2d;
+interface textureDepth2dArray {
+  readonly kind: 'texture_depth_2d_array';
+  [$internal]: F32;
+}
+declare function textureDepth2dArray(): WgslTextureDepth2dArray;
+interface textureDepthCube {
+  readonly kind: 'texture_depth_cube';
+  [$internal]: F32;
+}
+declare function textureDepthCube(): WgslTextureDepthCube;
+interface textureDepthCubeArray {
+  readonly kind: 'texture_depth_cube_array';
+  [$internal]: F32;
+}
+declare function textureDepthCubeArray(): WgslTextureDepthCubeArray;
+interface textureExternal {
+  readonly kind: 'texture_external';
+  [$internal]: true;
+}
+declare function textureExternal(): WgslExternalTexture;
+//#endregion
+export { StorageTextureDimension, TextureSchemaForDescriptor, 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 };

package/{texture-Dg5ybJro.js → data/texture.js}

@@ -1,4 +1,5 @@
-import { cr as $internal, dr as $repr, it as f32 } from "./operators-HTxa_0k9.js";
+import { $internal, $repr } from "../shared/symbols.js";
+import { f32 } from "./numeric.js";
 
 //#region src/data/texture.ts
 function textureDescriptorToSchema(desc) {
@@ -199,7 +200,9 @@ function isWgslTexture(value) {
 function isWgslStorageTexture(value) {
 	return !!value[$internal] && typeof value.format === "string" && typeof value.access === "string";
 }
+function isWgslExternalTexture(value) {
+	return !!value[$internal] && value.type === "texture_external";
+}
 
 //#endregion
-export { textureMultisampled2d as _, texture2d as a, textureStorage2dArray as b, textureCube as c, textureDepth2dArray as d, textureDepthCube as f, textureExternal as g, textureDescriptorToSchema as h, texture1d as i, textureCubeArray as l, textureDepthMultisampled2d as m, isWgslStorageTexture as n, texture2dArray as o, textureDepthCubeArray as p, isWgslTexture as r, texture3d as s, accessModeMap as t, textureDepth2d as u, textureStorage1d as v, textureStorage3d as x, textureStorage2d as y };
-//# sourceMappingURL=texture-Dg5ybJro.js.map
+export { accessModeMap, isWgslExternalTexture, isWgslStorageTexture, isWgslTexture, texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureDescriptorToSchema, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d };

package/data/unstruct.d.ts

@@ -0,0 +1,24 @@
+import { AnyData, Unstruct } from "./dataTypes.js";
+
+//#region src/data/unstruct.d.ts
+/**
+ * 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 function unstruct<TProps extends Record<string, AnyData>>(properties: TProps): Unstruct<TProps>;
+//#endregion
+export { unstruct };

package/data/unstruct.js

@@ -0,0 +1,43 @@
+import { $internal } from "../shared/symbols.js";
+import { getName, setName } from "../shared/meta.js";
+import { schemaCallWrapper } from "./schemaCallWrapper.js";
+
+//#region src/data/unstruct.ts
+/**
+* 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.
+*/
+function unstruct(properties) {
+	const unstructSchema = (instanceProps) => Object.fromEntries(Object.entries(properties).map(([key, schema]) => [key, schemaCallWrapper(schema, instanceProps?.[key])]));
+	Object.setPrototypeOf(unstructSchema, UnstructImpl);
+	unstructSchema.propTypes = properties;
+	return unstructSchema;
+}
+const UnstructImpl = {
+	[$internal]: true,
+	type: "unstruct",
+	$name(label) {
+		setName(this, label);
+		return this;
+	},
+	toString() {
+		return `unstruct:${getName(this) ?? "<unnamed>"}`;
+	}
+};
+
+//#endregion
+export { unstruct };

package/data/vector.d.ts

@@ -0,0 +1,191 @@
+import { Vec2b, Vec2f, Vec2h, Vec2i, Vec2u, Vec3b, Vec3f, Vec3h, Vec3i, Vec3u, Vec4b, Vec4f, Vec4h, Vec4i, Vec4u } from "./wgslTypes.js";
+
+//#region src/data/vector.d.ts
+/**
+ * Schema representing vec2f - a vector with 2 elements of type f32.
+ * Also a constructor function for this vector value.
+ *
+ * @example
+ * const vector = d.vec2f(); // (0.0, 0.0)
+ * const vector = d.vec2f(1); // (1.0, 1.0)
+ * const vector = d.vec2f(0.5, 0.1); // (0.5, 0.1)
+ *
+ * @example
+ * const buffer = root.createBuffer(d.vec2f, d.vec2f(0, 1)); // buffer holding a d.vec2f value, with an initial value of vec2f(0, 1);
+ */
+declare const vec2f: Vec2f;
+/**
+ * Schema representing vec2h - a vector with 2 elements of type f16.
+ * Also a constructor function for this vector value.
+ *
+ * @example
+ * const vector = d.vec2h(); // (0.0, 0.0)
+ * const vector = d.vec2h(1); // (1.0, 1.0)
+ * const vector = d.vec2h(0.5, 0.1); // (0.5, 0.1)
+ *
+ * @example
+ * const buffer = root.createBuffer(d.vec2h, d.vec2h(0, 1)); // buffer holding a d.vec2h value, with an initial value of vec2h(0, 1);
+ */
+declare const vec2h: Vec2h;
+/**
+ * Schema representing vec2i - a vector with 2 elements of type i32.
+ * Also a constructor function for this vector value.
+ *
+ * @example
+ * const vector = d.vec2i(); // (0, 0)
+ * const vector = d.vec2i(1); // (1, 1)
+ * const vector = d.vec2i(-1, 1); // (-1, 1)
+ *
+ * @example
+ * const buffer = root.createBuffer(d.vec2i, d.vec2i(0, 1)); // buffer holding a d.vec2i value, with an initial value of vec2i(0, 1);
+ */
+declare const vec2i: Vec2i;
+/**
+ * Schema representing vec2u - a vector with 2 elements of type u32.
+ * Also a constructor function for this vector value.
+ *
+ * @example
+ * const vector = d.vec2u(); // (0, 0)
+ * const vector = d.vec2u(1); // (1, 1)
+ * const vector = d.vec2u(1, 2); // (1, 2)
+ *
+ * @example
+ * const buffer = root.createBuffer(d.vec2u, d.vec2u(0, 1)); // buffer holding a d.vec2u value, with an initial value of vec2u(0, 1);
+ */
+declare const vec2u: Vec2u;
+/**
+ * Schema representing `vec2<bool>` - a vector with 2 elements of type `bool`.
+ * Also a constructor function for this vector value.
+ *
+ * @example
+ * const vector = d.vec2b(); // (false, false)
+ * const vector = d.vec2b(true); // (true, true)
+ * const vector = d.vec2b(false, true); // (false, true)
+ */
+declare const vec2b: Vec2b;
+/**
+ * Schema representing vec3f - a vector with 3 elements of type f32.
+ * Also a constructor function for this vector value.
+ *
+ * @example
+ * const vector = d.vec3f(); // (0.0, 0.0, 0.0)
+ * const vector = d.vec3f(1); // (1.0, 1.0, 1.0)
+ * const vector = d.vec3f(1, 2, 3.5); // (1.0, 2.0, 3.5)
+ *
+ * @example
+ * const buffer = root.createBuffer(d.vec3f, d.vec3f(0, 1, 2)); // buffer holding a d.vec3f value, with an initial value of vec3f(0, 1, 2);
+ */
+declare const vec3f: Vec3f;
+/**
+ * Schema representing vec3h - a vector with 3 elements of type f16.
+ * Also a constructor function for this vector value.
+ *
+ * @example
+ * const vector = d.vec3h(); // (0.0, 0.0, 0.0)
+ * const vector = d.vec3h(1); // (1.0, 1.0, 1.0)
+ * const vector = d.vec3h(1, 2, 3.5); // (1.0, 2.0, 3.5)
+ *
+ * @example
+ * const buffer = root.createBuffer(d.vec3h, d.vec3h(0, 1, 2)); // buffer holding a d.vec3h value, with an initial value of vec3h(0, 1, 2);
+ */
+declare const vec3h: Vec3h;
+/**
+ * Schema representing vec3i - a vector with 3 elements of type i32.
+ * Also a constructor function for this vector value.
+ *
+ * @example
+ * const vector = d.vec3i(); // (0, 0, 0)
+ * const vector = d.vec3i(1); // (1, 1, 1)
+ * const vector = d.vec3i(1, 2, -3); // (1, 2, -3)
+ *
+ * @example
+ * const buffer = root.createBuffer(d.vec3i, d.vec3i(0, 1, 2)); // buffer holding a d.vec3i value, with an initial value of vec3i(0, 1, 2);
+ */
+declare const vec3i: Vec3i;
+/**
+ * Schema representing vec3u - a vector with 3 elements of type u32.
+ * Also a constructor function for this vector value.
+ *
+ * @example
+ * const vector = d.vec3u(); // (0, 0, 0)
+ * const vector = d.vec3u(1); // (1, 1, 1)
+ * const vector = d.vec3u(1, 2, 3); // (1, 2, 3)
+ *
+ * @example
+ * const buffer = root.createBuffer(d.vec3u, d.vec3u(0, 1, 2)); // buffer holding a d.vec3u value, with an initial value of vec3u(0, 1, 2);
+ */
+declare const vec3u: Vec3u;
+/**
+ * Schema representing `vec3<bool>` - a vector with 3 elements of type `bool`.
+ * Also a constructor function for this vector value.
+ *
+ * @example
+ * const vector = d.vec3b(); // (false, false, false)
+ * const vector = d.vec3b(true); // (true, true, true)
+ * const vector = d.vec3b(false, true, false); // (false, true, false)
+ */
+declare const vec3b: Vec3b;
+/**
+ * Schema representing vec4f - a vector with 4 elements of type f32.
+ * Also a constructor function for this vector value.
+ *
+ * @example
+ * const vector = d.vec4f(); // (0.0, 0.0, 0.0, 0.0)
+ * const vector = d.vec4f(1); // (1.0, 1.0, 1.0, 1.0)
+ * const vector = d.vec4f(1, 2, 3, 4.5); // (1.0, 2.0, 3.0, 4.5)
+ *
+ * @example
+ * const buffer = root.createBuffer(d.vec4f, d.vec4f(0, 1, 2, 3)); // buffer holding a d.vec4f value, with an initial value of vec4f(0, 1, 2, 3);
+ */
+declare const vec4f: Vec4f;
+/**
+ * Schema representing vec4h - a vector with 4 elements of type f16.
+ * Also a constructor function for this vector value.
+ *
+ * @example
+ * const vector = d.vec4h(); // (0.0, 0.0, 0.0, 0.0)
+ * const vector = d.vec4h(1); // (1.0, 1.0, 1.0, 1.0)
+ * const vector = d.vec4h(1, 2, 3, 4.5); // (1.0, 2.0, 3.0, 4.5)
+ *
+ * @example
+ * const buffer = root.createBuffer(d.vec4h, d.vec4h(0, 1, 2, 3)); // buffer holding a d.vec4h value, with an initial value of vec4h(0, 1, 2, 3);
+ */
+declare const vec4h: Vec4h;
+/**
+ * Schema representing vec4i - a vector with 4 elements of type i32.
+ * Also a constructor function for this vector value.
+ *
+ * @example
+ * const vector = d.vec4i(); // (0, 0, 0, 0)
+ * const vector = d.vec4i(1); // (1, 1, 1, 1)
+ * const vector = d.vec4i(1, 2, 3, -4); // (1, 2, 3, -4)
+ *
+ * @example
+ * const buffer = root.createBuffer(d.vec4i, d.vec4i(0, 1, 2, 3)); // buffer holding a d.vec4i value, with an initial value of vec4i(0, 1, 2, 3);
+ */
+declare const vec4i: Vec4i;
+/**
+ * Schema representing vec4u - a vector with 4 elements of type u32.
+ * Also a constructor function for this vector value.
+ *
+ * @example
+ * const vector = d.vec4u(); // (0, 0, 0, 0)
+ * const vector = d.vec4u(1); // (1, 1, 1, 1)
+ * const vector = d.vec4u(1, 2, 3, 4); // (1, 2, 3, 4)
+ *
+ * @example
+ * const buffer = root.createBuffer(d.vec4u, d.vec4u(0, 1, 2, 3)); // buffer holding a d.vec4u value, with an initial value of vec4u(0, 1, 2, 3);
+ */
+declare const vec4u: Vec4u;
+/**
+ * Schema representing `vec4<bool>` - a vector with 4 elements of type `bool`.
+ * Also a constructor function for this vector value.
+ *
+ * @example
+ * const vector = d.vec4b(); // (false, false, false, false)
+ * const vector = d.vec4b(true); // (true, true, true, true)
+ * const vector = d.vec4b(false, true, false, true); // (false, true, false, true)
+ */
+declare const vec4b: Vec4b;
+//#endregion
+export { vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u };