vim-web 0.3.44-dev.46 → 0.3.44-dev.50

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

@@ -1,24 +1,25 @@
-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 { CoreInputHandler } from '../../shared/coreInputHandler';
+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,
  * handling connections, and coordinating various components like the camera, decoder, and inputs.
  */
-export declare class UltraCoreViewer {
+export declare class Viewer {
     private readonly _decoder;
     private readonly _socketClient;
     private readonly _input;
@@ -28,6 +29,7 @@ export declare class UltraCoreViewer {
     private readonly _viewport;
     private readonly _camera;
     private readonly _selection;
+    private readonly _raycaster;
     private readonly _vims;
     private _disposed;
     /**
@@ -41,7 +43,7 @@ export declare class UltraCoreViewer {
     /**
      * The input API for handling user input events.
      */
-    get inputs(): CoreInputHandler;
+    get inputs(): InputHandler;
     get vims(): IReadonlyVimCollection;
     /**
      * The viewport API for managing the rendering viewport.
@@ -49,7 +51,8 @@ export declare class UltraCoreViewer {
     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 UltraCoreViewer {
      * 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.
      */
@@ -79,7 +82,7 @@ export declare class UltraCoreViewer {
      * @param logger - Optional logger for logging messages.
      * @returns A new instance of the Viewer class.
      */
-    static createWithCanvas(parent: HTMLElement, logger?: ILogger): UltraCoreViewer;
+    static createWithCanvas(parent: HTMLElement, logger?: ILogger): Viewer;
     /**
      * Constructs a new Viewer instance.
      * @param canvas - The HTML canvas element for rendering.

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,23 +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 * from '../shared/coreInputHandler';
-export * from './viewer/settings/viewerSettings';
-export * from './viewer/settings/viewerSettingsParsing';
-export * from './viewer/settings/defaultViewerSettings';
-export { RaycastResult as HitTestResult } from './viewer/raycaster';
-export { type SelectableObject, Selection } 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,23 @@
+export * from './vimSettings';
+export { requestVim as request, type RequestSource, type VimRequest } from './progressive/vimRequest';
+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.
      */

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
      */

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

@@ -7,7 +7,7 @@ import { G3dSubset } from './g3dSubset';
 import { ISignal, ISignalHandler } from 'ste-signals';
 import { ISubscribable, SubscriptionChangeEventHandler } from 'ste-core';
 import { Vimx } from './vimx';
-import { Scene } from '../scene';
+import { WebglScene } from '../scene';
 export interface SubsetBuilder {
     /** Dispatched whenever a subset begins or finishes loading. */
     onUpdate: ISignal;
@@ -45,7 +45,7 @@ export declare class VimxSubsetBuilder {
     private _onUpdate;
     get onUpdate(): ISignal;
     get isLoading(): boolean;
-    constructor(localVimx: Vimx, scene: Scene);
+    constructor(localVimx: Vimx, scene: WebglScene);
     getFullSet(): G3dSubset;
     loadSubset(subset: G3dSubset, settings?: LoadPartialSettings): Promise<void>;
     clear(): void;

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

@@ -1,7 +1,7 @@
 /**
  * @module vim-loader
  */
-import { Vimx, Scene } from '../..';
+import { Vimx, WebglScene } from '../..';
 import { G3dSubset } from './g3dSubset';
 export type LoadSettings = {
     /** Delay in ms between each rendering list update. @default: 400ms */
@@ -27,7 +27,7 @@ export declare class SubsetRequest {
     private _started;
     private _scene;
     getBoundingBox(): import("three").Box3;
-    constructor(scene: Scene, localVimx: Vimx, subset: G3dSubset);
+    constructor(scene: WebglScene, localVimx: Vimx, subset: G3dSubset);
     dispose(): void;
     start(settings: LoadPartialSettings): Promise<void>;
     private nextFrame;

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

@@ -1,6 +1,6 @@
 import { VimPartialSettings } from '../vimSettings';
 import { Vim } from '../vim';
-import { RequestResult } from '../../../utils/requestResult';
+import { Result } from '../../../../utils/result';
 import { VimSource } from '../..';
 import { IProgressLogs } from 'vim-format';
 export type RequestSource = {
@@ -14,7 +14,7 @@ export type RequestSource = {
  * @param settings the settings to configure how the vim will be loaded.
  * @returns a request object that can be used to track progress and get the result.
  */
-export declare function request(options: RequestSource, settings?: VimPartialSettings): VimRequest;
+export declare function requestVim(options: RequestSource, settings?: VimPartialSettings): VimRequest;
 /**
  * A class that represents a request to load a VIM object from a given source.
  */
@@ -34,7 +34,7 @@ export declare class VimRequest {
      */
     private startRequest;
     private end;
-    getResult(): Promise<RequestResult<Vim>>;
+    getResult(): Promise<Result<Vim>>;
     /**
      * Async generator that yields progress updates.
      * @returns An AsyncGenerator yielding IProgressLogs.