vim-web 0.3.44-dev.6 → 0.3.44-dev.61

package/dist/types/core-viewers/ultra/{viewer/sectionBox.d.ts → sectionBox.d.ts}

@@ -1,4 +1,4 @@
-import { Box3 } from "../utils/math3d";
+import { Box3 } from "../../utils/math3d";
 import { RpcSafeClient } from "./rpcSafeClient";
 export declare class SectionBox {
     private _visible;
@@ -8,6 +8,7 @@ export declare class SectionBox {
     private _rpc;
     private _interval;
     private _animationFrame;
+    private _pullId;
     private _onUpdate;
     get onUpdate(): import("ste-signals").ISignal;
     private get needUpdate();
@@ -22,7 +23,11 @@ export declare class SectionBox {
     set interactive(value: boolean);
     get clip(): boolean;
     set clip(value: boolean);
+    /**
+     * Fits the given box, invalid dimensions will be reversed.
+     * @param box - The new bounding box.
+     */
     fitBox(box: Box3): void;
-    getBox(): Box3;
+    getBox(): Box3 | undefined;
     dispose(): void;
 }

package/dist/types/core-viewers/ultra/selection.d.ts

@@ -0,0 +1,4 @@
+import { Selection } from "../shared/selection";
+import { Element3D } from "./element3d";
+export type ISelection = Selection<Element3D>;
+export declare function createSelection(): ISelection;

package/dist/types/core-viewers/ultra/{viewer/socketClient.d.ts → socketClient.d.ts}

@@ -1,8 +1,8 @@
-import * as Protocol from './protocol';
-import { Marshal, ReadMarshal } from './marshal';
 import { ILogger } from './logger';
-import { Segment } from '../utils/math3d';
-export declare const DEFAULT_LOCAL_ULTRA_SERVER_URL = "ws://localhost:8123";
+import * as Protocol from './protocol';
+import { Marshal, ReadMarshal } from './rpcMarshal';
+import { Segment } from './rpcTypes';
+export declare const DEFAULT_LOCAL_SERVER_URL = "ws://localhost:8123";
 export type ConnectionSettings = {
     url?: string;
     retries?: number;
@@ -41,13 +41,6 @@ export type ClientStreamError = {
     serverUrl: string;
     details: string;
 };
-export declare enum FrameType {
-    VideoKeyFrame = 0,
-    VideoDeltaFrame = 1,
-    Disconnection = 2,
-    RPCResponse = 255,
-    CameraPose = 254
-}
 /**
  * Messenger class responsible for handling WebSocket communication,
  * including sending and receiving messages, managing connection state,

package/dist/types/core-viewers/ultra/{viewer/viewer.d.ts → viewer.d.ts}

@@ -1,18 +1,19 @@
-import { IInputs } from './inputs/inputs';
-import { ClientState, ConnectionSettings } from './socketClient';
+import type { ISimpleEvent } from 'ste-simple-events';
+import type { InputHandler } from '../shared';
+import { ICamera } from './camera';
+import { ColorManager } from './colorManager';
 import { IDecoder } from './decoder';
-import { Vim } from './vim';
 import { ILoadRequest } from './loadRequest';
 import { ILogger } from './logger';
-import { IViewport } from './viewport';
-import { ColorManager } from './colorManager';
-import { ICamera } from './camera';
-import { RpcSafeClient, VimSource } from './rpcSafeClient';
-import { ISimpleEvent } from 'ste-simple-events';
-import { ViewerSelection } from './selection';
-import { IReadonlyVimCollection } from './vimCollection';
+import { IUltraRaycaster } from './raycaster';
 import { IRenderer } from './renderer';
+import { RpcSafeClient, VimSource } from './rpcSafeClient';
 import { SectionBox } from './sectionBox';
+import { ISelection } from './selection';
+import { ClientState, ConnectionSettings } from './socketClient';
+import { IViewport } from './viewport';
+import { Vim } from './vim';
+import { IReadonlyVimCollection } from './vimCollection';
 export declare const INVALID_HANDLE = 4294967295;
 /**
  * The main Viewer class responsible for managing VIM files,
@@ -28,6 +29,7 @@ export declare class Viewer {
     private readonly _viewport;
     private readonly _camera;
     private readonly _selection;
+    private readonly _raycaster;
     private readonly _vims;
     private _disposed;
     /**
@@ -41,7 +43,7 @@ export declare class Viewer {
     /**
      * The input API for handling user input events.
      */
-    get inputs(): IInputs;
+    get inputs(): InputHandler;
     get vims(): IReadonlyVimCollection;
     /**
      * The viewport API for managing the rendering viewport.
@@ -49,7 +51,8 @@ export declare class Viewer {
     get viewport(): IViewport;
     get renderer(): IRenderer;
     get decoder(): IDecoder;
-    get selection(): ViewerSelection;
+    get raycaster(): IUltraRaycaster;
+    get selection(): ISelection;
     /**
      * API to create, manage, and destroy colors.
      */
@@ -68,7 +71,7 @@ export declare class Viewer {
      * Gets the current connection status of the viewer.
      * @returns The current ClientStatus.
      */
-    get state(): ClientState;
+    get connectionState(): ClientState;
     /**
      * The section box API for controlling the section box.
      */

package/dist/types/core-viewers/ultra/vim.d.ts

@@ -0,0 +1,48 @@
+import type { IVim } from '../shared/vim';
+import type { ILogger } from './logger';
+import { ColorManager } from './colorManager';
+import { Element3D } from './element3d';
+import { LoadRequest } from './loadRequest';
+import { StateSynchronizer } from './nodeState';
+import { Renderer } from './renderer';
+import { RpcSafeClient, VimSource } from './rpcSafeClient';
+import * as THREE from 'three';
+import { RGBA32 } from './rpcTypes';
+export declare class Vim implements IVim<Element3D> {
+    readonly source: VimSource;
+    private _handle;
+    private _request;
+    private readonly _rpc;
+    private _colors;
+    private _renderer;
+    private _logger;
+    readonly nodeState: StateSynchronizer;
+    private _nodeColors;
+    private _updatedColors;
+    private _updateScheduled;
+    private _objects;
+    constructor(rpc: RpcSafeClient, color: ColorManager, renderer: Renderer, source: VimSource, logger: ILogger);
+    getObjectFromInstance(instance: number): Element3D;
+    getObjectsFromElementId(id: number): Element3D[];
+    getObjectFromElementIndex(element: number): Element3D;
+    getObjectsInBox(box: THREE.Box3): Element3D[];
+    getAllObjects(): Element3D[];
+    get handle(): number;
+    get connected(): boolean;
+    connect(): LoadRequest;
+    disconnect(): void;
+    private _load;
+    private getErrorType;
+    private _getHandle;
+    getBoundingBoxNodes(nodes: number[] | 'all'): Promise<THREE.Box3 | undefined>;
+    getBoundingBox(): Promise<THREE.Box3 | undefined>;
+    getColor(node: number): RGBA32 | undefined;
+    setColor(nodes: number[], color: RGBA32 | undefined): Promise<void>;
+    setColors(nodes: number[], color: (RGBA32 | undefined)[]): Promise<void>;
+    private applyColor;
+    clearColor(nodes: number[] | 'all'): void;
+    reapplyColors(): void;
+    private scheduleColorUpdate;
+    private updateRemote;
+    private updateRemoteColors;
+}

package/dist/types/core-viewers/webgl/index.d.ts

@@ -2,24 +2,5 @@ import './style.css';
 import { BFastSource } from 'vim-format';
 export type VimSource = BFastSource;
 export { IProgressLogs } from 'vim-format';
-export * from './loader/progressive/open';
-export * from './loader/progressive/vimRequest';
-export * from './loader/progressive/vimx';
-export * from './viewer/viewer';
-export * from './loader/geometry';
-export type { PointerMode, InputScheme } from './viewer/inputs/input';
-export { DefaultInputScheme, KEYS } from './viewer/inputs/input';
-export * from './viewer/settings/viewerSettings';
-export * from './viewer/settings/viewerSettingsParsing';
-export * from './viewer/settings/defaultViewerSettings';
-export { RaycastResult as HitTestResult, InputAction } from './viewer/raycaster';
-export { type SelectableObject } from './viewer/selection';
-export * from './loader/progressive/insertableMesh';
-export * from './loader/progressive/g3dSubset';
-export * from './loader/geometry';
-export * from './loader/materials/viewerMaterials';
-export * from './loader/object3D';
-export * from './loader/scene';
-export * from './loader/vim';
-export * from './loader/vimSettings';
-export * from './utils/boxes';
+export * from './loader';
+export * from './viewer';

package/dist/types/core-viewers/webgl/loader/{colorAttributes.d.ts → colorAttribute.d.ts}

@@ -3,13 +3,13 @@
  */
 import * as THREE from 'three';
 import { Vim } from './vim';
-import { AttributeTarget } from './objectAttributes';
-export declare class ColorAttribute {
+import { WebglAttributeTarget } from './webglAttribute';
+export declare class WebglColorAttribute {
     readonly vim: Vim;
     private _meshes;
     private _value;
-    constructor(meshes: AttributeTarget[] | undefined, value: THREE.Color | undefined, vim: Vim | undefined);
-    updateMeshes(meshes: AttributeTarget[] | undefined): void;
+    constructor(meshes: WebglAttributeTarget[] | undefined, value: THREE.Color | undefined, vim: Vim | undefined);
+    updateMeshes(meshes: WebglAttributeTarget[] | undefined): void;
     get value(): THREE.Color;
     apply(color: THREE.Color | undefined): void;
     /**

package/dist/types/core-viewers/webgl/loader/{object3D.d.ts → element3d.d.ts}

@@ -5,22 +5,23 @@ import * as THREE from 'three';
 import { Vim } from './vim';
 import { IElement, VimHelpers } from 'vim-format';
 import { Submesh } from './mesh';
+import { IVimObject } from '../../shared/vim';
 /**
  * High level api to interact with the loaded vim geometry and data.
  */
-export declare class Object3D {
+export declare class Element3D implements IVimObject {
     private _color;
     private _boundingBox;
     private _meshes;
-    private _outlineAttribute;
-    private _visibleAttribute;
-    private _coloredAttribute;
-    private _focusedAttribute;
-    private _colorAttribute;
+    private readonly _outlineAttribute;
+    private readonly _visibleAttribute;
+    private readonly _coloredAttribute;
+    private readonly _focusedAttribute;
+    private readonly _colorAttribute;
     /**
      * Indicate whether this object is architectural or markup.
      */
-    readonly type = "Object3D";
+    readonly type = "Element3D";
     /**
      * The vim object from which this object came from.
      */
@@ -42,6 +43,7 @@ export declare class Object3D {
      * @returns {boolean} True if this object has geometry, otherwise false.
      */
     get hasMesh(): boolean;
+    get isRoom(): boolean;
     /**
      * Determines whether to render selection outline for this object or not.
      */
@@ -64,6 +66,7 @@ export declare class Object3D {
      */
     get color(): THREE.Color | undefined;
     set color(color: THREE.Color | undefined);
+    private get renderer();
     /**
      * Constructs a new instance of Object.
      * @param {Vim} vim The Vim instance.
@@ -87,14 +90,14 @@ export declare class Object3D {
      * Returns undefined if the object has no geometry.
      * @returns {THREE.Box3 | undefined} The bounding box of the object, or undefined if the object has no geometry.
      */
-    getBoundingBox(): THREE.Box3;
+    getBoundingBox(): Promise<THREE.Box3>;
     /**
      * Retrieves the center position of this object.
      * @param {THREE.Vector3} [target=new THREE.Vector3()] Optional parameter specifying where to copy the center position data.
      * A new instance is created if none is provided.
      * @returns {THREE.Vector3 | undefined} The center position of the object, or undefined if the object has no geometry.
      */
-    getCenter(target?: THREE.Vector3): THREE.Vector3;
+    getCenter(target?: THREE.Vector3): Promise<THREE.Vector3>;
     /**
      * Internal method used to replace this object's meshes and apply color as needed.
      * @param {Submesh} mesh The new mesh to be added.

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

@@ -24,82 +24,80 @@ export declare namespace Transparency {
      */
     function requiresAlpha(mode: Mode): mode is "all" | "transparentOnly";
 }
-export declare namespace Geometry {
-    /**
-     * Creates a BufferGeometry with all given instances merged
-     * @param instances indices of the instances from the g3d to merge
-     * @returns a BufferGeometry
-     */
-    function createGeometryFromInstances(g3d: G3d, args: MergeArgs): THREE.BufferGeometry<THREE.NormalBufferAttributes>;
-    /**
-     * Creates a BufferGeometry from a given mesh index in the g3d
-     * @param mesh g3d mesh index
-     * @param transparent specify to use RGB or RGBA for colors
-     */
-    function createGeometryFromMesh(g3d: G3d, mesh: number, section: MeshSection, transparent: boolean): THREE.BufferGeometry;
-    /**
-     * Returns a THREE.Matrix4 from the g3d for given instance
-     * @param instance g3d instance index
-     * @param target matrix where the data will be copied, a new matrix will be created if none provided.
-     */
-    function getInstanceMatrix(g3d: G3d, instance: number, target?: THREE.Matrix4): THREE.Matrix4;
-    /**
-     * Creates a BufferGeometry from given geometry data arrays
-     * @param vertices vertex data with 3 number per vertex (XYZ)
-     * @param indices index data with 3 indices per face
-     * @param vertexColors color data with 3 or 4 number per vertex. RBG or RGBA
-     * @param colorSize specify whether to treat colors as RGB or RGBA
-     * @returns a BufferGeometry
-     */
-    function createGeometryFromArrays(vertices: Float32Array, indices: Uint32Array, vertexColors?: Float32Array | undefined, colorSize?: number): THREE.BufferGeometry;
-    /**
-     * Returns a merged mesh of all meshes related to given instances along with picking related metadata
-     * Returns undefined if mesh would be empty
-     * @param section mesh sections to include in the merged mesh.
-     * @param transparent true to use a transparent material.
-     * @param instances instances for which to merge meshes.
-     */
-    function mergeInstanceMeshes(g3d: G3d, mergeArgs: MergeArgs): MergeResult;
-    /**
-     * Returns a merged mesh of all unique meshes along with picking related metadata
-     * @param section mesh sections to include in the merged mesh.
-     * @param transparent true to use a transparent material.
-     * @param instances instances for which to merge meshes.
-     */
-    function mergeUniqueMeshes(g3d: G3d, args: MergeArgs): MergeResult;
-    /**
-     * Holds the info that needs to be precomputed for a merge.
-     */
-    class MergeInfo {
-        section: MeshSection;
-        transparent: boolean;
-        instances: number[];
-        indexCount: number;
-        vertexCount: number;
-        constructor(section: MeshSection, transparent: boolean, instance: number[], indexCount: number, vertexCount: number);
-        createBuffer(): MergeBuffer;
-    }
-    /**
-     * Allocates and holds all arrays needed to merge meshes.
-     */
-    class MergeBuffer {
-        indices: Uint32Array;
-        vertices: Float32Array;
-        colors: Float32Array;
-        groups: number[];
-        colorSize: number;
-        boxes: THREE.Box3[];
-        constructor(info: MergeInfo, positionSize: number, colorSize: number);
-        toBufferGeometry(): THREE.BufferGeometry<THREE.NormalBufferAttributes>;
-    }
-    /**
-     * Holds the result from a merge operation.
-     */
-    class MergeResult {
-        geometry: THREE.BufferGeometry;
-        instances: number[];
-        submeshes: number[];
-        boxes: THREE.Box3[];
-        constructor(geometry: THREE.BufferGeometry, instance: number[], submeshes: number[], boxes: THREE.Box3[]);
-    }
+/**
+ * Creates a BufferGeometry with all given instances merged
+ * @param instances indices of the instances from the g3d to merge
+ * @returns a BufferGeometry
+ */
+export declare function createGeometryFromInstances(g3d: G3d, args: MergeArgs): THREE.BufferGeometry<THREE.NormalBufferAttributes>;
+/**
+ * Creates a BufferGeometry from a given mesh index in the g3d
+ * @param mesh g3d mesh index
+ * @param transparent specify to use RGB or RGBA for colors
+ */
+export declare function createGeometryFromMesh(g3d: G3d, mesh: number, section: MeshSection, transparent: boolean): THREE.BufferGeometry;
+/**
+ * Returns a THREE.Matrix4 from the g3d for given instance
+ * @param instance g3d instance index
+ * @param target matrix where the data will be copied, a new matrix will be created if none provided.
+ */
+export declare function getInstanceMatrix(g3d: G3d, instance: number, target?: THREE.Matrix4): THREE.Matrix4;
+/**
+ * Creates a BufferGeometry from given geometry data arrays
+ * @param vertices vertex data with 3 number per vertex (XYZ)
+ * @param indices index data with 3 indices per face
+ * @param vertexColors color data with 3 or 4 number per vertex. RBG or RGBA
+ * @param colorSize specify whether to treat colors as RGB or RGBA
+ * @returns a BufferGeometry
+ */
+export declare function createGeometryFromArrays(vertices: Float32Array, indices: Uint32Array, vertexColors?: Float32Array | undefined, colorSize?: number): THREE.BufferGeometry;
+/**
+ * Returns a merged mesh of all meshes related to given instances along with picking related metadata
+ * Returns undefined if mesh would be empty
+ * @param section mesh sections to include in the merged mesh.
+ * @param transparent true to use a transparent material.
+ * @param instances instances for which to merge meshes.
+ */
+export declare function mergeInstanceMeshes(g3d: G3d, mergeArgs: MergeArgs): MergeResult;
+/**
+ * Returns a merged mesh of all unique meshes along with picking related metadata
+ * @param section mesh sections to include in the merged mesh.
+ * @param transparent true to use a transparent material.
+ * @param instances instances for which to merge meshes.
+ */
+export declare function mergeUniqueMeshes(g3d: G3d, args: MergeArgs): MergeResult;
+/**
+ * Holds the info that needs to be precomputed for a merge.
+ */
+export declare class MergeInfo {
+    section: MeshSection;
+    transparent: boolean;
+    instances: number[];
+    indexCount: number;
+    vertexCount: number;
+    constructor(section: MeshSection, transparent: boolean, instance: number[], indexCount: number, vertexCount: number);
+    createBuffer(): MergeBuffer;
+}
+/**
+ * Allocates and holds all arrays needed to merge meshes.
+ */
+export declare class MergeBuffer {
+    indices: Uint32Array;
+    vertices: Float32Array;
+    colors: Float32Array;
+    groups: number[];
+    colorSize: number;
+    boxes: THREE.Box3[];
+    constructor(info: MergeInfo, positionSize: number, colorSize: number);
+    toBufferGeometry(): THREE.BufferGeometry<THREE.NormalBufferAttributes>;
+}
+/**
+ * Holds the result from a merge operation.
+ */
+export declare class MergeResult {
+    geometry: THREE.BufferGeometry;
+    instances: number[];
+    submeshes: number[];
+    boxes: THREE.Box3[];
+    constructor(geometry: THREE.BufferGeometry, instance: number[], submeshes: number[], boxes: THREE.Box3[]);
 }

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

@@ -0,0 +1,24 @@
+export * from './vimSettings';
+export { requestVim as request, type RequestSource, type VimRequest } from './progressive/vimRequest';
+export * as Materials from './materials';
+export type { Transparency } from './geometry';
+export type * from './webglAttribute';
+export type * from './colorAttribute';
+export type * from './element3d';
+export type * from './elementMapping';
+export type * from './mesh';
+export type * from './scene';
+export type * from './vim';
+export type * from './progressive/vimx';
+export type * from './progressive/g3dOffsets';
+export type * from './progressive/g3dSubset';
+export type * from './progressive/insertableGeometry';
+export type * from './progressive/insertableMesh';
+export type * from './progressive/insertableSubmesh';
+export type * from './progressive/instancedMesh';
+export type * from './progressive/instancedMeshFactory';
+export type * from './progressive/instancedSubmesh';
+export type * from './progressive/legacyMeshFactory';
+export type * from './progressive/loadingSynchronizer';
+export type * from './progressive/subsetBuilder';
+export type * from './progressive/subsetRequest';

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

@@ -0,0 +1,9 @@
+export * from './ghostMaterial';
+export * from './maskMaterial';
+export * from './materials';
+export * from './mergeMaterial';
+export * from './outlineMaterial';
+export * from './simpleMaterial';
+export * from './skyboxMaterial';
+export * from './standardMaterial';
+export * from './transferMaterial';

package/dist/types/core-viewers/webgl/loader/materials/{viewerMaterials.d.ts → materials.d.ts}

@@ -11,10 +11,10 @@ export type ModelMaterial = THREE.Material | THREE.Material[] | undefined;
 /**
  * Defines the materials to be used by the vim loader and allows for material injection.
  */
-export declare class ViewerMaterials {
-    static instance: ViewerMaterials;
-    static createInstance(instance: ViewerMaterials): void;
-    static getInstance(): ViewerMaterials;
+export declare class Materials {
+    static instance: Materials;
+    static createInstance(instance: Materials): void;
+    static getInstance(): Materials;
     /**
      * Material used for opaque model geometry.
      */
@@ -131,7 +131,7 @@ export declare class ViewerMaterials {
     get outlineAntialias(): boolean;
     set outlineAntialias(value: boolean);
     /**
-     * Size of the blur convolution on the selection outline effect.
+     * Size of the blur convolution on the selection outline effect. Minimum 2.
      */
     get outlineBlur(): number;
     set outlineBlur(value: number);

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

@@ -5,13 +5,13 @@ import * as THREE from 'three';
 import { InsertableSubmesh } from './progressive/insertableSubmesh';
 import { Vim } from './vim';
 import { InstancedSubmesh } from './progressive/instancedSubmesh';
-import { ModelMaterial } from './materials/viewerMaterials';
+import { ModelMaterial } from './materials/materials';
 /**
  * Wrapper around THREE.Mesh
  * Keeps track of what VIM instances are part of this mesh.
  * Is either merged on instanced.
  */
-export declare class Mesh {
+export declare class WebglMesh {
     /**
      * the wrapped THREE mesh
      */
@@ -49,8 +49,8 @@ export declare class Mesh {
      */
     private _material;
     private constructor();
-    static createMerged(mesh: THREE.Mesh, instances: number[], boxes: THREE.Box3[], submeshes: number[]): Mesh;
-    static createInstanced(mesh: THREE.Mesh, instances: number[], boxes: THREE.Box3[]): Mesh;
+    static createMerged(mesh: THREE.Mesh, instances: number[], boxes: THREE.Box3[], submeshes: number[]): WebglMesh;
+    static createInstanced(mesh: THREE.Mesh, instances: number[], boxes: THREE.Box3[]): WebglMesh;
     /**
      * Overrides mesh material, set to undefine to restore initial material.
      */
@@ -81,9 +81,9 @@ export declare class SimpleInstanceSubmesh {
     constructor(mesh: THREE.InstancedMesh, index: number);
 }
 export declare class StandardSubmesh {
-    mesh: Mesh;
+    mesh: WebglMesh;
     index: number;
-    constructor(mesh: Mesh, index: number);
+    constructor(mesh: WebglMesh, index: number);
     equals(other: Submesh): boolean;
     /**
      * Returns parent three mesh.
@@ -112,5 +112,5 @@ export declare class StandardSubmesh {
     /**
      * Returns vim object for this submesh.
      */
-    get object(): import("./object3D").Object3D;
+    get object(): import("./element3d").Element3D;
 }

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

@@ -3,7 +3,7 @@
  */
 import * as THREE from 'three';
 import { G3d, G3dMesh, G3dMaterial } from 'vim-format';
-import { Scene } from '../scene';
+import { WebglScene } from '../scene';
 import { G3dMeshOffsets } from './g3dOffsets';
 export declare class GeometrySubmesh {
     instance: number;
@@ -13,7 +13,7 @@ export declare class GeometrySubmesh {
     expandBox(point: THREE.Vector3): void;
 }
 export declare class InsertableGeometry {
-    _scene: Scene;
+    _scene: WebglScene;
     materials: G3dMaterial;
     offsets: G3dMeshOffsets;
     geometry: THREE.BufferGeometry;

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

@@ -7,7 +7,7 @@ import { InsertableGeometry } from './insertableGeometry';
 import { InsertableSubmesh } from './insertableSubmesh';
 import { G3dMeshOffsets } from './g3dOffsets';
 import { Vim } from '../vim';
-import { ModelMaterial } from '../materials/viewerMaterials';
+import { ModelMaterial } from '../materials/materials';
 export declare class InsertableMesh {
     offsets: G3dMeshOffsets;
     mesh: THREE.Mesh;

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

@@ -37,7 +37,7 @@ export declare class InsertableSubmesh {
     /**
      * Returns vim object for this submesh.
      */
-    get object(): import("../object3D").Object3D;
+    get object(): import("..").Element3D;
     saveColors(colors: Float32Array): void;
     popColors(): Float32Array<ArrayBufferLike>;
 }

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

@@ -5,7 +5,7 @@ import * as THREE from 'three';
 import { Vim } from '../vim';
 import { InstancedSubmesh } from './instancedSubmesh';
 import { G3d, G3dMesh } from 'vim-format';
-import { ModelMaterial } from '../materials/viewerMaterials';
+import { ModelMaterial } from '../materials/materials';
 export declare class InstancedMesh {
     g3dMesh: G3dMesh | G3d;
     vim: Vim;

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

@@ -27,5 +27,5 @@ export declare class InstancedSubmesh {
     /**
      * Returns vim object for this submesh.
      */
-    get object(): import("../object3D").Object3D;
+    get object(): import("..").Element3D;
 }

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

@@ -1,7 +1,7 @@
 /**
  * @module vim-loader
  */
-import { Scene } from '../scene';
+import { WebglScene } from '../scene';
 import { G3dMaterial, G3d } from 'vim-format';
 import { G3dSubset } from './g3dSubset';
 /**
@@ -12,7 +12,7 @@ export declare class VimMeshFactory {
     private _materials;
     private _instancedFactory;
     private _scene;
-    constructor(g3d: G3d, materials: G3dMaterial, scene: Scene);
+    constructor(g3d: G3d, materials: G3dMaterial, scene: WebglScene);
     /**
      * Adds all instances from subset to the scene
      */