vim-web 0.6.0-dev.3 → 0.6.0-dev.6

package/dist/types/core-viewers/webgl/loader/progressive/legacyMeshFactory.d.ts

@@ -1,26 +0,0 @@
-/**
- * @module vim-loader
- */
-import { Scene } from '../scene';
-import { G3dMaterial, G3d } from 'vim-format';
-import { G3dSubset } from './g3dSubset';
-import { ElementMapping } from '../elementMapping';
-/**
- * Mesh factory to load a standard vim using the progressive pipeline.
- */
-export declare class VimMeshFactory {
-    readonly g3d: G3d;
-    private _materials;
-    private _instancedFactory;
-    private _scene;
-    private _mapping;
-    private _vimIndex;
-    constructor(g3d: G3d, materials: G3dMaterial, scene: Scene, mapping: ElementMapping, vimIndex?: number);
-    /**
-     * Adds all instances from subset to the scene
-     */
-    add(subset: G3dSubset): void;
-    private addMergedMesh;
-    private createMergedMesh;
-    private addInstancedMeshes;
-}

package/dist/types/core-viewers/webgl/loader/progressive/loadRequest.d.ts

@@ -1,21 +0,0 @@
-import { VimPartialSettings } from '../vimSettings';
-import { Vim } from '../vim';
-import { LoadRequest as BaseLoadRequest, ILoadRequest as BaseILoadRequest } from '../../../shared/loadResult';
-import { VimSource } from '../..';
-export type RequestSource = {
-    url?: string;
-    buffer?: ArrayBuffer;
-    headers?: Record<string, string>;
-};
-export type ILoadRequest = BaseILoadRequest<Vim>;
-/**
- * A request to load a VIM file. Extends the base LoadRequest to add BFast abort handling.
- * Loading starts immediately upon construction.
- */
-export declare class LoadRequest extends BaseLoadRequest<Vim> {
-    private _bfast;
-    constructor(source: VimSource, settings: VimPartialSettings, vimIndex: number);
-    private startRequest;
-    private loadFromVim;
-    abort(): void;
-}

package/dist/types/core-viewers/webgl/loader/progressive/loadingSynchronizer.d.ts

@@ -1,27 +0,0 @@
-/**
- * @module vim-loader
- */
-import { G3dMesh } from 'vim-format';
-import { G3dSubset } from './g3dSubset';
-/**
- * Makes sure both instanced meshes and merged meshes are requested in the right order
- * Also decouples downloads and processing.
- */
-export declare class LoadingSynchronizer {
-    done: boolean;
-    uniques: G3dSubset;
-    nonUniques: G3dSubset;
-    getMesh: (mesh: number) => Promise<G3dMesh>;
-    mergeAction: (mesh: G3dMesh, index: number) => void;
-    instanceAction: (mesh: G3dMesh, index: number) => void;
-    mergeQueue: (() => void)[];
-    instanceQueue: (() => void)[];
-    constructor(uniques: G3dSubset, nonUniques: G3dSubset, getMesh: (mesh: number) => Promise<G3dMesh>, mergeAction: (mesh: G3dMesh, index: number) => void, instanceAction: (mesh: G3dMesh, index: number) => void);
-    get isDone(): boolean;
-    abort(): void;
-    loadAll(): Promise<void>;
-    private consumeQueues;
-    private getSortedPromises;
-    merge(mesh: number, index: number): Promise<void>;
-    instance(mesh: number, index: number): Promise<void>;
-}

package/dist/types/core-viewers/webgl/loader/progressive/subsetBuilder.d.ts

@@ -1,74 +0,0 @@
-/**
- * @module vim-loader
- */
-import { VimMeshFactory } from './legacyMeshFactory';
-import { LoadPartialSettings, LoadSettings } from './subsetRequest';
-import { G3dSubset } from './g3dSubset';
-import { ISignal, ISignalHandler } from 'ste-signals';
-import { ISubscribable, SubscriptionChangeEventHandler } from 'ste-core';
-import { Vimx } from './vimx';
-import { Scene } from '../scene';
-export interface SubsetBuilder {
-    /** Dispatched whenever a subset begins or finishes loading. */
-    onUpdate: ISignal;
-    /** Returns true when some subset is being loaded. */
-    isLoading: boolean;
-    /** Returns all instances as a subset */
-    getFullSet(): G3dSubset;
-    /** Loads given subset with given options */
-    loadSubset(subset: G3dSubset, settings?: LoadPartialSettings): any;
-    /** Stops and clears all loading processes */
-    clear(): any;
-    dispose(): any;
-}
-/**
- * Loads and builds subsets from a Vim file.
- */
-export declare class VimSubsetBuilder implements SubsetBuilder {
-    factory: VimMeshFactory;
-    private _onUpdate;
-    get onUpdate(): ISignal;
-    get isLoading(): boolean;
-    constructor(factory: VimMeshFactory);
-    getFullSet(): G3dSubset;
-    loadSubset(subset: G3dSubset, settings?: LoadPartialSettings): void;
-    clear(): void;
-    dispose(): void;
-}
-/**
- * Loads and builds subsets from a VimX file.
- */
-export declare class VimxSubsetBuilder {
-    private _localVimx;
-    private _scene;
-    private _vimIndex;
-    private _set;
-    private _onUpdate;
-    get onUpdate(): ISignal;
-    get isLoading(): boolean;
-    constructor(localVimx: Vimx, scene: Scene, vimIndex?: number);
-    getFullSet(): G3dSubset;
-    loadSubset(subset: G3dSubset, settings?: LoadPartialSettings): Promise<void>;
-    clear(): void;
-    dispose(): void;
-}
-export declare class DummySubsetBuilder implements SubsetBuilder {
-    get onUpdate(): AlwaysTrueSignal;
-    get isLoading(): boolean;
-    getFullSet(): G3dSubset;
-    loadSubset(subset: G3dSubset, settings?: Partial<LoadSettings>): void;
-    clear(): void;
-    dispose(): void;
-}
-declare class AlwaysTrueSignal implements ISignal {
-    count: number;
-    subscribe(fn: ISignalHandler): () => void;
-    sub(fn: ISignalHandler): () => void;
-    unsubscribe(fn: ISignalHandler): void;
-    unsub(fn: ISignalHandler): void;
-    one(fn: ISignalHandler): () => void;
-    has(fn: ISignalHandler): boolean;
-    clear(): void;
-    onSubscriptionChange: ISubscribable<SubscriptionChangeEventHandler>;
-}
-export {};

package/dist/types/core-viewers/webgl/loader/progressive/subsetRequest.d.ts

@@ -1,38 +0,0 @@
-/**
- * @module vim-loader
- */
-import { Scene } from '../scene';
-import { Vimx } from './vimx';
-import { G3dSubset } from './g3dSubset';
-export type LoadSettings = {
-    /** Delay in ms between each rendering list update. @default: 400ms */
-    updateDelayMs: number;
-    /** If true, will wait for geometry to be ready before it is added to the renderer. @default: false */
-    delayRender: boolean;
-};
-export type LoadPartialSettings = Partial<LoadSettings>;
-/**
- * Manages geometry downloads and loads it into a scene for rendering.
- */
-export declare class SubsetRequest {
-    private _subset;
-    private _uniques;
-    private _nonUniques;
-    private _opaqueMesh;
-    private _transparentMesh;
-    private _synchronizer;
-    private _meshFactory;
-    private _meshes;
-    private _pushedMesh;
-    private _disposed;
-    private _started;
-    private _scene;
-    getBoundingBox(): import("three").Box3;
-    constructor(scene: Scene, localVimx: Vimx, subset: G3dSubset, vimIndex?: number);
-    dispose(): void;
-    start(settings: LoadPartialSettings): Promise<void>;
-    private nextFrame;
-    private mergeMesh;
-    private instanceMesh;
-    private updateMeshes;
-}

package/dist/types/core-viewers/webgl/loader/progressive/vimx.d.ts

@@ -1,17 +0,0 @@
-/**
- * @module vim-loader
- */
-import { G3dMaterial, RemoteVimx, VimHeader, G3dScene } from 'vim-format';
-/**
- * Interface to interact with a vimx
- */
-export declare class Vimx {
-    private readonly vimx;
-    readonly scene: G3dScene;
-    readonly materials: G3dMaterial;
-    readonly header: VimHeader;
-    static fromRemote(vimx: RemoteVimx, downloadMeshes: boolean): Promise<Vimx>;
-    private constructor();
-    getMesh(mesh: number): Promise<import("vim-format").G3dMesh>;
-    abort(): void;
-}

package/dist/types/core-viewers/webgl/loader/scene.d.ts

@@ -1,90 +0,0 @@
-/**
- * @module vim-loader
- */
-import * as THREE from 'three';
-import { Mesh, Submesh } from './mesh';
-import { Vim } from './vim';
-import { InsertableMesh } from './progressive/insertableMesh';
-import { InstancedMesh } from './progressive/instancedMesh';
-import { ModelMaterial } from './materials/materials';
-import { Renderer } from '../viewer/rendering/renderer';
-/**
- * Interface for a renderer object, providing methods to add and remove objects from a scene, update bounding boxes, and notify scene updates.
- */
-export interface IRenderer {
-    add(scene: Scene | THREE.Object3D): any;
-    remove(scene: Scene): any;
-    updateBox(box: THREE.Box3): any;
-    notifySceneUpdate(): any;
-}
-/**
- * Represents a scene that contains multiple meshes.
- * It tracks the global bounding box as meshes are added and maintains a mapping between g3d instance indices and meshes.
- */
-export declare class Scene {
-    private _renderer;
-    private _vim;
-    private _matrix;
-    insertables: InsertableMesh[];
-    meshes: (Mesh | InsertableMesh | InstancedMesh)[];
-    private _boundingBox;
-    private _averageBoundingBox;
-    private _instanceToMeshes;
-    private _material;
-    constructor(matrix: THREE.Matrix4);
-    setDirty(): void;
-    clearUpdateFlag(): void;
-    /**
-     * Returns the scene bounding box. Returns undefined if scene is empty.
-     */
-    getBoundingBox(target?: THREE.Box3): THREE.Box3;
-    /**
-     * Returns the bounding box of the average center of all meshes.
-     * Less precise but is more stable against outliers.
-     */
-    getAverageBoundingBox(): THREE.Box3;
-    updateBox(box: THREE.Box3): void;
-    getMemory(): number;
-    /**
-     * Returns the THREE.Mesh in which this instance is represented along with index
-     * For merged mesh, index refers to submesh index
-     * For instanced mesh, index refers to instance index.
-     */
-    getMeshFromInstance(instance: number): Submesh[];
-    getMeshesFromInstances(instances: number[] | undefined): Submesh[];
-    get renderer(): Renderer;
-    set renderer(value: Renderer);
-    get vim(): Vim;
-    /**
-     * Sets vim index for this scene and all its THREE.Meshes.
-     */
-    set vim(value: Vim);
-    addSubmesh(submesh: Submesh): void;
-    /**
-     * Add an instanced mesh to the Scene and recomputes fields as needed.
-     * @param mesh Is expected to have:
-     * userData.instances = number[] (indices of the g3d instances that went into creating the mesh)
-     * userData.boxes = THREE.Box3[] (bounding box of each instance)
-     */
-    addMesh(mesh: Mesh | InsertableMesh | InstancedMesh): this;
-    /**
-     * Adds the content of other Scene to this Scene and recomputes fields as needed.
-     */
-    merge(other: Scene): this;
-    /**
-     * Gets the current material override or undefined if none.
-     */
-    get material(): ModelMaterial;
-    /**
-     * Sets and apply a material override to the scene, set to undefined to remove override.
-     */
-    set material(value: ModelMaterial);
-    /**
-     * Unloads and disposes all meshes and leaves the scene ready to add new ones.
-     */
-    clear(): void;
-    /**
-     * Disposes of all resources.
-     */
-    dispose(): void;
-}

package/dist/types/core-viewers/webgl/loader/vim.d.ts

@@ -1,163 +0,0 @@
-/**
- * @module vim-loader
- */
-import * as THREE from 'three';
-import { VimDocument, G3d, VimHeader, FilterMode } from 'vim-format';
-import { Scene } from './scene';
-import { VimSettings } from './vimSettings';
-import { Element3D } from './element3d';
-import { ElementMapping, ElementMapping2, ElementNoMapping } from './elementMapping';
-import { ISignal } from 'ste-signals';
-import { G3dSubset } from './progressive/g3dSubset';
-import { SubsetBuilder } from './progressive/subsetBuilder';
-import { LoadPartialSettings } from './progressive/subsetRequest';
-import { IVim } from '../../shared/vim';
-type VimFormat = 'vim' | 'vimx';
-/**
- * Represents a container for the built three.js meshes and the vim data from which they were constructed.
- * Facilitates high-level scene manipulation by providing access to objects.
- */
-export declare class Vim implements IVim<Element3D> {
-    /**
-     * The type of the viewer, indicating it is a WebGL viewer.
-     * Useful for distinguishing between different viewer types in a multi-viewer application.
-     */
-    readonly type = "webgl";
-    /**
-     * The stable ID of this vim in the scene's vim collection (0-255).
-     * Used for GPU picking to identify which vim an element belongs to.
-     */
-    readonly vimIndex: number;
-    /**
-     * Indicates whether the vim was opened from a vim or vimx file.
-     */
-    readonly format: VimFormat;
-    /**
-     * Indicates the url this vim came from if applicable.
-     */
-    readonly source: string | undefined;
-    /**
-     * The header for this vim.
-     */
-    readonly header: VimHeader | undefined;
-    /**
-     * The interface to access bim data related to this vim if available.
-     */
-    readonly bim: VimDocument | undefined;
-    /**
-     * The raw g3d geometry scene definition.
-     */
-    readonly g3d: G3d | undefined;
-    /**
-     * The settings used when this vim was opened.
-     */
-    readonly settings: VimSettings;
-    /**
-     * Mostly Internal - The scene in which the vim geometry is added.
-     */
-    readonly scene: Scene;
-    /**
-     * The mapping from Bim to Geometry for this vim.
-     */
-    readonly map: ElementMapping | ElementNoMapping | ElementMapping2;
-    private readonly _builder;
-    private readonly _loadedInstances;
-    private readonly _elementToObject;
-    /**
-     * Getter for accessing the event dispatched whenever a subset begins or finishes loading.
-     * @returns {ISignal} The event dispatcher for loading updates.
-     */
-    get onLoadingUpdate(): ISignal;
-    /**
-     * Indicates whether there are subsets currently being loaded.
-     * @returns {boolean} True if subsets are being loaded; otherwise, false.
-     */
-    get isLoading(): boolean;
-    /**
-     * Getter for accessing the signal dispatched when the object is disposed.
-     * @returns {ISignal} The signal for disposal events.
-     */
-    get onDispose(): ISignal;
-    private _onDispose;
-    /**
-   * Constructs a new instance of a Vim object with the provided parameters.
-   * @param {VimHeader | undefined} header - The Vim header, if available.
-   * @param {VimDocument} document - The Vim document.
-   * @param {G3d | undefined} g3d - The G3d object, if available.
-   * @param {Scene} scene - The scene containing the vim's geometry.
-   * @param {VimSettings} settings - The settings used to open this vim.
-   * @param {number} vimIndex - The stable ID of this vim (0-255) for GPU picking.
-   * @param {ElementMapping | ElementNoMapping | ElementMapping2} map - The element mapping.
-   * @param {SubsetBuilder} builder - The subset builder for constructing subsets of the Vim object.
-   * @param {string} source - The source of the Vim object.
-   * @param {VimFormat} format - The format of the Vim object.
-   */
-    constructor(header: VimHeader | undefined, document: VimDocument, g3d: G3d | undefined, scene: Scene, settings: VimSettings, vimIndex: number, map: ElementMapping | ElementNoMapping | ElementMapping2, builder: SubsetBuilder, source: string, format: VimFormat);
-    getBoundingBox(): Promise<THREE.Box3>;
-    /**
-     * Retrieves the matrix representation of the Vim object's position, rotation, and scale.
-     * @returns {THREE.Matrix4} The matrix representing the Vim object's transformation.
-     */
-    getMatrix(): THREE.Matrix4;
-    /**
-     * Retrieves the object associated with the specified instance number.
-     * @param {number} instance - The instance number of the object.
-     * @returns {THREE.Object3D | undefined} The object corresponding to the instance, or undefined if not found.
-     */
-    getElement(instance: number): Element3D;
-    /**
-     * Retrieves the objects associated with the specified element ID.
-     * @param {number} id - The element ID to retrieve objects for.
-     * @returns {THREE.Object3D[]} An array of objects corresponding to the element ID, or an empty array if none are found.
-     */
-    getElementsFromId(id: number): any;
-    /**
-     * Retrieves the Vim object associated with the given Vim element index.
-     * @param {number} element - The index of the Vim element.
-     * @returns {WebglElement3D | undefined} The Vim object corresponding to the element index, or undefined if not found.
-     */
-    getElementFromIndex(element: number): Element3D | undefined;
-    /**
-     * Retrieves an array of all objects within the Vim.
-     * @returns {WebglElement3D[]} An array containing all objects within the Vim.
-     */
-    getAllElements(): Element3D[];
-    /**
-     * Retrieves an array containing all objects within the specified subset.
-     * @param {G3dSubset} subset - The subset to retrieve objects from.
-     * @returns {WebglElement3D[]} An array of objects within the specified subset.
-     */
-    getObjectsInSubset(subset: G3dSubset): Element3D[];
-    /**
-     * Retrieves all instances as a subset.
-     * @returns {G3dSubset} A subset containing all instances.
-     */
-    getFullSet(): G3dSubset;
-    /**
-     * Asynchronously loads all geometry according to the provided settings.
-     * @param {LoadPartialSettings} [settings] - Optional settings for the loading process.
-     */
-    loadAll(settings?: LoadPartialSettings): Promise<void>;
-    /**
-     * Asynchronously loads geometry for the specified subset according to the provided settings.
-     * @param {G3dSubset} subset - The subset to load resources for.
-     * @param {LoadPartialSettings} [settings] - Optional settings for the loading process.
-     */
-    loadSubset(subset: G3dSubset, settings?: LoadPartialSettings): Promise<void>;
-    /**
-     * Asynchronously loads geometry based on a specified filter mode and criteria.
-     * @param {FilterMode} filterMode - The mode of filtering to apply.
-     * @param {number[]} filter - The filter criteria.
-     * @param {LoadPartialSettings} [settings] - Optional settings for the loading process.
-     */
-    loadFilter(filterMode: FilterMode, filter: number[], settings?: LoadPartialSettings): Promise<void>;
-    /**
-     * Removes the current geometry from the renderer.
-     */
-    clear(): void;
-    /**
-     * Cleans up and releases resources associated with the vim.
-     */
-    dispose(): void;
-}
-export {};

package/dist/types/core-viewers/webgl/loader/vimCollection.d.ts

@@ -1,79 +0,0 @@
-/**
- * @module vim-loader
- */
-import { ISignal } from 'ste-signals';
-import { IVimCollection } from '../../shared/vimCollection';
-import { Vim } from './vim';
-/**
- * Maximum number of vims that can be loaded simultaneously.
- * Limited by the 8-bit vimIndex in GPU picking.
- * Index 255 is reserved for marker gizmos, so vims use 0-254.
- */
-export declare const MAX_VIMS = 255;
-/**
- * Manages a collection of Vim objects with stable IDs for GPU picking.
- *
- * Each vim is assigned a stable ID (0-255) that persists for its lifetime.
- * IDs are allocated sequentially and only reused after all 256 have been used.
- * This ensures GPU picker can correctly identify vims even after removals.
- */
-export declare class VimCollection implements IVimCollection<Vim> {
-    private _vimsById;
-    private _nextId;
-    private _freedIds;
-    private _count;
-    private _onChanged;
-    /**
-     * Signal dispatched when collection changes (add/remove/clear).
-     */
-    get onChanged(): ISignal;
-    /**
-     * Allocates a stable ID for a new vim.
-     * Fresh IDs are allocated sequentially (0, 1, 2, ..., 255).
-     * Freed IDs are only reused after all 256 have been allocated once.
-     * @returns The allocated ID, or undefined if all 256 IDs are in use
-     */
-    allocateId(): number | undefined;
-    /**
-     * Whether the collection has reached maximum capacity (256 vims).
-     */
-    get isFull(): boolean;
-    /**
-     * The number of vims currently in the collection.
-     */
-    get count(): number;
-    /**
-     * Adds a vim to the collection using its vimIndex as the ID.
-     * The vim's vimIndex should have been allocated via allocateId().
-     * @param vim The vim to add
-     * @throws Error if the vim's vimIndex slot is already occupied
-     */
-    add(vim: Vim): void;
-    /**
-     * Removes a vim from the collection and frees its ID for reuse.
-     * @param vim The vim to remove
-     * @throws Error if the vim is not in the collection
-     */
-    remove(vim: Vim): void;
-    /**
-     * Gets a vim by its stable ID.
-     * @param id The stable ID (0-255)
-     * @returns The vim at that ID, or undefined if empty
-     */
-    getFromId(id: number): Vim | undefined;
-    /**
-     * Checks if a vim is in the collection.
-     * @param vim The vim to check
-     * @returns True if the vim is in the collection
-     */
-    has(vim: Vim): boolean;
-    /**
-     * Returns all vims as a packed array (for iteration).
-     * @returns Array of all vims currently in the collection
-     */
-    getAll(): Vim[];
-    /**
-     * Clears all vims from the collection and resets ID allocation.
-     */
-    clear(): void;
-}

package/dist/types/core-viewers/webgl/loader/vimSettings.d.ts

@@ -1,69 +0,0 @@
-/**
- * @module vim-loader
- */
-import { Transparency } from './geometry';
-import * as THREE from 'three';
-type FileType = 'vim' | 'vimx' | undefined;
-/**
- * Represents settings for configuring the behavior and rendering of a vim object.
- */
-export type VimSettings = {
-    /**
-     * The positional offset for the vim object.
-     */
-    position: THREE.Vector3;
-    /**
-     * The XYZ rotation applied to the vim object.
-     */
-    rotation: THREE.Vector3;
-    /**
-     * The scaling factor applied to the vim object.
-     */
-    scale: number;
-    /**
-     * The matrix representation of the vim object's position, rotation, and scale.
-     * Setting this will override individual position, rotation, and scale properties.
-     */
-    matrix: THREE.Matrix4;
-    /**
-     * Determines whether objects are drawn based on their transparency.
-     */
-    transparency: Transparency.Mode;
-    /**
-     * Set to true to enable verbose HTTP logging.
-     */
-    verboseHttp: boolean;
-};
-/**
- * Internal settings type that includes vimx-specific fields.
- * Used internally for loading vimx files.
- */
-export type VimSettingsFull = VimSettings & {
-    /**
-     * Specifies the file type (vim or vimx) if it cannot or should not be inferred from the file extension.
-     */
-    fileType: FileType;
-    /**
-     * Set to true to stream geometry to the scene. Only supported with vimx files.
-     */
-    progressive: boolean;
-    /**
-     * The time in milliseconds between each scene refresh during progressive loading.
-     */
-    progressiveInterval: number;
-};
-/**
- * Default configuration settings for a vim object.
- */
-export declare function getDefaultVimSettings(): VimSettingsFull;
-/**
- * Represents a partial configuration of settings for a vim object.
- */
-export type VimPartialSettings = Partial<VimSettings>;
-/**
- * Wraps Vim options, converting values to related THREE.js types and providing default values.
- * @param {VimPartialSettings} [options] - Optional partial settings for the Vim object.
- * @returns {VimSettingsFull} The complete settings for the Vim object, including defaults.
- */
-export declare function createVimSettings(options?: VimPartialSettings): VimSettingsFull;
-export {};

package/dist/types/core-viewers/webgl/loader/webglAttribute.d.ts

@@ -1,19 +0,0 @@
-/**
- * @module vim-loader
- */
-import { SimpleInstanceSubmesh, Submesh } from './mesh';
-export type WebglAttributeTarget = Submesh | SimpleInstanceSubmesh;
-export declare class WebglAttribute<T> {
-    readonly vertexAttribute: string;
-    readonly instanceAttribute: string;
-    readonly defaultValue: T;
-    readonly toNumber: (value: T) => number;
-    private _value;
-    private _meshes;
-    constructor(value: T, vertexAttribute: string, instanceAttribute: string, meshes: WebglAttributeTarget[] | undefined, toNumber: (value: T) => number);
-    updateMeshes(meshes: WebglAttributeTarget[] | undefined): void;
-    get value(): T;
-    apply(value: T): boolean;
-    private applyInstanced;
-    private applyMerged;
-}

package/dist/types/core-viewers/webgl/utils/boxes.d.ts

@@ -1,5 +0,0 @@
-/**
- * @module utils
- */
-import * as THREE from 'three';
-export declare function createBoxes(boxes: THREE.Box3[]): THREE.InstancedMesh<THREE.BoxGeometry, THREE.MeshBasicMaterial, THREE.InstancedMeshEventMap>;