typegpu 0.4.1 → 0.4.2

package/index.d.ts

@@ -1,5 +1,5 @@
-import { A as AnyWgslData, T as TgpuNamable, I as Infer, D as Decorated, F as F32, a as F16, b as I32, U as U32, V as Vec2f, c as Vec3f, d as Vec4f, e as Vec2h, f as Vec3h, g as Vec4h, h as Vec2i, i as Vec3i, j as Vec4i, k as Vec2u, l as Vec3u, m as Vec4u, n as AnyWgslStruct, o as Default, p as UnionToIntersection, W as WgslArray, q as Disarray, K as KindToAcceptedAttribMap, r as Unstruct, s as VertexFormat, t as TgpuVertexAttrib, u as KindToDefaultFormatMap, v as AnyData, B as BaseData, L as Location, w as WgslStruct, O as OmitProps, P as Prettify, M as Mutable, x as InferPartial, y as MemIdentity, z as WgslTypeLiteral, C as AnyVecInstance, E as AnyMatInstance } from './wgslTypes-BNsjCP--.js';
-import { A as AnyAttribute, a as AnyComputeBuiltin, D as Decorate, I as IsBuiltin, H as HasCustomLocation, O as OmitBuiltins, B as BuiltinSampleMask, b as BuiltinFragDepth } from './attributes-BQuRnaZ4.js';
+import { A as AnyWgslData, T as TgpuNamable, I as Infer, D as Decorated, F as F32, a as F16, b as I32, U as U32, V as Vec2f, c as Vec3f, d as Vec4f, e as Vec2h, f as Vec3h, g as Vec4h, h as Vec2i, i as Vec3i, j as Vec4i, k as Vec2u, l as Vec3u, m as Vec4u, n as AnyWgslStruct, B as BaseData, L as Location, W as WgslStruct, o as Default, p as UnionToIntersection, q as WgslArray, r as Disarray, K as KindToAcceptedAttribMap, s as Unstruct, t as VertexFormat, u as TgpuVertexAttrib, v as KindToDefaultFormatMap, w as AnyData, O as OmitProps, P as Prettify, M as Mutable, x as InferPartial, y as MemIdentity, z as WgslTypeLiteral, C as AnyVecInstance, E as AnyMatInstance } from './wgslTypes-D8LnuOPy.js';
+import { A as AnyAttribute, a as AnyComputeBuiltin, D as Decorate, I as IsBuiltin, H as HasCustomLocation, O as OmitBuiltins, b as AnyFragmentOutputBuiltin, c as AnyFragmentInputBuiltin } from './attributes-CkPkK-h9.js';
 import * as smol from 'tinyest';
 import { Block } from 'tinyest';
 
@@ -80,17 +80,13 @@ interface TgpuComputeFn<ComputeIn extends Record<string, AnyComputeBuiltin> = Re
     readonly shell: TgpuComputeFnShell<ComputeIn>;
     $uses(dependencyMap: Record<string, unknown>): this;
 }
-interface ComputeFnOptions {
+declare function computeFn(options: {
     workgroupSize: number[];
-}
-/**
- * Creates a shell of a typed entry function for the compute shader stage. Any function
- * that implements this shell can perform general-purpose computation.
- *
- * @param workgroupSize
- *   Size of blocks that the thread grid will be divided into (up to 3 dimensions).
- */
-declare function computeFn<ComputeIn extends Record<string, AnyComputeBuiltin>>(argTypes: ComputeIn, options: ComputeFnOptions): TgpuComputeFnShell<ComputeIn>;
+}): TgpuComputeFnShell<{}>;
+declare function computeFn<ComputeIn extends Record<string, AnyComputeBuiltin>>(options: {
+    in: ComputeIn;
+    workgroupSize: number[];
+}): TgpuComputeFnShell<ComputeIn>;
 
 interface Storage {
     usableAsStorage: true;
@@ -175,6 +171,78 @@ interface TgpuComputePipeline extends TgpuNamable {
     dispatchWorkgroups(x: number, y?: number | undefined, z?: number | undefined): void;
 }
 
+type WithLocations<T extends IORecord> = {
+    [Key in keyof T]: IsBuiltin<T[Key]> extends true ? T[Key] : HasCustomLocation<T[Key]> extends true ? T[Key] : Decorate<T[Key], Location<number>>;
+};
+type IOLayoutToSchema<T extends IOLayout> = T extends BaseData ? Decorate<T, Location<0>> : T extends IORecord ? WgslStruct<WithLocations<T>> : never;
+
+type FragmentOutConstrained = Vec4f | Decorated<Vec4f, [Location<number>]> | AnyFragmentOutputBuiltin | IORecord<Vec4f | Decorated<Vec4f, [Location<number>]> | AnyFragmentOutputBuiltin>;
+type FragmentInConstrained = IORecord<BaseIOData | Decorated<BaseIOData, AnyAttribute<never>[]> | AnyFragmentInputBuiltin>;
+/**
+ * Describes a fragment entry function signature (its arguments and return type)
+ */
+interface TgpuFragmentFnShell<FragmentIn extends FragmentInConstrained, FragmentOut extends FragmentOutConstrained> {
+    readonly argTypes: [AnyWgslStruct];
+    readonly targets: FragmentOut;
+    readonly returnType: FragmentOut;
+    /**
+     * Creates a type-safe implementation of this signature
+     */
+    does(implementation: (input: InferIO<FragmentIn>) => InferIO<FragmentOut>): TgpuFragmentFn<OmitBuiltins<FragmentIn>, OmitBuiltins<FragmentOut>>;
+    /**
+     * @param implementation
+     *   Raw WGSL function implementation with header and body
+     *   without `fn` keyword and function name
+     *   e.g. `"(x: f32) -> f32 { return x; }"`;
+     */
+    does(implementation: string): TgpuFragmentFn<OmitBuiltins<FragmentIn>, OmitBuiltins<FragmentOut>>;
+}
+interface TgpuFragmentFn<Varying extends FragmentInConstrained = FragmentInConstrained, Output extends FragmentOutConstrained = FragmentOutConstrained> extends TgpuNamable {
+    readonly shell: TgpuFragmentFnShell<Varying, Output>;
+    readonly outputType: IOLayoutToSchema<Output>;
+    $uses(dependencyMap: Record<string, unknown>): this;
+}
+declare function fragmentFn<FragmentOut extends FragmentOutConstrained>(options: {
+    out: FragmentOut;
+}): TgpuFragmentFnShell<{}, FragmentOut>;
+declare function fragmentFn<FragmentIn extends FragmentInConstrained, FragmentOut extends FragmentOutConstrained>(options: {
+    in: FragmentIn;
+    out: FragmentOut;
+}): TgpuFragmentFnShell<FragmentIn, FragmentOut>;
+
+/**
+ * Describes a vertex entry function signature (its arguments and return type)
+ */
+interface TgpuVertexFnShell<VertexIn extends IOLayout, VertexOut extends IOLayout> {
+    readonly argTypes: [AnyWgslStruct];
+    readonly returnType: VertexOut;
+    readonly attributes: [VertexIn];
+    /**
+     * Creates a type-safe implementation of this signature
+     */
+    does(implementation: (input: InferIO<VertexIn>) => InferIO<VertexOut>): TgpuVertexFn<OmitBuiltins<VertexIn>, OmitBuiltins<VertexOut>>;
+    /**
+     * @param implementation
+     *   Raw WGSL function implementation with header and body
+     *   without `fn` keyword and function name
+     *   e.g. `"(x: f32) -> f32 { return x; }"`;
+     */
+    does(implementation: string): TgpuVertexFn<OmitBuiltins<VertexIn>, OmitBuiltins<VertexOut>>;
+}
+interface TgpuVertexFn<VertexIn extends IOLayout = IOLayout, VertexOut extends IOLayout = IOLayout> extends TgpuNamable {
+    readonly shell: TgpuVertexFnShell<VertexIn, VertexOut>;
+    readonly outputType: IOLayoutToSchema<VertexOut>;
+    readonly inputType: IOLayoutToSchema<VertexIn>;
+    $uses(dependencyMap: Record<string, unknown>): this;
+}
+declare function vertexFn<VertexOut extends IORecord>(options: {
+    out: VertexOut;
+}): TgpuVertexFnShell<{}, VertexOut>;
+declare function vertexFn<VertexIn extends IORecord, VertexOut extends IORecord>(options: {
+    in: VertexIn;
+    out: VertexOut;
+}): TgpuVertexFnShell<VertexIn, VertexOut>;
+
 type TextureProps = {
     size: readonly number[];
     format: GPUTextureFormat;
@@ -473,99 +541,6 @@ interface TgpuVertexLayout<TData extends WgslArray | Disarray = WgslArray | Disa
 }
 declare function vertexLayout<TData extends WgslArray | Disarray>(schemaForCount: (count: number) => TData, stepMode?: 'vertex' | 'instance'): TgpuVertexLayout<TData>;
 
-interface Unwrapper {
-    readonly device: GPUDevice;
-    unwrap(resource: TgpuComputePipeline): GPUComputePipeline;
-    unwrap(resource: TgpuBindGroupLayout): GPUBindGroupLayout;
-    unwrap(resource: TgpuBindGroup): GPUBindGroup;
-    unwrap(resource: TgpuBuffer<AnyData>): GPUBuffer;
-    unwrap(resource: TgpuTexture): GPUTexture;
-    unwrap(resource: TgpuReadonlyTexture | TgpuWriteonlyTexture | TgpuMutableTexture | TgpuSampledTexture): GPUTextureView;
-    unwrap(resource: TgpuVertexLayout): GPUVertexBufferLayout;
-}
-
-type WithLocations<T extends IORecord> = {
-    [Key in keyof T]: IsBuiltin<T[Key]> extends true ? T[Key] : HasCustomLocation<T[Key]> extends true ? T[Key] : Decorate<T[Key], Location<number>>;
-};
-type IOLayoutToSchema<T extends IOLayout> = T extends BaseData ? Decorate<T, Location<0>> : T extends IORecord ? WgslStruct<WithLocations<T>> : never;
-
-type FragmentOutConstrained = Vec4f | Decorated<Vec4f, [Location<number>]> | BuiltinSampleMask | BuiltinFragDepth | IORecord<Vec4f | Decorated<Vec4f, [Location<number>]> | BuiltinSampleMask | BuiltinFragDepth>;
-/**
- * Describes a fragment entry function signature (its arguments and return type)
- */
-interface TgpuFragmentFnShell<FragmentIn extends IOLayout, FragmentOut extends FragmentOutConstrained> {
-    readonly argTypes: [AnyWgslStruct];
-    readonly targets: FragmentOut;
-    readonly returnType: FragmentOut;
-    /**
-     * Creates a type-safe implementation of this signature
-     */
-    does(implementation: (input: InferIO<FragmentIn>) => InferIO<FragmentOut>): TgpuFragmentFn<OmitBuiltins<FragmentIn>, OmitBuiltins<FragmentOut>>;
-    /**
-     * @param implementation
-     *   Raw WGSL function implementation with header and body
-     *   without `fn` keyword and function name
-     *   e.g. `"(x: f32) -> f32 { return x; }"`;
-     */
-    does(implementation: string): TgpuFragmentFn<OmitBuiltins<FragmentIn>, OmitBuiltins<FragmentOut>>;
-}
-interface TgpuFragmentFn<Varying extends IOLayout = IOLayout, Output extends FragmentOutConstrained = FragmentOutConstrained> extends TgpuNamable {
-    readonly shell: TgpuFragmentFnShell<Varying, Output>;
-    readonly outputType: IOLayoutToSchema<Output>;
-    $uses(dependencyMap: Record<string, unknown>): this;
-}
-/**
- * Creates a shell of a typed entry function for the fragment shader stage. Any function
- * that implements this shell can run for each fragment (pixel), allowing the inner code
- * to process information received from the vertex shader stage and builtins to determine
- * the final color of the pixel (many pixels in case of multiple targets).
- *
- * @param inputType
- *   Values computed in the vertex stage and builtins to be made available to functions that implement this shell.
- * @param outputType
- *   A `vec4f`, signaling this function outputs a color for one target, or a struct/array containing
- *   colors for multiple targets.
- */
-declare function fragmentFn<FragmentIn extends IORecord, FragmentOut extends FragmentOutConstrained>(inputType: FragmentIn, outputType: FragmentOut): TgpuFragmentFnShell<FragmentIn, FragmentOut>;
-
-/**
- * Describes a vertex entry function signature (its arguments and return type)
- */
-interface TgpuVertexFnShell<VertexIn extends IOLayout, VertexOut extends IOLayout> {
-    readonly argTypes: [AnyWgslStruct];
-    readonly returnType: VertexOut;
-    readonly attributes: [VertexIn];
-    /**
-     * Creates a type-safe implementation of this signature
-     */
-    does(implementation: (input: InferIO<VertexIn>) => InferIO<VertexOut>): TgpuVertexFn<OmitBuiltins<VertexIn>, OmitBuiltins<VertexOut>>;
-    /**
-     * @param implementation
-     *   Raw WGSL function implementation with header and body
-     *   without `fn` keyword and function name
-     *   e.g. `"(x: f32) -> f32 { return x; }"`;
-     */
-    does(implementation: string): TgpuVertexFn<OmitBuiltins<VertexIn>, OmitBuiltins<VertexOut>>;
-}
-interface TgpuVertexFn<VertexIn extends IOLayout = IOLayout, VertexOut extends IOLayout = IOLayout> extends TgpuNamable {
-    readonly shell: TgpuVertexFnShell<VertexIn, VertexOut>;
-    readonly outputType: IOLayoutToSchema<VertexOut>;
-    readonly inputType: IOLayoutToSchema<VertexIn>;
-    $uses(dependencyMap: Record<string, unknown>): this;
-}
-/**
- * Creates a shell of a typed entry function for the vertex shader stage. Any function
- * that implements this shell can run for each vertex, allowing the inner code to process
- * attributes and determine the final position of the vertex.
- *
- * @param inputType
- *   Vertex attributes and builtins to be made available to functions that implement this shell.
- * @param outputType
- *   A struct type containing the final position of the vertex, and any information
- *   passed onto the fragment shader stage.
- */
-declare function vertexFn<VertexIn extends IORecord, VertexOut extends IORecord>(inputType: VertexIn, outputType: VertexOut): TgpuVertexFnShell<VertexIn, VertexOut>;
-
 interface TgpuRenderPipeline<Output extends IOLayout = IOLayout> extends TgpuNamable {
     readonly resourceType: 'render-pipeline';
     readonly label: string | undefined;
@@ -673,10 +648,22 @@ interface DepthStencilAttachment {
     stencilReadOnly?: boolean;
 }
 
+interface Unwrapper {
+    readonly device: GPUDevice;
+    unwrap(resource: TgpuComputePipeline): GPUComputePipeline;
+    unwrap(resource: TgpuRenderPipeline): GPURenderPipeline;
+    unwrap(resource: TgpuBindGroupLayout): GPUBindGroupLayout;
+    unwrap(resource: TgpuBindGroup): GPUBindGroup;
+    unwrap(resource: TgpuBuffer<AnyData>): GPUBuffer;
+    unwrap(resource: TgpuTexture): GPUTexture;
+    unwrap(resource: TgpuReadonlyTexture | TgpuWriteonlyTexture | TgpuMutableTexture | TgpuSampledTexture): GPUTextureView;
+    unwrap(resource: TgpuVertexLayout): GPUVertexBufferLayout;
+}
+
 interface WithCompute {
     createPipeline(): TgpuComputePipeline;
 }
-type ValidateFragmentIn<VertexOut extends IORecord, FragmentIn extends IORecord, FragmentOut extends FragmentOutConstrained> = FragmentIn extends Partial<VertexOut> ? VertexOut extends FragmentIn ? [
+type ValidateFragmentIn<VertexOut extends IORecord, FragmentIn extends FragmentInConstrained, FragmentOut extends FragmentOutConstrained> = FragmentIn extends Partial<VertexOut> ? VertexOut extends FragmentIn ? [
     entryFn: TgpuFragmentFn<FragmentIn, FragmentOut>,
     targets: FragmentOutToTargets<FragmentOut>
 ] : [
@@ -693,7 +680,7 @@ type ValidateFragmentIn<VertexOut extends IORecord, FragmentIn extends IORecord,
     }
 ];
 interface WithVertex<VertexOut extends IORecord = IORecord> {
-    withFragment<FragmentIn extends IORecord, FragmentOut extends FragmentOutConstrained>(...args: ValidateFragmentIn<VertexOut, FragmentIn, FragmentOut>): WithFragment<FragmentOut>;
+    withFragment<FragmentIn extends FragmentInConstrained, FragmentOut extends FragmentOutConstrained>(...args: ValidateFragmentIn<VertexOut, FragmentIn, FragmentOut>): WithFragment<FragmentOut>;
 }
 interface WithFragment<Output extends FragmentOutConstrained = FragmentOutConstrained> {
     withPrimitive(primitiveState: GPUPrimitiveState | undefined): WithFragment<Output>;
@@ -746,6 +733,103 @@ type CreateTextureResult<TSize extends readonly number[], TFormat extends GPUTex
     sampleCount: number extends TSampleCount ? undefined : TSampleCount extends 1 ? undefined : TSampleCount;
     viewFormats: GPUTextureFormat extends TViewFormat ? undefined : TViewFormat[] extends never[] ? undefined : TViewFormat[];
 }, undefined>>;
+interface RenderPass {
+    /**
+     * Sets the viewport used during the rasterization stage to linearly map from
+     * NDC (i.e., normalized device coordinates) to viewport coordinates.
+     * @param x - Minimum X value of the viewport in pixels.
+     * @param y - Minimum Y value of the viewport in pixels.
+     * @param width - Width of the viewport in pixels.
+     * @param height - Height of the viewport in pixels.
+     * @param minDepth - Minimum depth value of the viewport.
+     * @param maxDepth - Maximum depth value of the viewport.
+     */
+    setViewport(x: number, y: number, width: number, height: number, minDepth: number, maxDepth: number): void;
+    /**
+     * Sets the scissor rectangle used during the rasterization stage.
+     * After transformation into viewport coordinates any fragments which fall outside the scissor
+     * rectangle will be discarded.
+     * @param x - Minimum X value of the scissor rectangle in pixels.
+     * @param y - Minimum Y value of the scissor rectangle in pixels.
+     * @param width - Width of the scissor rectangle in pixels.
+     * @param height - Height of the scissor rectangle in pixels.
+     */
+    setScissorRect(x: number, y: number, width: number, height: number): void;
+    /**
+     * Sets the constant blend color and alpha values used with {@link GPUBlendFactor#constant}
+     * and {@link GPUBlendFactor#"one-minus-constant"} {@link GPUBlendFactor}s.
+     * @param color - The color to use when blending.
+     */
+    setBlendConstant(color: GPUColor): void;
+    /**
+     * Sets the {@link RenderState#[[stencilReference]]} value used during stencil tests with
+     * the {@link GPUStencilOperation#"replace"} {@link GPUStencilOperation}.
+     * @param reference - The new stencil reference value.
+     */
+    setStencilReference(reference: GPUStencilValue): undefined;
+    /**
+     * @param queryIndex - The index of the query in the query set.
+     */
+    beginOcclusionQuery(queryIndex: GPUSize32): undefined;
+    endOcclusionQuery(): undefined;
+    /**
+     * Executes the commands previously recorded into the given {@link GPURenderBundle}s as part of
+     * this render pass.
+     * When a {@link GPURenderBundle} is executed, it does not inherit the render pass's pipeline, bind
+     * groups, or vertex and index buffers. After a {@link GPURenderBundle} has executed, the render
+     * pass's pipeline, bind group, and vertex/index buffer state is cleared
+     * (to the initial, empty values).
+     * Note: The state is cleared, not restored to the previous state.
+     * This occurs even if zero {@link GPURenderBundle|GPURenderBundles} are executed.
+     * @param bundles - List of render bundles to execute.
+     */
+    executeBundles(bundles: Iterable<GPURenderBundle>): undefined;
+    setPipeline(pipeline: TgpuRenderPipeline): void;
+    /**
+     * Sets the current index buffer.
+     * @param buffer - Buffer containing index data to use for subsequent drawing commands.
+     * @param indexFormat - Format of the index data contained in `buffer`.
+     * @param offset - Offset in bytes into `buffer` where the index data begins. Defaults to `0`.
+     * @param size - Size in bytes of the index data in `buffer`.
+     * 	             Defaults to the size of the buffer minus the offset.
+     */
+    setIndexBuffer<TData extends WgslArray | Disarray>(buffer: TgpuBuffer<TData> | GPUBuffer, indexFormat: GPUIndexFormat, offset?: GPUSize64, size?: GPUSize64): void;
+    setVertexBuffer<TData extends WgslArray | Disarray>(vertexLayout: TgpuVertexLayout<TData>, buffer: (TgpuBuffer<TData> & Vertex) | GPUBuffer, offset?: GPUSize64, size?: GPUSize64): void;
+    setBindGroup<Entries extends Record<string, TgpuLayoutEntry | null>>(bindGroupLayout: TgpuBindGroupLayout<Entries>, bindGroup: TgpuBindGroup<Entries> | GPUBindGroup): void;
+    /**
+     * Draws primitives.
+     * @param vertexCount - The number of vertices to draw.
+     * @param instanceCount - The number of instances to draw.
+     * @param firstVertex - Offset into the vertex buffers, in vertices, to begin drawing from.
+     * @param firstInstance - First instance to draw.
+     */
+    draw(vertexCount: number, instanceCount?: number | undefined, firstVertex?: number | undefined, firstInstance?: number | undefined): void;
+    /**
+     * Draws indexed primitives.
+     * @param indexCount - The number of indices to draw.
+     * @param instanceCount - The number of instances to draw.
+     * @param firstIndex - Offset into the index buffer, in indices, begin drawing from.
+     * @param baseVertex - Added to each index value before indexing into the vertex buffers.
+     * @param firstInstance - First instance to draw.
+     */
+    drawIndexed(indexCount: number, instanceCount?: number | undefined, firstIndex?: number | undefined, baseVertex?: number | undefined, firstInstance?: number | undefined): void;
+    /**
+     * Draws primitives using parameters read from a {@link GPUBuffer}.
+     * Packed block of **four 32-bit unsigned integer values (16 bytes total)**, given in the same
+     * order as the arguments for {@link GPURenderEncoderBase#draw}. For example:
+     * @param indirectBuffer - Buffer containing the indirect draw parameters.
+     * @param indirectOffset - Offset in bytes into `indirectBuffer` where the drawing data begins.
+     */
+    drawIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): undefined;
+    /**
+     * Draws indexed primitives using parameters read from a {@link GPUBuffer}.
+     * Tightly packed block of **five 32-bit unsigned integer values (20 bytes total)**, given in
+     * the same order as the arguments for {@link GPURenderEncoderBase#drawIndexed}. For example:
+     * @param indirectBuffer - Buffer containing the indirect drawIndexed parameters.
+     * @param indirectOffset - Offset in bytes into `indirectBuffer` where the drawing data begins.
+     */
+    drawIndexedIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): undefined;
+}
 interface TgpuRoot extends Unwrapper {
     /**
      * The GPU device associated with this root.
@@ -818,6 +902,7 @@ interface ExperimentalTgpuRoot extends TgpuRoot, WithBinding {
     createMutable<TData extends AnyWgslData>(typeSchema: TData, initialOrBuffer?: Infer<TData> | GPUBuffer): TgpuBufferMutable<TData> & TgpuFixedBufferUsage<TData>;
     createReadonly<TData extends AnyWgslData>(typeSchema: TData, initialOrBuffer?: Infer<TData> | GPUBuffer): TgpuBufferReadonly<TData> & TgpuFixedBufferUsage<TData>;
     createTexture<TWidth extends number, THeight extends number, TDepth extends number, TSize extends readonly [TWidth] | readonly [TWidth, THeight] | readonly [TWidth, THeight, TDepth], TFormat extends GPUTextureFormat, TMipLevelCount extends number, TSampleCount extends number, TViewFormat extends GPUTextureFormat, TDimension extends GPUTextureDimension>(props: CreateTextureOptions<TSize, TFormat, TMipLevelCount, TSampleCount, TViewFormat, TDimension>): TgpuTexture<CreateTextureResult<TSize, TFormat, TMipLevelCount, TSampleCount, TViewFormat, TDimension>>;
+    beginRenderPass(descriptor: GPURenderPassDescriptor, callback: (pass: RenderPass) => void): void;
     /**
      * Causes all commands enqueued by pipelines to be
      * submitted to the GPU.
@@ -1399,6 +1484,9 @@ declare const tgpu: {
         fragmentFn: typeof fragmentFn;
         vertexFn: typeof vertexFn;
         computeFn: typeof computeFn;
+        /**
+         * @deprecated This feature is now stable, use tgpu.vertexLayout.
+         */
         vertexLayout: typeof vertexLayout;
         derived: typeof derived;
         slot: typeof slot;