vim-web 0.3.42-dev.5 → 0.3.42-dev.7

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

@@ -0,0 +1,16 @@
+/**
+ * @module vim-loader/materials
+ * This module provides materials for rendering specific visualization modes in VIM.
+ */
+import * as THREE from 'three';
+/**
+ * Creates a material for the ghost effect in isolation mode.
+ *
+ * - **Non-visible items**: Rendered as transparent objects using a customizable fill color.
+ * - **Visible items**: Completely excluded from rendering.
+ * - Designed for use with instanced or merged meshes.
+ * - Includes clipping plane support, vertex colors, and transparency.
+ *
+ * @returns {THREE.ShaderMaterial} A custom shader material for the ghost effect.
+ */
+export declare function createGhostMaterial(): THREE.ShaderMaterial;

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

@@ -1,12 +1,17 @@
 /**
  * @module vim-loader/materials
+ * This module provides custom materials for visualizing and isolating objects in VIM.
  */
 import * as THREE from 'three';
 /**
- * Material for isolation mode
- * Non visible item appear as transparent.
- * Visible items are flat shaded with a basic pseudo lighting.
- * Supports object coloring for visible objects.
- * Non-visible objects use fillColor.
+ * Creates a material for isolation mode.
+ *
+ * - **Non-visible items**: Completely excluded from rendering by pushing them out of view.
+ * - **Visible items**: Rendered with flat shading and basic pseudo-lighting.
+ * - **Object coloring**: Supports both instance-based and vertex-based coloring for visible objects.
+ *
+ * This material is optimized for both instanced and merged meshes, with support for clipping planes.
+ *
+ * @returns {THREE.ShaderMaterial} A custom shader material for isolation mode.
  */
 export declare function createSimpleMaterial(): THREE.ShaderMaterial;

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

@@ -7,6 +7,7 @@ import { OutlineMaterial } from './outlineMaterial';
 import { ViewerSettings } from '../../viewer/settings/viewerSettings';
 import { MergeMaterial } from './mergeMaterial';
 import { SkyboxMaterial } from './skyboxMaterial';
+export type ModelMaterial = THREE.Material | THREE.Material[] | undefined;
 /**
  * Defines the materials to be used by the vim loader and allows for material injection.
  */
@@ -33,7 +34,7 @@ export declare class ViewerMaterials {
     /**
      * Material used to show traces of hidden objects.
      */
-    readonly isolation: THREE.Material;
+    readonly ghost: THREE.Material;
     /**
      * Material used to filter out what is not selected for selection outline effect.
      */
@@ -57,7 +58,7 @@ export declare class ViewerMaterials {
     private _focusIntensity;
     private _focusColor;
     private _onUpdate;
-    constructor(opaque?: StandardMaterial, transparent?: StandardMaterial, simple?: THREE.Material, wireframe?: THREE.LineBasicMaterial, isolation?: THREE.Material, mask?: THREE.ShaderMaterial, outline?: OutlineMaterial, merge?: MergeMaterial, skyBox?: SkyboxMaterial);
+    constructor(opaque?: StandardMaterial, transparent?: StandardMaterial, simple?: THREE.Material, wireframe?: THREE.LineBasicMaterial, ghost?: THREE.Material, mask?: THREE.ShaderMaterial, outline?: OutlineMaterial, merge?: MergeMaterial, skyBox?: SkyboxMaterial);
     /**
      * Updates material settings based on the provided configuration.
      * @param {ViewerSettings} settings - The settings to apply to the materials.
@@ -73,15 +74,15 @@ export declare class ViewerMaterials {
     get modelColor(): THREE.Color;
     set modelColor(color: THREE.Color);
     /**
-     * Determines the opacity of the isolation material.
+     * Determines the opacity of the ghost material.
      */
-    get isolationOpacity(): number;
-    set isolationOpacity(opacity: number);
+    get ghostOpacity(): number;
+    set ghostOpacity(opacity: number);
     /**
-     * Determines the color of the isolation material.
+     * Determines the color of the ghost material.
      */
-    get isolationColor(): THREE.Color;
-    set isolationColor(color: THREE.Color);
+    get ghostColor(): THREE.Color;
+    set ghostColor(color: THREE.Color);
     /**
      * Determines the color intensity of the highlight effect on mouse hover.
      */

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

@@ -5,6 +5,7 @@ import * as THREE from 'three';
 import { InsertableSubmesh } from './progressive/insertableSubmesh';
 import { Vim } from './vim';
 import { InstancedSubmesh } from './progressive/instancedSubmesh';
+import { ModelMaterial } from './materials/viewerMaterials';
 /**
  * Wrapper around THREE.Mesh
  * Keeps track of what VIM instances are part of this mesh.
@@ -53,7 +54,7 @@ export declare class Mesh {
     /**
      * Overrides mesh material, set to undefine to restore initial material.
      */
-    setMaterial(value: THREE.Material): void;
+    setMaterial(value: ModelMaterial): void;
     /**
      * Returns submesh for given index.
      */

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

@@ -7,6 +7,7 @@ import { InsertableGeometry } from './insertableGeometry';
 import { InsertableSubmesh } from './insertableSubmesh';
 import { G3dMeshOffsets } from './g3dOffsets';
 import { Vim } from '../vim';
+import { ModelMaterial } from '../materials/viewerMaterials';
 export declare class InsertableMesh {
     offsets: G3dMeshOffsets;
     mesh: THREE.Mesh;
@@ -55,5 +56,5 @@ export declare class InsertableMesh {
     /**
      * Overrides mesh material, set to undefine to restore initial material.
      */
-    setMaterial(value: THREE.Material): void;
+    setMaterial(value: ModelMaterial): void;
 }

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

@@ -5,6 +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';
 export declare class InstancedMesh {
     g3dMesh: G3dMesh | G3d;
     vim: Vim;
@@ -15,6 +16,7 @@ export declare class InstancedMesh {
     boxes: THREE.Box3[];
     ignoreSceneMaterial: boolean;
     private _material;
+    readonly size: number;
     constructor(g3d: G3dMesh | G3d, mesh: THREE.InstancedMesh, instances: Array<number>);
     get merged(): boolean;
     /**
@@ -25,7 +27,7 @@ export declare class InstancedMesh {
      * Returns all submeshes for given index.
      */
     getSubmeshes(): InstancedSubmesh[];
-    setMaterial(value: THREE.Material): void;
+    setMaterial(value: ModelMaterial): void;
     private computeBoundingBoxes;
     private importBoundingBoxes;
     computeBoundingBox(boxes: THREE.Box3[]): THREE.Box3;

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

@@ -6,6 +6,7 @@ import { Mesh, Submesh } from './mesh';
 import { Vim } from './vim';
 import { InsertableMesh } from './progressive/insertableMesh';
 import { InstancedMesh } from './progressive/instancedMesh';
+import { ModelMaterial } from './materials/viewerMaterials';
 /**
  * Interface for a renderer object, providing methods to add and remove objects from a scene, update bounding boxes, and notify scene updates.
  */
@@ -76,11 +77,11 @@ export declare class Scene {
     /**
      * Gets the current material override or undefined if none.
      */
-    get material(): THREE.Material | undefined;
+    get material(): ModelMaterial;
     /**
      * Sets and apply a material override to the scene, set to undefined to remove override.
      */
-    set material(value: THREE.Material | undefined);
+    set material(value: ModelMaterial);
     /**
      * Unloads and disposes all meshes and leaves the scene ready to add new ones.
      */

package/dist/types/core-viewers/webgl/viewer/environment/environment.d.ts

@@ -5,7 +5,6 @@ import * as THREE from 'three';
 import { ViewerSettings } from '../settings/viewerSettings';
 import { ICamera } from '../camera/camera';
 import { ViewerMaterials } from '../../loader/materials/viewerMaterials';
-import { GroundPlane } from './groundPlane';
 import { Skybox } from './skybox';
 import { Renderer } from '../rendering/renderer';
 import { CameraLight } from './cameraLight';
@@ -23,10 +22,6 @@ export declare class Environment {
      * The array of directional lights in the scene.
      */
     readonly sunLights: ReadonlyArray<CameraLight>;
-    /**
-     * The ground plane under the model in the scene.
-     */
-    readonly groundPlane: GroundPlane;
     readonly skybox: Skybox;
     constructor(camera: ICamera, renderer: Renderer, viewerMaterials: ViewerMaterials, settings: ViewerSettings);
     /**
@@ -36,7 +31,6 @@ export declare class Environment {
     private createSkyLight;
     private createSunLights;
     private addObjectsToRenderer;
-    private setupRendererListeners;
     /**
      * Dispose of all resources.
      */

package/dist/types/core-viewers/webgl/viewer/rendering/renderScene.d.ts

@@ -3,6 +3,8 @@
  */
 import * as THREE from 'three';
 import { Scene } from '../../loader/scene';
+import { ModelMaterial } from '../../loader/materials/viewerMaterials';
+import { InstancedMesh } from '../../loader/progressive/instancedMesh';
 /**
  * Wrapper around the THREE scene that tracks bounding box and other information.
  */
@@ -13,8 +15,8 @@ export declare class RenderScene {
     private _boundingBox;
     private _memory;
     private _2dCount;
-    private _material;
-    get models(): (import("../..").InsertableMesh | import("../../loader/mesh").Mesh | import("../../loader/progressive/instancedMesh").InstancedMesh)[];
+    private _modelMaterial;
+    get meshes(): (import("../..").InsertableMesh | import("../../loader/mesh").Mesh | InstancedMesh)[];
     constructor();
     get estimatedMemory(): number;
     has2dObjects(): boolean;
@@ -45,8 +47,9 @@ export declare class RenderScene {
      * Removes all rendered objects
      */
     clear(): void;
-    get material(): THREE.Material;
-    set material(material: THREE.Material);
+    get modelMaterial(): ModelMaterial;
+    set modelMaterial(material: ModelMaterial);
+    private updateInstanceMeshVisibility;
     private addScene;
     updateBox(box: THREE.Box3 | undefined): void;
     private removeScene;

package/dist/types/core-viewers/webgl/viewer/rendering/renderer.d.ts

@@ -5,7 +5,7 @@ import * as THREE from 'three';
 import { IRenderer, Scene } from '../../loader/scene';
 import { Viewport } from '../viewport';
 import { RenderScene } from './renderScene';
-import { ViewerMaterials } from '../../loader/materials/viewerMaterials';
+import { ModelMaterial, ViewerMaterials } from '../../loader/materials/viewerMaterials';
 import { CSS2DRenderer } from 'three/examples/jsm/renderers/CSS2DRenderer';
 import { Camera } from '../camera/camera';
 import { RenderingSection } from './renderingSection';
@@ -36,7 +36,6 @@ export declare class Renderer implements IRenderer {
     private _composer;
     private _materials;
     private _renderText;
-    private _skipAntialias;
     private _needsUpdate;
     private _onSceneUpdate;
     private _onBoxUpdated;
@@ -52,13 +51,6 @@ export declare class Renderer implements IRenderer {
      */
     get needsUpdate(): boolean;
     set needsUpdate(value: boolean);
-    /**
-   * Indicates whether the next render should skip antialiasing.
-   * Useful for expensive operations such as the section box.
-   * Can only be set to true. Cleared on each render.
-   */
-    get skipAntialias(): boolean;
-    set skipAntialias(value: boolean);
     constructor(scene: RenderScene, viewport: Viewport, materials: ViewerMaterials, camera: Camera, settings: ViewerSettings);
     /**
      * Removes all objects from rendering and disposes the WebGL context.
@@ -69,6 +61,8 @@ export declare class Renderer implements IRenderer {
      */
     get background(): THREE.Color | THREE.Texture;
     set background(color: THREE.Color | THREE.Texture);
+    get modelMaterial(): ModelMaterial;
+    set modelMaterial(material: ModelMaterial);
     /**
      * Signal dispatched at the end of each frame if the scene was updated, such as visibility changes.
      */

package/dist/types/core-viewers/webgl/viewer/selection.d.ts

@@ -51,6 +51,7 @@ export declare class Selection {
      *        or `null`, `undefined`, or an empty array to clear the selection.
      */
     select(object: SelectableObject | SelectableObject[] | undefined): void;
+    any(): boolean;
     /**
      * Returns true if the given object is currently selected.
      * @param {IObject} object The object to check for selection.

package/dist/types/core-viewers/webgl/viewer/settings/viewerSettings.d.ts

@@ -165,41 +165,6 @@ export type ViewerSettings = {
          */
         sharpness: number;
     };
-    /**
-     * Ground plane under the scene options.
-     */
-    groundPlane: {
-        /**
-        * Enables/Disables plane under scene
-        * Default: true
-        */
-        visible: boolean;
-        /**
-        * Controls how the texture will be retrieved using the texture field.
-        * Default: base64
-        */
-        encoding: TextureEncoding;
-        /**
-        * Local or remote texture url for plane
-        * Default: Vim halo ground provided with the viewer.
-        */
-        texture: string;
-        /**
-        * Opacity of the plane
-        * Default: 1
-        */
-        opacity: number;
-        /**
-        * Color of the plane
-        * Default: THREE.Color(0xff, 0xff, 0xff)
-        */
-        color: THREE.Color;
-        /**
-        * Size of the ground plane relative to the model
-        * Default: 5
-        */
-        size: number;
-    };
     /**
     * Object highlight on click options
     */
@@ -226,16 +191,16 @@ export type ViewerSettings = {
             opacity: number;
         };
         /**
-        * Isolation material options
+        * Ghost material options
         */
-        isolation: {
+        ghost: {
             /**
-            * Isolation material color
+            * Ghost material color
             * Default: rgb(78, 82, 92)
             */
             color: THREE.Color;
             /**
-            * Isolation material opacity
+            * Ghost material opacity
             * Default: 0.08
             */
             opacity: number;

package/dist/types/react-viewers/helpers/inputs.d.ts

@@ -3,8 +3,8 @@
  */
 import * as VIM from '../../core-viewers/webgl/index';
 import { SideState } from '../sidePanel/sideState';
-import { Isolation } from './isolation';
 import { ComponentCamera } from './camera';
+import { Isolation } from './isolation';
 /**
  * Custom viewer input scheme for the vim component
  */
@@ -14,7 +14,6 @@ export declare class ComponentInputs implements VIM.InputScheme {
     private _default;
     private _isolation;
     private _sideState;
-    private _help;
     constructor(viewer: VIM.Viewer, camera: ComponentCamera, isolation: Isolation, sideState: SideState);
     private _getSelection;
     onMainAction(hit: VIM.InputAction): void;

package/dist/types/react-viewers/helpers/isolation.d.ts

@@ -1,87 +1,128 @@
-/**
- * @module viw-webgl-react
- */
 import * as VIM from '../../core-viewers/webgl/index';
 import { ComponentSettings } from '../settings/settings';
 import { ComponentCamera } from './camera';
+import { ISimpleEvent } from 'ste-simple-events';
 /**
- * Manages the isolation mechanic in the vim component.
+ * Manages the isolation mechanic in the VIM component.
+ *
+ * **Isolation** determines which objects are visible (isolated) and which are
+ * hidden or displayed as ghosted. This class applies materials, updates object
+ * visibility, and ensures the camera view is adjusted when isolation changes.
  */
 export declare class Isolation {
     private _viewer;
     private _settings;
     private _isolation;
-    private _lastIsolation;
     private _camera;
-    private _references;
     private _onChanged;
-    /** Signal dispatched when the isolation set changes. */
-    get onChanged(): import("ste-simple-events").ISimpleEvent<string>;
-    constructor(viewer: VIM.Viewer, camera: ComponentCamera, settings: ComponentSettings);
-    /**
-     * Applies relevant settings to isolation.
-     * @param settings The settings to be applied to isolation.
-     */
-    applySettings(settings: ComponentSettings): void;
     /**
-     * Sets the reference objects for a given VIM.
-     * @param vim The VIM for which reference objects are being set.
-     * @param reference An array of reference objects or the string 'always' to indicate permanent reference.
+     * An event that is dispatched whenever the isolation set changes.
+     *
+     * @remarks
+     * This can be used by other parts of the application to react to isolation
+     * updates (for example, updating UI or triggering additional viewport actions).
+     *
+     * @returns {ISimpleEvent<string>} Event interface for subscribing to isolation changes.
      */
-    setReference(vim: VIM.Vim, reference: VIM.Object3D[] | 'always'): void;
+    get onChanged(): ISimpleEvent<string>;
     /**
-     * Retrieves the reference objects set for a given VIM.
-     * @param vim The VIM for which reference objects are being retrieved.
-     * @returns The reference objects set for the specified VIM.
+     * Constructs an IsolationManager.
+     *
+     * @param viewer - The VIM Viewer responsible for managing the 3D scene and objects.
+     * @param camera - A component that handles camera control and framing.
+     * @param settings - The settings that control isolation and material usage.
      */
-    getReference(vim: VIM.Vim): Set<VIM.Object3D> | "always";
+    constructor(viewer: VIM.Viewer, camera: ComponentCamera, settings: ComponentSettings);
     /**
-     * Clears all reference objects set for VIMs.
+     * Applies relevant settings to the isolation behavior.
+     *
+     * @param settings - The new settings to apply.
+     *
+     * @remarks
+     * This updates the internal reference to settings and immediately sets
+     * the material based on whether isolation is currently active.
      */
-    clearReferences(): void;
+    applySettings(settings: ComponentSettings): void;
     /**
-     * Returns true if there are currently objects isolated.
-     * @returns True if there are currently objects isolated; otherwise, false.
+     * Checks if isolation is currently active (i.e., any objects are isolated).
+     *
+     * @returns True if isolation is active; otherwise, false.
      */
-    any(): boolean;
+    isActive(): boolean;
     /**
-     * Returns the current array of isolated objects.
-     * @returns The array of objects currently isolated, or undefined if no objects are isolated.
+     * Retrieves the current array of isolated objects.
+     *
+     * @returns An array of isolated objects, or undefined if isolation is not active.
      */
-    current(): VIM.Object3D[];
+    current(): VIM.Object3D[] | undefined;
     /**
-     * Isolates the objects in the given array and shows the rest as ghost.
-     * @param objects An array of objects to isolate.
-     * @param source The source of isolation.
-     * @returns True if isolation occurs; otherwise, false.
+     * Sets the specified objects as isolated, hiding or ghosting the rest.
+     *
+     * @param objects - The objects to isolate.
+     * @param source - A label or identifier indicating the source of this action (e.g., "user").
      */
-    isolate(objects: VIM.Object3D[], source: string): boolean;
+    isolate(objects: VIM.Object3D[], source: string): void;
     /**
-     * Toggles current isolation based on selection.
-     * @param source The source of isolation.
+     * Toggles isolation by using the current selection.
+     *
+     * @param source - A label or identifier for the isolation action.
+     *
+     * @remarks
+     * This method replaces the current isolation set with whatever objects are
+     * currently selected. If selection is empty, it effectively clears isolation.
      */
-    toggleIsolation(source: string): void;
+    toggle(source: string): void;
     /**
-     * Removes the given objects from the isolation set.
-     * @param objects An array of objects to be removed from isolation.
-     * @param source The source of the removal operation.
+     * Hides the specified objects from the isolation set.
+     *
+     * @param objects - The objects to hide.
+     * @param source - A label or identifier for the isolation action.
+     *
+     * @remarks
+     * If there is no active isolation set (i.e., all objects are visible),
+     * the method first treats all objects in the scene as isolated,
+     * and then removes the specified objects. This ensures the specified
+     * objects become hidden.
      */
     hide(objects: VIM.Object3D[], source: string): void;
     /**
-     * Adds the given objects to the isolation set.
-     * @param objects An array of objects to be added to isolation.
-     * @param source The source of the addition operation.
+     * Adds the specified objects to the current isolation set (making them visible).
+     *
+     * @param objects - The objects to show.
+     * @param source - A label or identifier for the isolation action.
      */
     show(objects: VIM.Object3D[], source: string): void;
     /**
-     * Clears the current isolation.
-     * @param source The source of the isolation clearing operation.
+     * Clears the current isolation set, making all objects visible.
+     *
+     * @param source - A label or identifier for the isolation action.
      */
     clear(source: string): void;
     /**
-     * Show all objects and quit isolation mode.
+     * Constructs the correct material (or array of materials) based on the given settings.
+     *
+     * @param settings - The current component settings, including isolation rules.
+     * @param isolate - Whether or not isolation is active.
+     * @returns The material(s) to assign to the renderer, or undefined if default materials should be used.
+     *
+     * @remarks
+     * - If isolation is active and `useGhostMaterial` is true, an array containing
+     *   the simple and ghost materials is returned.
+     * - If fast materials are enabled, the simple material is returned.
+     * - Otherwise, defaults to undefined, allowing the system to pick a standard material.
+     */
+    private getMaterial;
+    /**
+     * Applies the current isolation state: sets visibility for objects, updates materials,
+     * and dispatches the changed event.
+     *
+     * @param source - A label or identifier for the isolation action.
+     */
+    private _apply;
+    /**
+     * Gathers all objects from all loaded VIM instances.
+     *
+     * @returns An array of all objects within the loaded VIM scenes.
      */
-    private _showAll;
-    getMaterial(settings: ComponentSettings, isolate: boolean): import("three").Material;
-    private _isolate;
+    private getAllObjects;
 }

package/dist/types/react-viewers/settings/settings.d.ts

@@ -32,12 +32,12 @@ export declare function isFalse(value: UserBoolean | boolean): value is false |
  * @interface ComponentSettings
  */
 export type ComponentSettings = {
-    peformance: {
+    materials: {
         useFastMaterial: boolean;
+        useGhostMaterial: boolean;
     };
     isolation: {
         enable: boolean;
-        useIsolationMaterial: boolean;
     };
     capacity: {
         canFollowUrl: boolean;