vim-web 0.3.44-dev.8 → 0.3.44-dev.80

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

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.

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

@@ -2,17 +2,18 @@
  * @module vim-loader
  */
 import * as THREE from 'three';
-import { Mesh, Submesh } from './mesh';
+import { WebglMesh, Submesh } from './mesh';
 import { Vim } from './vim';
 import { InsertableMesh } from './progressive/insertableMesh';
 import { InstancedMesh } from './progressive/instancedMesh';
-import { ModelMaterial } from './materials/viewerMaterials';
+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;
+    add(scene: WebglScene | THREE.Object3D): any;
+    remove(scene: WebglScene): any;
     updateBox(box: THREE.Box3): any;
     notifySceneUpdate(): any;
 }
@@ -20,22 +21,18 @@ export interface IRenderer {
  * 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 {
+export declare class WebglScene {
     private _renderer;
     private _vim;
     private _matrix;
     insertables: InsertableMesh[];
-    meshes: (Mesh | InsertableMesh | InstancedMesh)[];
-    private _outlineCount;
+    meshes: (WebglMesh | InsertableMesh | InstancedMesh)[];
     private _boundingBox;
     private _averageBoundingBox;
     private _instanceToMeshes;
     private _material;
     constructor(matrix: THREE.Matrix4);
     setDirty(): void;
-    hasOutline(): boolean;
-    addOutline(): void;
-    removeOutline(): void;
     clearUpdateFlag(): void;
     /**
      * Returns the scene bounding box. Returns undefined if scene is empty.
@@ -55,8 +52,8 @@ export declare class Scene {
      */
     getMeshFromInstance(instance: number): Submesh[];
     getMeshesFromInstances(instances: number[] | undefined): Submesh[];
-    get renderer(): IRenderer;
-    set renderer(value: IRenderer);
+    get renderer(): Renderer;
+    set renderer(value: Renderer);
     get vim(): Vim;
     /**
      * Sets vim index for this scene and all its THREE.Meshes.
@@ -69,11 +66,11 @@ export declare class Scene {
      * 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;
+    addMesh(mesh: WebglMesh | InsertableMesh | InstancedMesh): this;
     /**
      * Adds the content of other Scene to this Scene and recomputes fields as needed.
      */
-    merge(other: Scene): this;
+    merge(other: WebglScene): this;
     /**
      * Gets the current material override or undefined if none.
      */

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

@@ -3,20 +3,21 @@
  */
 import * as THREE from 'three';
 import { VimDocument, G3d, VimHeader, FilterMode } from 'vim-format';
-import { Scene } from './scene';
+import { WebglScene } from './scene';
 import { VimSettings } from './vimSettings';
-import { Object3D } from './object3D';
+import { Element3D as WebglElement3D } 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 {
+export declare class Vim implements IVim<WebglElement3D> {
     /**
      * Indicates whether the vim was opened from a vim or vimx file.
      */
@@ -44,7 +45,7 @@ export declare class Vim {
     /**
      * Mostly Internal - The scene in which the vim geometry is added.
      */
-    readonly scene: Scene;
+    readonly scene: WebglScene;
     /**
      * The mapping from Bim to Geometry for this vim.
      */
@@ -73,7 +74,7 @@ export declare class Vim {
    * @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 {WebglScene} scene - The scene containing the vim's geometry.
    * @param {VimSettings} settings - The settings used to open this vim.
    * @param {ElementMapping | ElementNoMapping | ElementMapping2} map - The element mapping.
    * @param {SubsetBuilder} builder - The subset builder for constructing subsets of the Vim object.
@@ -81,7 +82,8 @@ export declare class Vim {
    * @param {VimFormat} format - The format of the Vim object.
    * @param {boolean} isLegacy - Indicates whether the Vim object uses a legacy loading pipeline.
    */
-    constructor(header: VimHeader | undefined, document: VimDocument, g3d: G3d | undefined, scene: Scene, settings: VimSettings, map: ElementMapping | ElementNoMapping | ElementMapping2, builder: SubsetBuilder, source: string, format: VimFormat);
+    constructor(header: VimHeader | undefined, document: VimDocument, g3d: G3d | undefined, scene: WebglScene, settings: VimSettings, 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.
@@ -92,36 +94,30 @@ export declare class Vim {
      * @param {number} instance - The instance number of the object.
      * @returns {THREE.Object3D | undefined} The object corresponding to the instance, or undefined if not found.
      */
-    getObjectFromInstance(instance: number): Object3D;
+    getElementFromInstanceIndex(instance: number): WebglElement3D;
     /**
      * 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.
      */
-    getObjectsFromElementId(id: number): any;
+    getElementFromId(id: number): any;
     /**
      * Retrieves the Vim object associated with the given Vim element index.
      * @param {number} element - The index of the Vim element.
-     * @returns {Object3D | undefined} The Vim object corresponding to the element index, or undefined if not found.
+     * @returns {WebglElement3D | undefined} The Vim object corresponding to the element index, or undefined if not found.
      */
-    getObjectFromElement(element: number): Object3D | undefined;
-    /**
-     * Retrieves an array containing all Vim objects strictly contained within the specified bounding box.
-     * @param {THREE.Box3} box - The bounding box to search within.
-     * @returns {Object3D[]} An array of Vim objects strictly contained within the bounding box.
-     */
-    getObjectsInBox(box: THREE.Box3): Object3D[];
+    getElementFromIndex(element: number): WebglElement3D | undefined;
     /**
      * Retrieves an array of all objects within the Vim.
-     * @returns {Object3D[]} An array containing all objects within the Vim.
+     * @returns {WebglElement3D[]} An array containing all objects within the Vim.
      */
-    getObjects(): Object3D[];
+    getAllElements(): WebglElement3D[];
     /**
      * Retrieves an array containing all objects within the specified subset.
      * @param {G3dSubset} subset - The subset to retrieve objects from.
-     * @returns {Object3D[]} An array of objects within the specified subset.
+     * @returns {WebglElement3D[]} An array of objects within the specified subset.
      */
-    getObjectsInSubset(subset: G3dSubset): Object3D[];
+    getObjectsInSubset(subset: G3dSubset): WebglElement3D[];
     /**
      * Retrieves all instances as a subset.
      * @returns {G3dSubset} A subset containing all instances.

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

@@ -49,7 +49,7 @@ export type VimSettings = {
 /**
  * Default configuration settings for a vim object.
  */
-export declare const defaultConfig: VimSettings;
+export declare function getDefaultVimSettings(): VimSettings;
 /**
  * Represents a partial configuration of settings for a vim object.
  */
@@ -59,4 +59,4 @@ export type VimPartialSettings = Partial<VimSettings>;
  * @param {VimPartialSettings} [options] - Optional partial settings for the Vim object.
  * @returns {VimSettings} The complete settings for the Vim object, including defaults.
  */
-export declare function getFullSettings(options?: VimPartialSettings): VimSettings;
+export declare function createVimSettings(options?: VimPartialSettings): VimSettings;

package/dist/types/core-viewers/webgl/loader/{objectAttributes.d.ts → webglAttribute.d.ts}

@@ -2,16 +2,16 @@
  * @module vim-loader
  */
 import { SimpleInstanceSubmesh, Submesh } from './mesh';
-export type AttributeTarget = Submesh | SimpleInstanceSubmesh;
-export declare class ObjectAttribute<T> {
+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: AttributeTarget[] | undefined, toNumber: (value: T) => number);
-    updateMeshes(meshes: AttributeTarget[] | undefined): void;
+    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;