@cognite/reveal 4.27.0-dev.20251001 → 4.27.1

package/dist/packages/cad-geometry-loaders/src/sector/ModelStateHandler.d.ts

@@ -5,8 +5,8 @@ import { LevelOfDetail } from '../../../cad-parsers';
 export declare class ModelStateHandler {
     private readonly _sceneModelState;
     constructor();
-    hasStateChanged(modelIdentifier: string, sectorId: number, levelOfDetail: LevelOfDetail): boolean;
-    addModel(modelIdentifier: string): void;
-    removeModel(modelIdentifier: string): void;
-    updateState(modelIdentifier: string, sectorId: number, levelOfDetail: LevelOfDetail): void;
+    hasStateChanged(modelIdentifier: symbol, sectorId: number, levelOfDetail: LevelOfDetail): boolean;
+    addModel(modelIdentifier: symbol): void;
+    removeModel(modelIdentifier: symbol): void;
+    updateState(modelIdentifier: symbol, sectorId: number, levelOfDetail: LevelOfDetail): void;
 }

package/dist/packages/cad-geometry-loaders/src/sector/rxSectorUtilities.d.ts

@@ -8,5 +8,5 @@ export interface ModelState {
     [id: number]: LevelOfDetail;
 }
 export interface SceneModelState {
-    [modelIdentifier: string]: ModelState;
+    [modelIdentifier: symbol]: ModelState;
 }

package/dist/packages/cad-model/src/wrappers/CadMeshManager.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Copyright 2021 Cognite AS
+ */
+import { CadMaterialManager } from '../../../rendering';
+import { ParsedMeshGeometry } from '../../../cad-parsers';
+import { TreeIndexToSectorsMap } from '../utilities/TreeIndexToSectorsMap';
+import { SectorRepository } from '../../../sector-loader';
+import { ModelIdentifier } from '../../../data-providers';
+import { Group } from 'three';
+/**
+ * Manages mesh data for CAD sectors.
+ * This class prepares mesh data for object creation.
+ */
+export declare class CadMeshManager {
+    private readonly _materialManager;
+    private readonly _modelIdentifier;
+    private readonly _treeIndexToSectorsMap;
+    private readonly _sectorMeshGroups;
+    constructor(materialManager: CadMaterialManager, modelIdentifier: symbol, treeIndexToSectorsMap: TreeIndexToSectorsMap);
+    /**
+     * Creates meshes from parsed geometries for a given sector.
+     * @param parsedMeshGeometries Array of parsed mesh geometries to create meshes from
+     * @param sectorId The sector ID these meshes belong to
+     * @returns Group containing the created meshes
+     */
+    createMeshesFromParsedGeometries(parsedMeshGeometries: ParsedMeshGeometry[], sectorId: number): Group;
+    /**
+     * Removes mesh group for the given sector ID.
+     * Note: This does not dispose the underlying geometries as they may be shared with other models.
+     * @param sectorId The sector ID whose mesh group should be removed
+     */
+    private removeSectorMeshGroup;
+    /**
+     * Removes mesh group and dereferences the sector in the repository.
+     * This should be called when a model stops using a sector to properly manage reference counting.
+     * @param sectorId The sector ID whose mesh group should be removed
+     * @param sectorRepository The sector repository to dereference from
+     * @param modelIdentifier The model identifier for dereferencing
+     */
+    removeSectorMeshGroupAndDereference(sectorId: number, sectorRepository: SectorRepository, modelIdentifier: ModelIdentifier): void;
+    /**
+     * Gets all currently managed sector IDs.
+     */
+    getManagedSectorIds(): number[];
+    /**
+     * Checks if a sector is currently managed by this mesh manager.
+     * @param sectorId The sector ID to check
+     * @returns True if the sector is managed, false otherwise
+     */
+    hasManagedSector(sectorId: number): boolean;
+    /**
+     * Creates a mesh from geometry, material, and bounding box.
+     */
+    private createMeshFromGeometry;
+    /**
+     * Updates tree index to sectors mapping from a set of tree indices.
+     */
+    private updateTreeIndexToSectorsMap;
+    private createTreeIndexSet;
+}

package/dist/packages/cad-model/src/wrappers/CadNode.d.ts

@@ -6,14 +6,16 @@ import { SectorScene, CadModelMetadata, RootSectorNode, WantedSector, ConsumedSe
 import { SectorRepository } from '../../../sector-loader';
 import { ParsedGeometry } from '../../../sector-parser';
 import { CadMaterialManager, NodeTransformProvider, RenderMode } from '../../../rendering';
-import { Object3D, Plane, Matrix4, Object3DEventMap } from 'three';
+import { Group, Object3D, Plane, Matrix4, Object3DEventMap } from 'three';
 import { TreeIndexToSectorsMap } from '../utilities/TreeIndexToSectorsMap';
+import { ParsedMeshGeometry } from '../../../cad-parsers';
 export declare class CadNode extends Object3D<Object3DEventMap & {
     update: undefined;
 }> {
     private readonly _cadModelMetadata;
     private readonly _materialManager;
     private readonly _sectorRepository;
+    private readonly _modelIdentifier;
     private _rootSector;
     private _sectorScene;
     private _geometryBatchingManager?;
@@ -24,6 +26,7 @@ export declare class CadNode extends Object3D<Object3DEventMap & {
     private readonly _styledTreeIndexSets;
     private _isDisposed;
     private _needsRedraw;
+    private readonly _meshManager;
     readonly treeIndexToSectorsMap: TreeIndexToSectorsMap;
     readonly type = "CadNode";
     constructor(model: CadModelMetadata, materialManager: CadMaterialManager, sectorRepository: SectorRepository);
@@ -36,7 +39,7 @@ export declare class CadNode extends Object3D<Object3DEventMap & {
     get clippingPlanes(): Plane[];
     set clippingPlanes(planes: Plane[]);
     get cadModelMetadata(): CadModelMetadata;
-    get cadModelIdentifier(): string;
+    get cadModelIdentifier(): symbol;
     get sectorScene(): SectorScene;
     get rootSector(): RootSectorNode;
     get materialManager(): CadMaterialManager;
@@ -59,6 +62,13 @@ export declare class CadNode extends Object3D<Object3DEventMap & {
     get prioritizedAreas(): PrioritizedArea[];
     batchGeometry(geometryBatchingQueue: ParsedGeometry[], sectorId: number): void;
     removeBatchedSectorGeometries(sectorId: number): void;
+    /**
+     * Removes sector mesh group and properly dereferences it in the sector repository.
+     * This ensures proper reference counting for shared geometry between duplicate models.
+     * @param sectorId The sector ID to remove and dereference
+     */
+    removeSectorMeshGroupWithDereferencing(sectorId: number): void;
+    createMeshesFromParsedGeometries(parsedMeshGeometries: ParsedMeshGeometry[], sectorId: number): Group;
     setCacheSize(sectorCount: number): void;
     dispose(): void;
 }

package/dist/packages/cad-parsers/index.d.ts

@@ -11,5 +11,5 @@ export { SectorNode } from './src/sector/SectorNode';
 export { RootSectorNode } from './src/sector/RootSectorNode';
 export { LevelOfDetail } from './src/cad/LevelOfDetail';
 export { filterGeometryOutsideClipBox } from './src/cad/filterPrimitivesV9';
-export { InstancedMeshFile, InstancedMesh, TriangleMesh, WantedSector, ConsumedSector } from './src/cad/types';
+export { InstancedMeshFile, InstancedMesh, TriangleMesh, WantedSector, ConsumedSector, ParsedMeshGeometry } from './src/cad/types';
 export { getDistanceToMeterConversionFactor } from './src/utilities/types';

package/dist/packages/cad-parsers/src/cad/types.d.ts

@@ -2,10 +2,10 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { AutoDisposeGroup } from '../../../utilities';
 import { SectorMetadata } from '../metadata/types';
 import { LevelOfDetail } from './LevelOfDetail';
 import { ParsedGeometry } from '../../../sector-parser';
+import { ModelIdentifier } from '../../../data-providers';
 export type TriangleMesh = {
     readonly fileId: number;
     readonly indices: Uint32Array;
@@ -28,17 +28,20 @@ export type InstancedMesh = {
     readonly treeIndices: Float32Array;
 };
 export interface ConsumedSector {
-    modelIdentifier: string;
+    modelIdentifier: ModelIdentifier;
     metadata: SectorMetadata;
     levelOfDetail: LevelOfDetail;
-    group: AutoDisposeGroup | undefined;
     instancedMeshes: InstancedMeshFile[] | undefined;
     geometryBatchingQueue?: ParsedGeometry[];
+    parsedMeshGeometries?: ParsedMeshGeometry[];
 }
 export interface WantedSector {
-    modelIdentifier: string;
+    modelIdentifier: ModelIdentifier;
     modelBaseUrl: string;
     geometryClipBox: THREE.Box3 | null;
     levelOfDetail: LevelOfDetail;
     metadata: SectorMetadata;
 }
+export type ParsedMeshGeometry = ParsedGeometry & {
+    wholeSectorBoundingBox: THREE.Box3;
+};

package/dist/packages/cad-parsers/src/metadata/CadModelMetadata.d.ts

@@ -4,12 +4,12 @@
 import * as THREE from 'three';
 import { SectorScene } from '../utilities/types';
 import { CameraConfiguration } from '../../../utilities';
-import { File3dFormat } from '../../../data-providers';
+import { File3dFormat, ModelIdentifier } from '../../../data-providers';
 export interface CadModelMetadata {
     /**
      * A unique identifier of the model.
      */
-    readonly modelIdentifier: string;
+    readonly modelIdentifier: ModelIdentifier;
     /**
      * File format of the 3D model (i3d/f3d, gltf, etc.)
      */

package/dist/packages/cad-parsers/src/metadata/CadModelMetadataRepository.d.ts

@@ -9,7 +9,6 @@ export declare class CadModelMetadataRepository implements MetadataRepository<Pr
     private readonly _modelDataProvider;
     private readonly _cadSceneParser;
     private readonly _blobFileName;
-    private _currentModelIdentifier;
     constructor(modelMetadataProvider: ModelMetadataProvider, modelDataProvider: ModelDataProvider, blobFileName?: string);
     loadData(modelIdentifier: ModelIdentifier): Promise<CadModelMetadata>;
     private getSupportedOutput;

package/dist/packages/cad-parsers/src/sector/SectorNode.d.ts

@@ -2,7 +2,6 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { AutoDisposeGroup } from '../../../utilities';
 import { LevelOfDetail } from '../cad/LevelOfDetail';
 export declare class SectorNode extends THREE.Group {
     readonly sectorPath: string;
@@ -16,7 +15,6 @@ export declare class SectorNode extends THREE.Group {
     get levelOfDetail(): LevelOfDetail;
     get group(): THREE.Group | undefined;
     get updatedTimestamp(): number;
-    updateGeometry(geometryGroup: AutoDisposeGroup | undefined, levelOfDetail: LevelOfDetail): void;
-    dereference(): void;
+    updateGeometry(geometryGroup: THREE.Group | undefined, levelOfDetail: LevelOfDetail): void;
     resetGeometry(): void;
 }

package/dist/packages/data-providers/src/ModelIdentifier.d.ts

@@ -10,5 +10,10 @@ export interface ModelIdentifier {
      * Unique ID of the model.
      */
     readonly revealInternalId: symbol;
+    /**
+     * Returns an identifier in a serialized form, which uniquely identifies
+     * the model from the data source
+     */
+    sourceModelIdentifier(): string;
 }
 export declare function createModelIdentifier(identifier: ClassicModelIdentifierType | (DMModelIdentifierType & ClassicModelIdentifierType) | LocalModelIdentifierType): ModelIdentifier;

package/dist/packages/data-providers/src/model-identifiers/CdfModelIdentifier.d.ts

@@ -1,7 +1,7 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-import { ModelIdentifier } from '../..';
+import { ModelIdentifier } from '../ModelIdentifier';
 /**
  * Identifies a 3D model stored in CDF by the combination of a modelId, a revisionId
  * and a format.
@@ -12,4 +12,9 @@ export declare class CdfModelIdentifier implements ModelIdentifier {
     readonly revisionId: number;
     constructor(modelId: number, revisionId: number);
     toString(): string;
+    /**
+     * Returns an identifier in a serialized form, which uniquely identifies
+     * the model in CDF
+     */
+    sourceModelIdentifier(): string;
 }

package/dist/packages/data-providers/src/model-identifiers/DMModelIdentifier.d.ts

@@ -9,4 +9,5 @@ export declare class DMModelIdentifier extends CdfModelIdentifier {
     readonly revisionSpace: string;
     constructor({ modelId, revisionId, revisionExternalId, revisionSpace }: DMModelIdentifierType & ClassicModelIdentifierType);
     toString(): string;
+    sourceModelIdentifier(): string;
 }

package/dist/packages/data-providers/src/model-identifiers/LocalModelIdentifier.d.ts

@@ -11,4 +11,5 @@ export declare class LocalModelIdentifier implements ModelIdentifier {
     readonly localPath: string;
     constructor(localPath: string);
     toString(): string;
+    sourceModelIdentifier(): string;
 }

package/dist/packages/rendering/src/CadMaterialManager.d.ts

@@ -16,21 +16,20 @@ export declare class CadMaterialManager {
     private _clippingPlanes;
     on(event: 'materialsChanged', listener: () => void): void;
     off(event: 'materialsChanged', listener: () => void): void;
-    addModelMaterials(modelIdentifier: string, maxTreeIndex: number): void;
-    removeModelMaterials(modelIdentifier: string): void;
-    addTexturedMeshMaterial(modelIdentifier: string, sectorId: number, texture: THREE.Texture): THREE.RawShaderMaterial;
-    removeTexturedMeshMaterial(modelIdentifier: string, sectorId: number): void;
-    getModelMaterials(modelIdentifier: string): Materials;
-    getModelNodeAppearanceProvider(modelIdentifier: string): NodeAppearanceProvider;
-    getModelNodeTransformProvider(modelIdentifier: string): NodeTransformProvider;
-    getModelDefaultNodeAppearance(modelIdentifier: string): NodeAppearance;
-    getModelClippingPlanes(modelIdentifier: string): THREE.Plane[];
-    setModelClippingPlanes(modelIdentifier: string, clippingPlanes: THREE.Plane[]): void;
-    setModelDefaultNodeAppearance(modelIdentifier: string, defaultAppearance: NodeAppearance): void;
-    getModelBackTreeIndices(modelIdentifier: string): IndexSet;
-    getModelInFrontTreeIndices(modelIdentifier: string): IndexSet;
-    getModelGhostedTreeIndices(modelIdentifier: string): IndexSet;
-    getModelVisibleTreeIndices(modelIdentifier: string): IndexSet;
+    addModelMaterials(modelIdentifier: symbol, maxTreeIndex: number): void;
+    removeModelMaterials(modelIdentifier: symbol): void;
+    addTexturedMeshMaterial(modelIdentifier: symbol, sectorId: number, texture: THREE.Texture): THREE.RawShaderMaterial;
+    getModelMaterials(modelIdentifier: symbol): Materials;
+    getModelNodeAppearanceProvider(modelIdentifier: symbol): NodeAppearanceProvider;
+    getModelNodeTransformProvider(modelIdentifier: symbol): NodeTransformProvider;
+    getModelDefaultNodeAppearance(modelIdentifier: symbol): NodeAppearance;
+    getModelClippingPlanes(modelIdentifier: symbol): THREE.Plane[];
+    setModelClippingPlanes(modelIdentifier: symbol, clippingPlanes: THREE.Plane[]): void;
+    setModelDefaultNodeAppearance(modelIdentifier: symbol, defaultAppearance: NodeAppearance): void;
+    getModelBackTreeIndices(modelIdentifier: symbol): IndexSet;
+    getModelInFrontTreeIndices(modelIdentifier: symbol): IndexSet;
+    getModelGhostedTreeIndices(modelIdentifier: symbol): IndexSet;
+    getModelVisibleTreeIndices(modelIdentifier: symbol): IndexSet;
     setRenderMode(mode: RenderMode): void;
     getRenderMode(): RenderMode;
     dispose(): void;

package/dist/packages/rendering/src/utilities/renderUtilities.d.ts

@@ -20,7 +20,7 @@ export declare enum RenderLayer {
     Default = 0
 }
 export declare function getLayerMask(renderLayer: number): number;
-export declare function hasStyledNodes(modelIdentifiers: string[], materialManager: CadMaterialManager): {
+export declare function hasStyledNodes(modelIdentifiers: symbol[], materialManager: CadMaterialManager): {
     back: boolean;
     inFront: boolean;
     ghost: boolean;

package/dist/packages/sector-loader/src/GltfSectorLoader.d.ts

@@ -1,12 +1,11 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
 import { ConsumedSector, WantedSector } from '../../cad-parsers';
 import { BinaryFileProvider } from '../../data-providers';
-import { CadMaterialManager } from '../../rendering';
 export declare class GltfSectorLoader {
     private readonly _gltfSectorParser;
     private readonly _sectorFileProvider;
-    private readonly _materialManager;
-    constructor(sectorFileProvider: BinaryFileProvider, materialManager: CadMaterialManager);
+    constructor(sectorFileProvider: BinaryFileProvider);
     loadSector(sector: WantedSector, abortSignal?: AbortSignal): Promise<ConsumedSector>;
-    private createTreeIndexSet;
-    private createMesh;
 }

package/dist/packages/sector-loader/src/GltfSectorRepository.d.ts

@@ -2,18 +2,24 @@
  * Copyright 2021 Cognite AS
  */
 import { ConsumedSector, WantedSector } from '../../cad-parsers';
-import { BinaryFileProvider } from '../../data-providers';
-import { CadMaterialManager } from '../../rendering';
+import { BinaryFileProvider, ModelIdentifier } from '../../data-providers';
 import { SectorRepository } from './SectorRepository';
 export declare class GltfSectorRepository implements SectorRepository {
     private readonly _gltfSectorLoader;
     private readonly _gltfCache;
-    constructor(sectorFileProvider: BinaryFileProvider, materialManager: CadMaterialManager);
+    constructor(sectorFileProvider: BinaryFileProvider);
     private getEmptySectorWithLod;
     private getEmptyDetailedSector;
     private getEmptyDiscardedSector;
     loadSector(sector: WantedSector, abortSignal?: AbortSignal): Promise<ConsumedSector>;
     setCacheSize(sectorCount: number): void;
     clearCache(): void;
+    /**
+     * Dereferences a sector when a model stops using it.
+     * The cache handles reference counting and automatic disposal when count reaches zero.
+     * @param modelIdentifier The model identifier that was using the sector
+     * @param sectorId The sector ID to dereference
+     */
+    dereferenceSector(modelIdentifier: ModelIdentifier, sectorId: number): void;
     private wantedSectorCacheKey;
 }

package/dist/packages/sector-loader/src/SectorRepository.d.ts

@@ -2,9 +2,15 @@
  * Copyright 2021 Cognite AS
  */
 import { ConsumedSector, WantedSector } from '../../cad-parsers';
+import { ModelIdentifier } from '../../data-providers';
 export type SectorId = number;
 export interface SectorRepository {
     loadSector(sector: WantedSector, abortSignal?: AbortSignal): Promise<ConsumedSector>;
     setCacheSize(sectorCount: number): void;
     clearCache(): void;
+    /**
+     * Dereferences a sector when a model stops using it.
+     * If this was the last reference, the sector will be disposed.
+     */
+    dereferenceSector(modelIdentifier: ModelIdentifier, sectorId: number): void;
 }

package/dist/packages/utilities/index.d.ts

@@ -19,7 +19,6 @@ export { determinePowerOfTwoDimensions } from './src/determinePowerOfTwoDimensio
 export { IndexSet } from './src/IndexSet';
 export { DynamicDefragmentedBuffer } from './src/datastructures/DynamicDefragmentedBuffer';
 export { AttributeDataAccessor } from './src/three/AttributeDataAccessor';
-export { AutoDisposeGroup } from './src/three/AutoDisposeGroup';
 export { toThreeBox3 } from './src/three/toThreeBox3';
 export { fromThreeVector3 } from './src/three/fromThreeVector3';
 export { unionBoxes } from './src/three/unionBoxes';

package/dist/packages/utilities/src/SceneHandler.d.ts

@@ -11,7 +11,7 @@ export declare class SceneHandler {
     get scene(): THREE.Scene;
     get cadModels(): {
         cadNode: THREE.Object3D;
-        modelIdentifier: string;
+        modelIdentifier: symbol;
     }[];
     get pointCloudModels(): {
         pointCloudNode: THREE.Object3D;
@@ -19,7 +19,7 @@ export declare class SceneHandler {
     }[];
     get customObjects(): ICustomObject[];
     constructor();
-    addCadModel(cadNode: THREE.Object3D, modelIdentifier: string): void;
+    addCadModel(cadNode: THREE.Object3D, modelIdentifier: symbol): void;
     addPointCloudModel(pointCloudNode: THREE.Object3D, modelIdentifier: symbol): void;
     removePointCloudModel(pointCloudNode: THREE.Object3D): void;
     removeCadModel(cadNode: THREE.Object3D): void;

package/dist/packages/utilities/src/cache/MemoryRequestCache.d.ts

@@ -9,9 +9,10 @@ export declare class MemoryRequestCache<Key, Data> implements RequestCache<Key,
     private _maxElementsInCache;
     private readonly _data;
     private _defaultCleanupCount;
-    private readonly _removeCallback;
+    private readonly _disposeCallback?;
+    private readonly _referenceCounts;
     private static readonly CLEANUP_COUNT_TO_CAPACITY_RATIO;
-    constructor(maxElementsInCache?: number, removeCallback?: (value: Data) => void, defaultCleanupCount?: number);
+    constructor(maxElementsInCache: number, defaultCleanupCount: number, disposeCallback?: (data: Data) => void);
     has(id: Key): boolean;
     forceInsert(id: Key, data: Data): void;
     insert(id: Key, data: Data): void;
@@ -19,6 +20,25 @@ export declare class MemoryRequestCache<Key, Data> implements RequestCache<Key,
     get(id: Key): Data;
     isFull(): boolean;
     cleanCache(count: number): void;
+    /**
+     * Adds a reference to the cached item. Items with active references will not be disposed
+     * until all references are removed.
+     * @param id The cache key to add a reference to
+     */
+    addReference(id: Key): void;
+    /**
+     * Removes a reference to the cached item. Items remain in cache even when
+     * reference count reaches 0, allowing for potential reuse. Disposal only
+     * happens during cache cleanup when memory pressure exists.
+     * @param id The cache key to remove a reference from
+     */
+    removeReference(id: Key): void;
+    /**
+     * Gets the current reference count for a cached item.
+     * @param id The cache key to get reference count for
+     * @returns The number of active references, or 0 if not found
+     */
+    getReferenceCount(id: Key): number;
     resize(cacheSize: number): void;
     clear(): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cognite/reveal",
-  "version": "4.27.0-dev.20251001",
+  "version": "4.27.1",
   "description": "WebGL based 3D viewer for CAD and point clouds processed in Cognite Data Fusion.",
   "homepage": "https://github.com/cognitedata/reveal/tree/master/viewer",
   "repository": {

package/dist/packages/utilities/src/three/AutoDisposeGroup.d.ts

@@ -1,18 +0,0 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-/**
- * Referenced count implementation of THREE.Group that
- * automatically disposes all geometries contained in meshes that
- * are direct children of the group.
- */
-export declare class AutoDisposeGroup extends THREE.Group {
-    private _isDisposed;
-    private _referenceCount;
-    isDisposed(): boolean;
-    reference(): void;
-    dereference(): void;
-    private dispose;
-    private ensureNotDisposed;
-}