@cognite/reveal 4.28.6 → 4.28.7-dev.20260108

package/dist/packages/3d-overlays/src/IconOctree.d.ts

@@ -2,15 +2,66 @@
  * Copyright 2023 Cognite AS
  */
 import { Node, PointOctant, PointOctree } from 'sparse-octree';
-import { Box3, Matrix4 } from 'three';
+import { Box3, Matrix4, Vector3 } from 'three';
 import { Overlay3DIcon } from './Overlay3DIcon';
 import { DefaultOverlay3DContentType } from './OverlayCollection';
 export declare class IconOctree<ContentType = DefaultOverlay3DContentType> extends PointOctree<Overlay3DIcon<ContentType>> {
     private readonly _nodeCenters;
+    private readonly _distanceBoxChecker;
     static getMinimalOctreeBoundsFromIcons<ContentType>(icons: Overlay3DIcon<ContentType>[]): Box3;
     constructor(icons: Overlay3DIcon<ContentType>[], bounds: Box3, maxLeafSize: number);
     getNodeIcon(node: Node): Overlay3DIcon | undefined;
+    /**
+     * Get all icons from a node's subtree recursively
+     * @param node - The octree node to get icons from
+     * @returns Array of Overlay3DIcons contained in the node's subtree
+     */
+    getAllIconsFromNode(node: Node): Overlay3DIcon<ContentType>[];
+    /**
+     * Check if a node or any of its descendants exists in the given set
+     * @param node - The octree node to check
+     * @param nodeSet - Set of nodes to check against
+     * @returns True if the node or any descendant is in the set, false otherwise
+     */
+    hasDescendantInSet(node: Node, nodeSet: Set<Node>): boolean;
+    /**
+     * Get LOD nodes based on projected screen area.
+     * Nodes with projected area above the threshold are expanded,
+     * while those below are selected as LOD representatives.
+     * @param areaThreshold - Screen area threshold (0 to 1) for LOD selection
+     * @param projection - View projection matrix
+     * @param minimumLevel - Minimum octree level to expand to (default: 0)
+     * @returns Set of PointOctant nodes selected for LOD based on screen area
+     */
     getLODByScreenArea(areaThreshold: number, projection: Matrix4, minimumLevel?: number): Set<PointOctant<Overlay3DIcon>>;
+    /**
+     * Get LOD nodes based purely on camera distance.
+     * This provides consistent behavior regardless of view angle.
+     *
+     * @param cameraPosition - Camera position in model space
+     * @param distanceThreshold - Distance from camera within which all icons are shown (no clustering)
+     * @param clusteringLevel - The octree level at which to cluster far icons (higher = finer clusters)
+     * @returns Set of PointOctant nodes selected for LOD based on distance
+     */
+    getLODByDistance(cameraPosition: Vector3 | undefined, distanceThreshold: number, clusteringLevel?: number): Set<PointOctant<Overlay3DIcon>>;
+    /**
+     * Get all icons from a node's subtree that are within the given distance from a point.
+     * Also returns the representative icon if no close icons are found (for clustering).
+     *
+     * @param node - The octree node to get icons from
+     * @param cameraPosition - Camera position for distance calculation
+     * @param distanceThreshold - Distance threshold for "close" icons
+     * @returns Object containing close icons and whether to show representative
+     */
+    getIconsFromClusteredNode(node: Node, cameraPosition: Vector3, distanceThreshold: number): Overlay3DIcon<ContentType | DefaultOverlay3DContentType>[];
+    /**
+     * Check if any icon in the node's subtree is within the given distance from a point
+     * @param node - The octree node to check
+     * @param point - The point to measure distance from
+     * @param distance - Distance threshold
+     * @returns True if any icon is within distance, false otherwise
+     */
+    private isNodeWithinDistance;
     private populateNodeCenters;
     private filterEmptyLeaves;
     private hasChildren;

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

@@ -20,7 +20,6 @@ export declare class CadManager {
     private _needsRedraw;
     private readonly _loadingStateChangedTrigger;
     private readonly _markNeedsRedrawBound;
-    private readonly _materialsChangedListener;
     private readonly _sectorBufferTime;
     get materialManager(): CadMaterialManager;
     get budget(): CadModelBudget;
@@ -57,6 +56,5 @@ export declare class CadManager {
      */
     private setCacheSizeForModel;
     private markNeedsRedraw;
-    private handleMaterialsChanged;
     private updateTreeIndexToSectorsMap;
 }

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

@@ -5,7 +5,7 @@ import { NodeAppearanceProvider, NodeAppearance, PrioritizedArea, type NodeTrans
 import { SectorScene, CadModelMetadata, RootSectorNode, WantedSector, ConsumedSector } from '../../../cad-parsers';
 import { SectorRepository } from '../../../sector-loader';
 import { ParsedGeometry } from '../../../sector-parser';
-import { CadMaterialManager, RenderMode } from '../../../rendering';
+import { CadMaterialManager, type CadMaterial } from '../../../rendering';
 import { Group, Object3D, Plane, Matrix4, Object3DEventMap } from 'three';
 import { TreeIndexToSectorsMap } from '../utilities/TreeIndexToSectorsMap';
 import { ParsedMeshGeometry } from '../../../cad-parsers';
@@ -21,9 +21,9 @@ export declare class CadNode extends Object3D<Object3DEventMap & {
     private _geometryBatchingManager?;
     private readonly _sourceTransform;
     private readonly _customTransform;
-    private readonly _setModelRenderLayers;
     private readonly _batchedGeometryMeshGroup;
     private readonly _styledTreeIndexSets;
+    private readonly _cadMaterial;
     private _isDisposed;
     private _needsRedraw;
     private readonly _meshManager;
@@ -32,6 +32,7 @@ export declare class CadNode extends Object3D<Object3DEventMap & {
     constructor(model: CadModelMetadata, materialManager: CadMaterialManager, sectorRepository: SectorRepository);
     get needsRedraw(): boolean;
     resetRedraw(): void;
+    get cadMaterial(): CadMaterial;
     get nodeTransformProvider(): NodeTransformProvider;
     get nodeAppearanceProvider(): NodeAppearanceProvider;
     get defaultNodeAppearance(): NodeAppearance;
@@ -42,9 +43,6 @@ export declare class CadNode extends Object3D<Object3DEventMap & {
     get cadModelIdentifier(): symbol;
     get sectorScene(): SectorScene;
     get rootSector(): RootSectorNode;
-    get materialManager(): CadMaterialManager;
-    set renderMode(mode: RenderMode);
-    get renderMode(): RenderMode;
     get isDisposed(): boolean;
     loadSector(sector: WantedSector, abortSignal?: AbortSignal): Promise<ConsumedSector>;
     /**

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

@@ -1,7 +1,7 @@
 /**
  * Copyright 2021 Cognite AS
  */
-export { CadMaterialManager } from './src/CadMaterialManager';
+export { CadMaterialManager, createCadMaterial, CadMaterial } from './src/CadMaterialManager';
 export { PointCloudMaterialManager } from './src/PointCloudMaterialManager';
 export { RenderOptions, defaultRenderOptions, SsaoParameters, SsaoSampleQuality, AntiAliasingMode, EdlOptions } from './src/rendering/types';
 export * from './src/pointcloud-rendering/constants';

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

@@ -4,18 +4,25 @@
 import * as THREE from 'three';
 import { Materials } from './rendering/materials';
 import { RenderMode } from './rendering/RenderMode';
-import { NodeAppearance, NodeAppearanceProvider, NodeTransformProvider } from '../../cad-styling';
+import { NodeAppearance, NodeAppearanceProvider, NodeAppearanceTextureBuilder, NodeTransformProvider, NodeTransformTextureBuilder } from '../../cad-styling';
 import { IndexSet } from '../../utilities';
+export type CadMaterial = {
+    materials: Materials;
+    nodeAppearanceProvider: NodeAppearanceProvider;
+    nodeTransformProvider: NodeTransformProvider;
+    nodeAppearanceTextureBuilder: NodeAppearanceTextureBuilder;
+    nodeTransformTextureBuilder: NodeTransformTextureBuilder;
+    matCapTexture: THREE.Texture;
+};
 export declare class CadMaterialManager {
-    private readonly _events;
     get clippingPlanes(): THREE.Plane[];
     set clippingPlanes(clippingPlanes: THREE.Plane[]);
+    get needsRedraw(): boolean;
     private _renderMode;
     private readonly materialsMap;
     private _clippingPlanes;
-    on(event: 'materialsChanged', listener: () => void): void;
-    off(event: 'materialsChanged', listener: () => void): void;
-    addModelMaterials(modelIdentifier: symbol, maxTreeIndex: number): void;
+    private _needsRedraw;
+    addModelMaterials(modelIdentifier: symbol, cadMaterial: CadMaterial): void;
     removeModelMaterials(modelIdentifier: symbol): void;
     addTexturedMeshMaterial(modelIdentifier: symbol, sectorId: number, texture: THREE.Texture): THREE.RawShaderMaterial;
     getModelMaterials(modelIdentifier: symbol): Materials;
@@ -31,12 +38,13 @@ export declare class CadMaterialManager {
     getModelVisibleTreeIndices(modelIdentifier: symbol): IndexSet;
     setRenderMode(mode: RenderMode): void;
     getRenderMode(): RenderMode;
+    resetRedraw(): void;
     dispose(): void;
     private updateClippingPlanesForModel;
     private updateMaterials;
     private updateTransforms;
     private getModelMaterialsWrapper;
     private applyToAllMaterials;
-    private triggerMaterialsChanged;
     private initializeDefinesAndUniforms;
 }
+export declare function createCadMaterial(maxTreeIndex: number): CadMaterial;

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

@@ -22,5 +22,5 @@ export interface Materials {
     };
 }
 export declare function forEachMaterial(materials: Materials, callback: (material: THREE.RawShaderMaterial) => void): void;
-export declare function createMaterials(renderMode: RenderMode, clippingPlanes: THREE.Plane[], overrideColorPerTreeIndex: THREE.DataTexture, transformOverrideIndexTexture: THREE.DataTexture, transformOverrideLookupTexture: THREE.DataTexture, matCapTexture: THREE.Texture): Materials;
+export declare function createMaterials(overrideColorPerTreeIndex: THREE.DataTexture, transformOverrideIndexTexture: THREE.DataTexture, transformOverrideLookupTexture: THREE.DataTexture, matCapTexture: THREE.Texture): Materials;
 export declare function initializeDefinesAndUniforms(material: THREE.RawShaderMaterial, overrideColorPerTreeIndex: THREE.DataTexture, transformOverrideIndexTexture: THREE.DataTexture, transformOverrideTexture: THREE.DataTexture, matCapTexture: THREE.Texture, renderMode: RenderMode): void;

package/dist/packages/utilities/src/fdm/typeGuards.d.ts

@@ -2,4 +2,4 @@
  * Copyright 2025 Cognite AS
  */
 import { DMInstanceRef } from './types';
-export declare function isDmIdentifier(id: any): id is DMInstanceRef;
+export declare function isDmIdentifier(id: unknown): id is DMInstanceRef;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cognite/reveal",
-  "version": "4.28.6",
+  "version": "4.28.7-dev.20260108",
   "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": {