@nativescript/canvas-three 2.0.0-webgpu.26 → 2.0.0-webgpu.27

package/three/src/renderers/common/Backend.d.ts

@@ -0,0 +1,19 @@
+import { CoordinateSystem } from "../../constants.js";
+import Renderer from "./Renderer.js";
+
+export interface BackendParameters {
+    canvas?: HTMLCanvasElement | undefined;
+}
+
+export default abstract class Backend {
+    renderer: Renderer | null;
+    domElement: HTMLCanvasElement | null;
+
+    constructor(parameters?: BackendParameters);
+
+    init(renderer: Renderer): void;
+
+    abstract get coordinateSystem(): CoordinateSystem;
+
+    getDomElement(): HTMLCanvasElement;
+}

package/three/src/renderers/common/Background.d.ts

@@ -0,0 +1,23 @@
+import { Mesh } from "../../objects/Mesh.js";
+import { Scene } from "../../scenes/Scene.js";
+import DataMap from "./DataMap.js";
+import Nodes from "./nodes/Nodes.js";
+import RenderContext from "./RenderContext.js";
+import Renderer from "./Renderer.js";
+import RenderList from "./RenderList.js";
+interface SceneData {
+    backgroundMesh?: Mesh;
+    backgroundCacheKey: string;
+}
+declare class Background extends DataMap<{
+    scene: {
+        key: Scene;
+        value: SceneData;
+    };
+}> {
+    renderer: Renderer;
+    nodes: Nodes;
+    constructor(renderer: Renderer, nodes: Nodes);
+    update(scene: Scene, renderList: RenderList, renderContext: RenderContext): void;
+}
+export default Background;

package/three/src/renderers/common/BindGroup.d.ts

@@ -0,0 +1,9 @@
+import Binding from "./Binding.js";
+import NodeUniformsGroup from "./nodes/NodeUniformsGroup.js";
+declare class BindGroup {
+    name: string;
+    bindings: NodeUniformsGroup[] | Binding[];
+    id: number;
+    constructor(name?: string, bindings?: NodeUniformsGroup[]);
+}
+export default BindGroup;

package/three/src/renderers/common/Binding.d.ts

@@ -0,0 +1,8 @@
+declare class Binding {
+    name: string;
+    visibility: number;
+    constructor(name?: string);
+    setVisibility(visibility: number): void;
+    clone(): Binding & this;
+}
+export default Binding;

package/three/src/renderers/common/Bindings.d.ts

@@ -0,0 +1,42 @@
+import ComputeNode from "../../nodes/gpgpu/ComputeNode.js";
+import Attributes from "./Attributes.js";
+import Backend from "./Backend.js";
+import BindGroup from "./BindGroup.js";
+import DataMap from "./DataMap.js";
+import Info from "./Info.js";
+import Nodes from "./nodes/Nodes.js";
+import Pipelines from "./Pipelines.js";
+import RenderObject from "./RenderObject.js";
+import Textures from "./Textures.js";
+interface BindGroupData {
+    bindGroup?: BindGroup | undefined;
+}
+declare class Bindings extends DataMap<{
+    bindGroup: {
+        key: BindGroup;
+        value: BindGroupData;
+    };
+}> {
+    backend: Backend;
+    textures: Textures;
+    pipelines: Pipelines;
+    attributes: Attributes;
+    nodes: Nodes;
+    info: Info;
+    constructor(
+        backend: Backend,
+        nodes: Nodes,
+        textures: Textures,
+        attributes: Attributes,
+        pipelines: Pipelines,
+        info: Info,
+    );
+    getForRender(renderObject: RenderObject): BindGroup[];
+    getForCompute(computeNode: ComputeNode): BindGroup[];
+    updateForCompute(computeNode: ComputeNode): void;
+    updateForRender(renderObject: RenderObject): void;
+    _updateBindings(object: ComputeNode | RenderObject, bindings: BindGroup[]): void;
+    _init(bindGroup: BindGroup): void;
+    _update(object: ComputeNode | RenderObject, bindGroup: BindGroup, bindings: BindGroup[]): void;
+}
+export default Bindings;

package/three/src/renderers/common/Buffer.d.ts

@@ -0,0 +1,11 @@
+import Binding from "./Binding.js";
+declare class Buffer extends Binding {
+    readonly isBuffer: true;
+    bytesPerElement: number;
+    _buffer: Float32Array | null;
+    constructor(name?: string, buffer?: Float32Array | null);
+    get byteLength(): number;
+    get buffer(): Float32Array | null;
+    update(): boolean;
+}
+export default Buffer;

package/three/src/renderers/common/BufferUtils.d.ts

@@ -0,0 +1,4 @@
+declare function getFloatLength(floatLength: number): number;
+declare function getVectorLength(count: number, vectorLength?: number): number;
+declare function getStrideLength(vectorLength: number): number;
+export { getFloatLength, getStrideLength, getVectorLength };

package/three/src/renderers/common/ChainMap.d.ts

@@ -0,0 +1,9 @@
+type RecursiveWeakMap<K extends readonly object[], V> = WeakMap<K[number], V | RecursiveWeakMap<K, V>>;
+export default class ChainMap<K extends readonly object[], V> {
+    weakMap: RecursiveWeakMap<K, V>;
+    constructor();
+    get(keys: K): V | undefined;
+    set(keys: K, value: V): V;
+    delete(keys: K): boolean;
+}
+export {};

package/three/src/renderers/common/ClippingContext.d.ts

@@ -0,0 +1,23 @@
+import { Camera } from "../../cameras/Camera.js";
+import { Material } from "../../materials/Material.js";
+import { Matrix3 } from "../../math/Matrix3.js";
+import { Matrix4 } from "../../math/Matrix4.js";
+import { Plane } from "../../math/Plane.js";
+import { Vector4 } from "../../math/Vector4.js";
+import Renderer from "./Renderer.js";
+declare class ClippingContext {
+    version: number;
+    globalClippingCount: number;
+    localClippingCount: number;
+    localClippingEnabled: boolean | undefined;
+    localClipIntersection: boolean;
+    planes: Vector4[];
+    parentVersion: number;
+    viewNormalMatrix: Matrix3;
+    viewMatrix?: Matrix4 | undefined;
+    constructor();
+    projectPlanes(source: readonly Plane[], offset: number): void;
+    updateGlobal(renderer: Renderer, camera: Camera): void;
+    update(parent: ClippingContext, material: Material): void;
+}
+export default ClippingContext;

package/three/src/renderers/common/Color4.d.ts

@@ -0,0 +1,10 @@
+import { Color, ColorRepresentation } from "../../math/Color.js";
+declare class Color4 extends Color {
+    a: number;
+    constructor(color?: ColorRepresentation);
+    constructor(r: number, g: number, b: number, a?: number);
+    set(...args: [color: ColorRepresentation] | [r: number, g: number, b: number, a?: number]): this;
+    copy(color: Color): this;
+    clone(): this;
+}
+export default Color4;

package/three/src/renderers/common/ComputePipeline.d.ts

@@ -0,0 +1,8 @@
+import Pipeline from "./Pipeline.js";
+import ProgrammableStage from "./ProgrammableStage.js";
+declare class ComputePipeline extends Pipeline {
+    computeProgram: ProgrammableStage;
+    readonly isComputePipeline: true;
+    constructor(cacheKey: string, computeProgram: ProgrammableStage);
+}
+export default ComputePipeline;

package/three/src/renderers/common/Constants.d.ts

@@ -0,0 +1,9 @@
+export declare const AttributeType: {
+    readonly VERTEX: 1;
+    readonly INDEX: 2;
+    readonly STORAGE: 4;
+};
+export type AttributeType = (typeof AttributeType)[keyof typeof AttributeType];
+export declare const GPU_CHUNK_BYTES = 16;
+export declare const BlendColorFactor = 211;
+export declare const OneMinusBlendColorFactor = 212;

package/three/src/renderers/common/CubeRenderTarget.d.ts

@@ -0,0 +1,10 @@
+import { RenderTargetOptions } from "../../core/RenderTarget.js";
+import { WebGLCubeRenderTarget } from "../../renderers/WebGLCubeRenderTarget.js";
+import { Texture } from "../../textures/Texture.js";
+import { WebGLRenderer } from "../WebGLRenderer.js";
+declare class CubeRenderTarget extends WebGLCubeRenderTarget {
+    readonly isCubeRenderTarget: true;
+    constructor(size?: number, options?: RenderTargetOptions);
+    fromEquirectangularTexture(renderer: WebGLRenderer, texture: Texture): this;
+}
+export default CubeRenderTarget;

package/three/src/renderers/common/DataMap.d.ts

@@ -0,0 +1,20 @@
+declare class DataMap<
+    M extends {
+        [key: string]: {
+            key: object;
+            value: unknown;
+        };
+    },
+> {
+    data: WeakMap<M[keyof M]["key"], M[keyof M]["value"]>;
+    constructor();
+    get<K extends M[keyof M]["key"]>(object: K): Extract<M[keyof M], {
+        key: K;
+    }>["value"];
+    delete<K extends M[keyof M]["key"]>(object: K): Extract<M[keyof M], {
+        key: K;
+    }>["value"];
+    has(object: M[keyof M]["key"]): boolean;
+    dispose(): void;
+}
+export default DataMap;

package/three/src/renderers/common/Geometries.d.ts

@@ -0,0 +1,31 @@
+import { BufferAttribute } from "../../core/BufferAttribute.js";
+import { BufferGeometry } from "../../core/BufferGeometry.js";
+import { InterleavedBuffer } from "../../core/InterleavedBuffer.js";
+import { InterleavedBufferAttribute } from "../../core/InterleavedBufferAttribute.js";
+import Attributes from "./Attributes.js";
+import { AttributeType } from "./Constants.js";
+import DataMap from "./DataMap.js";
+import Info from "./Info.js";
+import RenderObject from "./RenderObject.js";
+interface GeometryData {
+    initialized?: boolean | undefined;
+}
+declare class Geometries extends DataMap<{
+    geometry: {
+        key: BufferGeometry;
+        value: GeometryData;
+    };
+}> {
+    attributes: Attributes;
+    info: Info;
+    wireframes: WeakMap<BufferGeometry, BufferAttribute>;
+    attributeCall: WeakMap<BufferAttribute | InterleavedBufferAttribute | InterleavedBuffer, number>;
+    constructor(attributes: Attributes, info: Info);
+    has(renderObject: RenderObject | BufferGeometry): boolean;
+    updateForRender(renderObject: RenderObject): void;
+    initGeometry(renderObject: RenderObject): void;
+    updateAttributes(renderObject: RenderObject): void;
+    updateAttribute(attribute: BufferAttribute | InterleavedBufferAttribute, type: AttributeType): void;
+    getIndex(renderObject: RenderObject): BufferAttribute | null;
+}
+export default Geometries;

package/three/src/renderers/common/Info.d.ts

@@ -0,0 +1,34 @@
+import { Object3D } from "../../core/Object3D.js";
+declare class Info {
+    autoReset: boolean;
+    frame: number;
+    calls: number;
+    render: {
+        calls: number;
+        frameCalls: number;
+        drawCalls: number;
+        triangles: number;
+        points: number;
+        lines: number;
+        timestamp: number;
+        previousFrameCalls: number;
+        timestampCalls: number;
+    };
+    compute: {
+        calls: number;
+        frameCalls: number;
+        timestamp: number;
+        previousFrameCalls: number;
+        timestampCalls: number;
+    };
+    memory: {
+        geometries: number;
+        textures: number;
+    };
+    constructor();
+    update(object: Object3D, count: number, instanceCount: number): void;
+    updateTimestamp(type: "render" | "compute", time: number): void;
+    reset(): void;
+    dispose(): void;
+}
+export default Info;

package/three/src/renderers/common/Pipeline.d.ts

@@ -0,0 +1,6 @@
+declare class Pipeline {
+    cacheKey: string;
+    usedTimes: number;
+    constructor(cacheKey: string);
+}
+export default Pipeline;

package/three/src/renderers/common/Pipelines.d.ts

@@ -0,0 +1,68 @@
+import ComputeNode from "../../nodes/gpgpu/ComputeNode.js";
+import Backend from "./Backend.js";
+import Binding from "./Binding.js";
+import Bindings from "./Bindings.js";
+import ComputePipeline from "./ComputePipeline.js";
+import DataMap from "./DataMap.js";
+import Nodes from "./nodes/Nodes.js";
+import Pipeline from "./Pipeline.js";
+import ProgrammableStage from "./ProgrammableStage.js";
+import RenderObject from "./RenderObject.js";
+import RenderPipeline from "./RenderPipeline.js";
+interface ComputeNodeData {
+    version: number;
+    pipeline: ComputePipeline;
+}
+interface RenderObjectData {
+    pipeline: RenderPipeline;
+}
+declare class Pipelines extends DataMap<{
+    computeNode: {
+        key: ComputeNode;
+        value: ComputeNodeData;
+    };
+    renderObject: {
+        key: RenderObject;
+        value: RenderObjectData;
+    };
+}> {
+    backend: Backend;
+    nodes: Nodes;
+    bindings: Bindings | null;
+    caches: Map<string, Pipeline>;
+    programs: {
+        vertex: Map<string, ProgrammableStage>;
+        fragment: Map<string, ProgrammableStage>;
+        compute: Map<string, ProgrammableStage>;
+    };
+    constructor(backend: Backend, nodes: Nodes);
+    getForCompute(computeNode: ComputeNode, bindings: Binding[]): ComputePipeline;
+    getForRender(renderObject: RenderObject, promises?: Promise<void>[] | null): RenderPipeline;
+    delete(object: ComputeNode | RenderObject): never;
+    dispose(): void;
+    updateForRender(renderObject: RenderObject): void;
+    _getComputePipeline(
+        computeNode: ComputeNode,
+        stageCompute: ProgrammableStage,
+        cacheKey: string,
+        bindings: Binding[],
+    ): ComputePipeline;
+    _getRenderPipeline(
+        renderObject: RenderObject,
+        stageVertex: ProgrammableStage,
+        stageFragment: ProgrammableStage,
+        cacheKey: string,
+        promises: Promise<void>[] | null,
+    ): RenderPipeline;
+    _getComputeCacheKey(computeNode: ComputeNode, stageCompute: ProgrammableStage): string;
+    _getRenderCacheKey(
+        renderObject: RenderObject,
+        stageVertex: ProgrammableStage,
+        stageFragment: ProgrammableStage,
+    ): string;
+    _releasePipeline(pipeline: Pipeline): void;
+    _releaseProgram(program: ProgrammableStage): void;
+    _needsComputeUpdate(computeNode: ComputeNode): boolean;
+    _needsRenderUpdate(renderObject: RenderObject): true | void;
+}
+export default Pipelines;

package/three/src/renderers/common/PostProcessing.d.ts

@@ -0,0 +1,21 @@
+import { Node } from "../../nodes/Nodes.js";
+import Renderer from "./Renderer.js";
+
+declare class PostProcessing {
+    renderer: Renderer;
+    outputNode: Node;
+
+    outputColorTransform: boolean;
+
+    needsUpdate: boolean;
+
+    constructor(renderer: Renderer, outputNode?: Node);
+
+    render(): void;
+
+    update(): void;
+
+    renderAsync(): Promise<void>;
+}
+
+export default PostProcessing;

package/three/src/renderers/common/ProgrammableStage.d.ts

@@ -0,0 +1,15 @@
+import NodeAttribute from "../../nodes/core/NodeAttribute.js";
+declare class ProgrammableStage {
+    id: number;
+    code: string;
+    stage: "compute" | "vertex" | "fragment";
+    attributes: NodeAttribute[] | null;
+    usedTimes: number;
+    constructor(
+        code: string,
+        type: "compute" | "vertex" | "fragment",
+        transforms?: null,
+        attributes?: NodeAttribute[] | null,
+    );
+}
+export default ProgrammableStage;

package/three/src/renderers/common/QuadMesh.d.ts

@@ -0,0 +1,14 @@
+import { OrthographicCamera } from "../../cameras/OrthographicCamera.js";
+import { Material } from "../../materials/Material.js";
+import { Mesh } from "../../objects/Mesh.js";
+import Renderer from "./Renderer.js";
+
+export default class QuadMesh extends Mesh {
+    camera: OrthographicCamera;
+
+    constructor(material?: Material | null);
+
+    renderAsync(renderer: Renderer): Promise<void>;
+
+    render(renderer: Renderer): void;
+}

package/three/src/renderers/common/RenderBundle.d.ts

@@ -0,0 +1,9 @@
+import { Camera } from "../../cameras/Camera.js";
+import { Object3D } from "../../core/Object3D.js";
+declare class RenderBundle {
+    scene: Object3D;
+    camera: Camera;
+    constructor(scene: Object3D, camera: Camera);
+    clone(): RenderBundle & this;
+}
+export default RenderBundle;

package/three/src/renderers/common/RenderBundles.d.ts

@@ -0,0 +1,11 @@
+import { Camera } from "../../cameras/Camera.js";
+import { Object3D } from "../../core/Object3D.js";
+import ChainMap from "./ChainMap.js";
+import RenderBundle from "./RenderBundle.js";
+declare class RenderBundles {
+    lists: ChainMap<readonly [Object3D, Camera], RenderBundle>;
+    constructor();
+    get(scene: Object3D, camera: Camera): RenderBundle;
+    dispose(): void;
+}
+export default RenderBundles;

package/three/src/renderers/common/RenderContext.d.ts

@@ -0,0 +1,41 @@
+import { RenderTarget } from "../../core/RenderTarget.js";
+import { Vector4 } from "../../math/Vector4.js";
+import { DepthTexture } from "../../textures/DepthTexture.js";
+import { Texture } from "../../textures/Texture.js";
+import ClippingContext from "./ClippingContext.js";
+declare class RenderContext {
+    id: number;
+    color: boolean;
+    clearColor: boolean;
+    clearColorValue: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    depth: boolean;
+    clearDepth: boolean;
+    clearDepthValue: number;
+    stencil: boolean;
+    clearStencil: boolean;
+    clearStencilValue: number;
+    viewport: boolean;
+    viewportValue: Vector4;
+    scissor: boolean;
+    scissorValue: Vector4;
+    textures: Texture[] | null;
+    depthTexture: DepthTexture | null;
+    activeCubeFace: number;
+    sampleCount: number;
+    width: number;
+    height: number;
+    readonly isRenderContext: true;
+    clippingContext?: ClippingContext | undefined;
+    depthClearValue?: number | undefined;
+    stencilClearValue?: number | undefined;
+    renderTarget?: RenderTarget | undefined;
+    activeMipmapLevel?: number | undefined;
+    occlusionQueryCount?: number | undefined;
+    constructor();
+}
+export default RenderContext;

package/three/src/renderers/common/RenderContexts.d.ts

@@ -0,0 +1,15 @@
+import { Camera } from "../../cameras/Camera.js";
+import { RenderTarget } from "../../core/RenderTarget.js";
+import { Scene } from "../../scenes/Scene.js";
+import ChainMap from "./ChainMap.js";
+import RenderContext from "./RenderContext.js";
+declare class RenderContexts {
+    chainMaps: {
+        [attachmentState: string]: ChainMap<readonly [Scene, Camera], RenderContext> | undefined;
+    };
+    constructor();
+    get(scene: Scene, camera: Camera, renderTarget?: RenderTarget | null): RenderContext;
+    getChainMap(attachmentState: string): ChainMap<readonly [Scene, Camera], RenderContext>;
+    dispose(): void;
+}
+export default RenderContexts;

package/three/src/renderers/common/RenderList.d.ts

@@ -0,0 +1,66 @@
+import { Camera } from "../../cameras/Camera.js";
+import { BufferGeometry, GeometryGroup } from "../../core/BufferGeometry.js";
+import { Object3D } from "../../core/Object3D.js";
+import { Light } from "../../lights/Light.js";
+import { Material } from "../../materials/Material.js";
+import { LightsNode } from "../../nodes/Nodes.js";
+export interface Bundle {
+    object: Object3D;
+    camera: Camera;
+    renderList: RenderList;
+}
+export interface RenderItem {
+    id: number | null;
+    object: Object3D | null;
+    geometry: BufferGeometry | null;
+    material: Material | null;
+    groupOrder: number | null;
+    renderOrder: number | null;
+    z: number | null;
+    group: GeometryGroup | null;
+}
+declare class RenderList {
+    renderItems: RenderItem[];
+    renderItemsIndex: number;
+    opaque: RenderItem[];
+    transparent: RenderItem[];
+    bundles: Bundle[];
+    lightsNode: LightsNode;
+    lightsArray: Light[];
+    occlusionQueryCount: number;
+    constructor();
+    begin(): this;
+    getNextRenderItem(
+        object: Object3D,
+        geometry: BufferGeometry,
+        material: Material,
+        groupOrder: number,
+        z: number,
+        group: GeometryGroup | null,
+    ): RenderItem;
+    push(
+        object: Object3D,
+        geometry: BufferGeometry,
+        material: Material,
+        groupOrder: number,
+        z: number,
+        group: GeometryGroup | null,
+    ): void;
+    unshift(
+        object: Object3D,
+        geometry: BufferGeometry,
+        material: Material,
+        groupOrder: number,
+        z: number,
+        group: GeometryGroup | null,
+    ): void;
+    pushBundle(group: Bundle): void;
+    pushLight(light: Light): void;
+    getLightsNode(): LightsNode;
+    sort(
+        customOpaqueSort: ((a: RenderItem, b: RenderItem) => number) | null,
+        customTransparentSort: ((a: RenderItem, b: RenderItem) => number) | null,
+    ): void;
+    finish(): void;
+}
+export default RenderList;

package/three/src/renderers/common/RenderLists.d.ts

@@ -0,0 +1,11 @@
+import { Camera } from "../../cameras/Camera.js";
+import { Object3D } from "../../core/Object3D.js";
+import ChainMap from "./ChainMap.js";
+import RenderList from "./RenderList.js";
+declare class RenderLists {
+    lists: ChainMap<readonly [Object3D, Camera], RenderList>;
+    constructor();
+    get(scene: Object3D, camera: Camera): RenderList;
+    dispose(): void;
+}
+export default RenderLists;

package/three/src/renderers/common/RenderObject.d.ts

@@ -0,0 +1,76 @@
+import { Camera } from "../../cameras/Camera.js";
+import { BufferAttribute } from "../../core/BufferAttribute.js";
+import { BufferGeometry } from "../../core/BufferGeometry.js";
+import { InterleavedBuffer } from "../../core/InterleavedBuffer.js";
+import { InterleavedBufferAttribute } from "../../core/InterleavedBufferAttribute.js";
+import { Object3D } from "../../core/Object3D.js";
+import { Material } from "../../materials/Material.js";
+import { LightsNode } from "../../nodes/Nodes.js";
+import { Scene } from "../../scenes/Scene.js";
+import BindGroup from "./BindGroup.js";
+import ClippingContext from "./ClippingContext.js";
+import Geometries from "./Geometries.js";
+import NodeBuilderState from "./nodes/NodeBuilderState.js";
+import Nodes from "./nodes/Nodes.js";
+import RenderContext from "./RenderContext.js";
+import Renderer from "./Renderer.js";
+import RenderPipeline from "./RenderPipeline.js";
+export default class RenderObject {
+    _nodes: Nodes;
+    _geometries: Geometries;
+    id: number;
+    renderer: Renderer;
+    object: Object3D;
+    material: Material;
+    scene: Scene;
+    camera: Camera;
+    lightsNode: LightsNode;
+    context: RenderContext;
+    geometry: BufferGeometry;
+    version: number;
+    drawRange: {
+        start: number;
+        count: number;
+    } | null;
+    attributes: Array<BufferAttribute | InterleavedBufferAttribute> | null;
+    pipeline: RenderPipeline | null;
+    vertexBuffers: Array<BufferAttribute | InterleavedBuffer> | null;
+    clippingContext: ClippingContext;
+    clippingContextVersion: number;
+    initialNodesCacheKey: string;
+    initialCacheKey: string;
+    _nodeBuilderState: NodeBuilderState | null;
+    _bindings: BindGroup[] | null;
+    onDispose: (() => void) | null;
+    readonly isRenderObject: true;
+    onMaterialDispose: () => void;
+    constructor(
+        nodes: Nodes,
+        geometries: Geometries,
+        renderer: Renderer,
+        object: Object3D,
+        material: Material,
+        scene: Scene,
+        camera: Camera,
+        lightsNode: LightsNode,
+        renderContext: RenderContext,
+    );
+    updateClipping(parent: ClippingContext): void;
+    get clippingNeedsUpdate(): boolean;
+    getNodeBuilderState(): NodeBuilderState;
+    getBindings(): BindGroup[];
+    getIndex(): BufferAttribute | null;
+    getChainArray(): readonly [
+        Object3D<import("../../core/Object3D.js").Object3DEventMap>,
+        Material,
+        RenderContext,
+        LightsNode,
+    ];
+    getAttributes(): (InterleavedBufferAttribute | BufferAttribute)[];
+    getVertexBuffers(): (InterleavedBuffer | BufferAttribute)[] | null;
+    getMaterialCacheKey(): string;
+    get needsUpdate(): boolean;
+    getDynamicCacheKey(): string;
+    getCacheKey(): string;
+    dispose(): void;
+}