@cognite/reveal 4.37.0 → 4.39.0

package/dist/packages/api/src/public/RevealManager.d.ts

@@ -6,6 +6,7 @@ import { LoadingState } from '../../../model-base';
 import { CadManager, CadModelBudget } from '../../../cad-geometry-loaders';
 import { NodeAppearanceProvider } from '../../../cad-styling';
 import { RenderMode, RenderPipelineExecutor, CadMaterialManager, RenderPipelineProvider, ResizeHandler, SettableRenderTarget } from '../../../rendering';
+import { PickCacheInvalidator } from '../../../utilities';
 import { CameraManager } from '../../../camera-manager';
 import { DataSourceType, File3dFormat, InternalDataSourceType } from '../../../data-providers';
 import { AddModelOptionsWithModelRevisionId } from '../../../data-providers/src/utilities/internalAddModelOptions';
@@ -25,19 +26,25 @@ export declare class RevealManager {
     private readonly _renderPipeline;
     private readonly _resizeHandler;
     private _cameraInMotion;
+    private _lastCameraSnapshot;
+    private readonly _pickCacheInvalidator;
     private _isDisposed;
     private readonly _subscriptions;
     private readonly _events;
     private readonly _cameraManager;
     private readonly _onCameraChange;
     private readonly _onCameraStop;
-    constructor(cadManager: CadManager, pointCloudManager: PointCloudManager, pipelineExecutor: RenderPipelineExecutor, renderPipeline: RenderPipelineProvider & SettableRenderTarget, resizeHandler: ResizeHandler, cameraManager: CameraManager);
+    constructor(cadManager: CadManager, pointCloudManager: PointCloudManager, pipelineExecutor: RenderPipelineExecutor, renderPipeline: RenderPipelineProvider & SettableRenderTarget, resizeHandler: ResizeHandler, cameraManager: CameraManager, pickCacheInvalidator: PickCacheInvalidator);
     dispose(): void;
     requestRedraw(): void;
     resetRedraw(): void;
     setOutputRenderTarget(target: WebGLRenderTarget | null, autoSizeRenderTarget?: boolean): void;
     get materialManager(): CadMaterialManager;
     get needsRedraw(): boolean;
+    /**
+     * Flag that is set whenever something that can change what a pick hits changes. See {@link PickCacheInvalidator}.
+     */
+    get pickCacheInvalidator(): PickCacheInvalidator;
     get cameraInMotion(): boolean;
     update(camera: PerspectiveCamera): void;
     get cadBudget(): CadModelBudget;
@@ -45,6 +52,8 @@ export declare class RevealManager {
     get cadLoadedStatistics(): CadModelSectorLoadStatistics;
     get cadRenderMode(): RenderMode;
     set cadRenderMode(renderMode: RenderMode);
+    get shadowsEnabled(): boolean;
+    set shadowsEnabled(enabled: boolean);
     get pointCloudBudget(): PointCloudBudget;
     set pointCloudBudget(budget: PointCloudBudget);
     set clippingPlanes(clippingPlanes: Plane[]);
@@ -61,4 +70,5 @@ export declare class RevealManager {
     removeModel(type: 'cad', model: CadNode): void;
     removeModel(type: 'pointcloud', model: PointCloudNode): void;
     private initLoadingStateObserver;
+    private requestPickCacheInvalidationIfCameraChanged;
 }

package/dist/packages/api/src/public/RevealOptions.d.ts

@@ -11,6 +11,7 @@ export type RevealOptions = {
     logMetrics?: boolean;
     renderOptions?: RenderOptions;
     continuousModelStreaming?: boolean;
+    enableShadows?: boolean;
     outputRenderTarget?: {
         target: WebGLRenderTarget;
         autoSize?: boolean;

package/dist/packages/api/src/public/migration/Cognite3DViewer.d.ts

@@ -24,6 +24,8 @@ export declare class Cognite3DViewer<DataSourceT extends DataSourceType = Classi
     private readonly _domElementResizeObserver;
     private readonly _image360ApiHelper;
     private readonly _unsubsribeOnLoading;
+    private _onContextLost;
+    private _onContextRestored;
     /**
      * Returns the rendering canvas, the DOM element where the renderer draws its output.
      */
@@ -83,6 +85,19 @@ export declare class Cognite3DViewer<DataSourceT extends DataSourceType = Classi
      * budget is shared between all added CAD models and not a per-model budget.
      */
     set cadBudget(budget: CadModelBudget);
+    /**
+     * Gets whether CAD shadows are currently enabled.
+     * @beta
+     */
+    get shadowsEnabled(): boolean;
+    /**
+     * Enables or disables CAD shadows at runtime, along with the world-space sun shading
+     * that matches them. Turning shadows on changes the CAD look even where no shadow is
+     * cast, including ghosted nodes. The GPU resources are allocated the first time shadows
+     * are enabled.
+     * @beta
+     */
+    set shadowsEnabled(enabled: boolean);
     /**
      * Returns the point cloud budget. The budget is shared between all loaded
      * point cloud models.
@@ -98,6 +113,12 @@ export declare class Cognite3DViewer<DataSourceT extends DataSourceType = Classi
      */
     get models(): CogniteModel<DataSourceT>[];
     constructor(options: Cognite3DViewerOptions);
+    /**
+     * Listens for render context loss/restore. On loss, prevents the default (so the
+     * browser attempts recovery) and sets `isRenderContextLost()`; on restore, clears
+     * the flag and requests a redraw.
+     */
+    private registerContextLossHandlers;
     /**
      * Get resolution options that are set on the viewer. This includes
      * settings for max resolution and limiting resolution when moving the camera.
@@ -388,6 +409,8 @@ export declare class Cognite3DViewer<DataSourceT extends DataSourceType = Classi
     addObject3D(object: Object3D): void;
     /**
      * Add a CustomObject to the viewer.
+     * Meshes in the custom object can use {@link CustomObjectEffectMaterial}, which supports
+     * effects specific to custom objects.
      * @param customObject
      * @example
      * ```js
@@ -398,6 +421,13 @@ export declare class Cognite3DViewer<DataSourceT extends DataSourceType = Classi
      * const customObject = CustomObject(sphere);
      * customObject.isPartOfBoundingBox = false;
      * viewer.addCustomObject(customObject);
+     *
+     * // Ground plane that receives CAD shadows and texture variation
+     * const groundMaterial = new CustomObjectEffectMaterial('#ffffff', texture);
+     * groundMaterial.setReceivesShadow(true);
+     * groundMaterial.setTextureVariation('hexTiling');
+     * const plane = new Mesh(new PlaneGeometry(100, 100), groundMaterial);
+     * viewer.addCustomObject(CustomObject(plane));
      * ```
      * @beta
      */
@@ -677,7 +707,7 @@ export declare class Cognite3DViewer<DataSourceT extends DataSourceType = Classi
      * @param options
      * @param options.stopOnHitting360Icon
      * @param options.predicate Check whether a CustomObject should be intersected.
-     * @param options.forceWindowedPick Skip point-cloud full-frame pick caching for this call.
+     * @param options.forceWindowedPick Skip point cloud and CAD full-frame pick caching for this call.
      * @returns A promise that if there was an intersection then return the intersection object - otherwise it
      * returns `null` if there were no intersections.
      * @beta

package/dist/packages/api/src/public/migration/renderOptionsHelpers.d.ts

@@ -1,4 +1,4 @@
-import { SsaoParameters, AntiAliasingMode } from '../../../../rendering';
+import { EdlOptions, SsaoParameters, AntiAliasingMode } from '../../../../rendering';
 import { DeviceDescriptor } from '../../../../utilities';
 import { PropType } from '../../utilities/reflection';
 import { Cognite3DViewerOptions } from './types';
@@ -30,4 +30,9 @@ export declare function determineSsaoRenderParameters(qualityHint: SsaoQualityHi
  * @param devicePixelRatio Device pixel ratio set on the renderer.
  */
 export declare function determineResolutionCap(rendererResolutionThreshold: number | undefined, device: DeviceDescriptor, devicePixelRatio: number): number;
+/**
+ * Create EDL options from input options. The radius is clamped to the maximum supported radius.
+ * @param inputOptions
+ */
+export declare function createCompleteEdlOptions(inputOptions?: Partial<EdlOptions> | 'disabled'): EdlOptions;
 export {};

package/dist/packages/api/src/public/migration/types.d.ts

@@ -147,6 +147,17 @@ export interface Cognite3DViewerOptions {
      * Enables / disables visualizing the edges of geometry. Defaults to true.
      */
     enableEdges?: boolean;
+    /**
+     * Enables shadows cast by CAD geometry, and the world-space sun shading that goes with
+     * them. Turning shadows on changes the CAD look even where no shadow is cast, including
+     * ghosted nodes. Defaults to false. Can also be toggled at runtime through
+     * {@link Cognite3DViewer.shadowsEnabled}.
+     * Custom objects receive shadows when they use {@link CustomObjectEffectMaterial} and request
+     * it with {@link CustomObjectEffectMaterial.setReceivesShadow}. GPU resources are only allocated
+     * when first enabled.
+     * @beta
+     */
+    enableShadows?: boolean;
     /** Callback to download stream progress. */
     onLoading?: OnLoadingCallback;
     /**

package/dist/packages/api/src/public/types.d.ts

@@ -7,7 +7,7 @@ import { CognitePointCloudModel } from '../../../pointclouds';
  */
 export type CogniteModel<T extends DataSourceType = ClassicDataSourceType> = CogniteCadModel | CognitePointCloudModel<T>;
 export { WellKnownAsprsPointClassCodes } from '../../../pointclouds';
-export { PointShape, PointColorType, PointSizeType } from '../../../rendering';
+export { PointShape, PointColorType, PointSizeType, CustomObjectEffectMaterial, CadShadowReceiverForCustomObjectMaterial, type TextureVariationType } from '../../../rendering';
 /**
  * A tuple of a 360 image and its collection.
  */

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

@@ -6,6 +6,7 @@ import { CadMaterialManager, RenderMode } from '../../rendering';
 import { ModelIdentifier, File3dFormat } from '../../data-providers';
 import { CadModelBudget } from './CadModelBudget';
 import { CadModelFactory, CadModelSectorLoadStatistics, CadNode, GeometryFilter } from '../../cad-model';
+import { PickCacheInvalidator } from '../../utilities';
 export declare class CadManager {
     private readonly _materialManager;
     private readonly _cadModelFactory;
@@ -15,6 +16,7 @@ export declare class CadManager {
     private readonly _unsubscribeLoadingState;
     private _compatibleFileFormat;
     private _needsRedraw;
+    private readonly _pickCacheInvalidator;
     private readonly _loadingStateChangedTrigger;
     private readonly _markNeedsRedrawBound;
     private readonly _sectorBufferTime;
@@ -26,7 +28,7 @@ export declare class CadManager {
      * Returns statistics about how data loaded (or data about to be loaded).
      */
     get loadedStatistics(): CadModelSectorLoadStatistics;
-    constructor(materialManger: CadMaterialManager, cadModelFactory: CadModelFactory, cadModelUpdateHandler: CadModelUpdateHandler);
+    constructor(materialManger: CadMaterialManager, cadModelFactory: CadModelFactory, cadModelUpdateHandler: CadModelUpdateHandler, pickCacheInvalidator: PickCacheInvalidator);
     dispose(): void;
     requestRedraw(): void;
     resetRedraw(): void;

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

@@ -2,6 +2,7 @@ import { CadManager } from './CadManager';
 import { InternalRevealCadOptions } from './InternalRevealCadOptions';
 import { CadMaterialManager } from '../../rendering';
 import { ModelDataProvider, ModelMetadataProvider } from '../../data-providers';
+import { PickCacheInvalidator } from '../../utilities';
 export declare function createCadManager(modelMetadataProvider: ModelMetadataProvider, modelDataProvider: ModelDataProvider, materialManager: CadMaterialManager, cadOptions: InternalRevealCadOptions & {
     continuousModelStreaming?: boolean;
-}): CadManager;
+}, pickCacheInvalidator: PickCacheInvalidator): CadManager;

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

@@ -12,12 +12,18 @@ export declare class SectorDownloadScheduler {
     get numberOfQueuedDownloads(): number;
     constructor(maxConcurrentSectorDownloads?: number);
     queueSectorBatchForDownload(downloadData: SectorDownloadData[]): Promise<ConsumedSector>[];
+    /**
+     * Drops all downloads that are queued but not yet started, resolving them as discarded.
+     * Downloads that are already in progress are left untouched.
+     */
+    clearQueuedDownloads(): void;
     private createDiscardedConsumedSector;
     private abortPendingDownload;
     private removeDownloadFromQueue;
     private getOrAddToQueuedDownloads;
     private addSectorToPendingDownloads;
     private processNextQueuedSectorDownload;
+    private downloadOrDiscard;
     private getSectorIdentifier;
     private createAbortSignal;
 }

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

@@ -24,6 +24,15 @@ export declare class SectorLoader {
     reportNewSectorsLoaded(loadedCountChange: number): void;
     private shouldLoad;
     private getSectorCuller;
-    private filterSectors;
+    /**
+     * Culls the batch against already loaded geometry and queues the remaining sectors for download.
+     * Resolves to no downloads if the load is superseded.
+     */
+    private startBatch;
+    /**
+     * Yields the sectors of a batch as they finish downloading, and reports progress.
+     * Stops as soon as the load is superseded.
+     */
+    private consumeBatch;
     private startLoadingBatch;
 }

package/dist/packages/cad-geometry-loaders/src/sector/culling/takensectors/TakenV9SectorMap.d.ts

@@ -5,6 +5,8 @@ import { CadModelMetadata, SectorMetadata } from '../../../../../cad-parsers';
 export declare class TakenV9SectorMap extends TakenSectorMapBase {
     private readonly determineSectorCost;
     private readonly _totalCost;
+    /** Cost of sectors force-included via {@link markSectorForced}; these bypass the budget. */
+    private readonly _forcedCost;
     private readonly _models;
     get totalCost(): SectorCost;
     get modelsMetadata(): CadModelMetadata[];
@@ -13,9 +15,14 @@ export declare class TakenV9SectorMap extends TakenSectorMapBase {
     markSectorDetailed(model: CadModelMetadata, sectorId: number, priority: number): void;
     /**
      * Marks a sector as forced-detailed with infinite priority.
-     * These sectors are always loaded regardless of budget constraints.
+     * These sectors are always loaded regardless of budget constraints, and their cost
+     * does not count against the budget (see {@link isWithinBudget}).
      */
     markSectorForced(model: CadModelMetadata, sectorId: number): void;
+    /**
+     * Cost of non-forced sectors is compared against the budget. Forced sectors (e.g. fully locked
+     * models) are excluded so they cannot starve other models of budget.
+     */
     isWithinBudget(budget: CadModelBudget): boolean;
     collectWantedSectors(): PrioritizedWantedSector[];
     clear(): void;

package/dist/packages/cad-model/src/CadModelFactory.d.ts

@@ -1,3 +1,4 @@
+import { PickCacheInvalidator } from '../../utilities';
 import { GeometryFilter } from './types';
 import { CadMaterialManager } from '../../rendering';
 import { CadModelMetadata } from '../../cad-parsers';
@@ -5,10 +6,11 @@ import { ModelDataProvider, ModelMetadataProvider, ModelIdentifier, File3dFormat
 import { CadNode } from './wrappers/CadNode';
 export declare class CadModelFactory {
     private readonly _materialManager;
+    private readonly _pickCacheInvalidator;
     private readonly _modelDataProvider;
     private readonly _cadModelMetadataRepository;
     private _gltfSectorRepository;
-    constructor(materialManager: CadMaterialManager, modelMetadataProvider: ModelMetadataProvider, modelDataProvider: ModelDataProvider);
+    constructor(materialManager: CadMaterialManager, modelMetadataProvider: ModelMetadataProvider, modelDataProvider: ModelDataProvider, pickCacheInvalidator: PickCacheInvalidator);
     loadModelMetadata(externalModelIdentifier: ModelIdentifier, outputFormat?: File3dFormat): Promise<CadModelMetadata>;
     createModel(metadata: CadModelMetadata, geometryFilter?: GeometryFilter): CadNode;
     private getSectorRepository;

package/dist/packages/cad-model/src/picking/CadPickBuffer.d.ts

@@ -0,0 +1,22 @@
+/*!
+ * Copyright 2026 Cognite AS
+ */
+export type CadPickBufferHit = {
+    modelIndex: number;
+    treeIndex: number;
+    depth: number;
+};
+export declare class CadPickBuffer {
+    readonly width: number;
+    readonly height: number;
+    readonly treeIndexPixels: Uint8Array;
+    readonly depthPixels: Uint8Array;
+    constructor(width: number, height: number);
+    static decodeModelIndex(pixels: Uint8Array, offset: number): number | undefined;
+    static decodeTreeIndex(pixels: Uint8Array, offset: number): number;
+    static unpackDepth(pixels: Uint8Array, offset: number): number;
+    getHit(normalizedCoords: {
+        x: number;
+        y: number;
+    }): CadPickBufferHit | undefined;
+}

package/dist/packages/cad-model/src/picking/CadPickCache.d.ts

@@ -0,0 +1,43 @@
+import { WebGLRenderer } from 'three';
+import { IntersectInput } from '../../../model-base';
+import { CadMaterialManager } from '../../../rendering';
+import { SceneHandler } from '../../../utilities';
+import { CadNode } from '../wrappers/CadNode';
+import { IntersectCadNodesResult } from './types';
+/**
+ * Full-frame pick cache. Renders the tree index and depth of all visible models in one pass each
+ * and serves picks from the CPU copy until the scene is rendered again.
+ */
+export declare class CadPickCache {
+    private static readonly REBUILD_HOLDOFF_MS;
+    private static readonly MAX_CACHED_MODELS;
+    private readonly _clearColor;
+    private readonly _clearAlpha;
+    private readonly _renderTarget;
+    private readonly _pipelineExecutor;
+    private readonly _depthRenderPipeline;
+    private readonly _treeIndexRenderPipeline;
+    private _cache;
+    private _invalidationCount;
+    private _lastInvalidatedAt;
+    private _isDisposed;
+    constructor(renderer: WebGLRenderer, materialManager: CadMaterialManager, sceneHandler: SceneHandler);
+    /**
+     * Marks the cache stale. Must be called whenever the camera or scene content that affects picking changes, as the
+     * cache does not compare the camera itself.
+     */
+    invalidate(): void;
+    dispose(): void;
+    /**
+     * Picks from the cache, rebuilding it first when it is stale and the frame is likely to stay
+     * unchanged. Returns undefined when the per-model path should be used instead.
+     */
+    intersect(visibleCadNodes: CadNode[], input: IntersectInput, shouldRunAsync: boolean): Promise<IntersectCadNodesResult | undefined>;
+    private isUsable;
+    /**
+     * Renders the tree index and depth of all visible models into full-frame buffers, one pass each,
+     * so every pixel holds the hit closest to the camera. Returns false if the result is stale.
+     */
+    private build;
+    private renderAndReadFullFrame;
+}

package/dist/packages/cad-model/src/picking/PickingHandler.d.ts

@@ -1,40 +1,32 @@
-import { Object3D, WebGLRenderer, Vector3 } from 'three';
+import { WebGLRenderer } from 'three';
 import { IntersectInput } from '../../../model-base';
 import { CadMaterialManager } from '../../../rendering';
 import { SceneHandler } from '../../../utilities';
 import { CadNode } from '../wrappers/CadNode';
-type IntersectCadNodesResult = {
-    distance: number;
-    point: Vector3;
-    treeIndex: number;
-    cadNode: CadNode;
-    object: Object3D;
-};
+import { CadPickCache } from './CadPickCache';
+import { IntersectCadNodesResult } from './types';
 export declare class PickingHandler {
     private readonly _clearColor;
     private readonly _clearAlpha;
     private readonly _raycaster;
     private readonly _pickPixelColorStorage;
-    private readonly _rgbaVector;
-    /**
-     * These factors are used for undoing the `packDepthToRGBA` GLSL operation defined by ThreeJS.
-     * They are taken from https://github.com/WestLangley/three.js/blob/bc58fecba18150103b95fbde5aaa3cc7cddf95a7/src/renderers/shaders/ShaderChunk/packing.glsl.js#L19
-     */
-    private readonly _unpackFactors;
     private readonly _pipelineExecutor;
     private readonly _depthRenderPipeline;
     private readonly _treeIndexRenderPipeline;
     private readonly _mutex;
-    constructor(renderer: WebGLRenderer, materialManager: CadMaterialManager, sceneHandler: SceneHandler);
+    private readonly _pickCache;
+    constructor(renderer: WebGLRenderer, materialManager: CadMaterialManager, sceneHandler: SceneHandler, pickCache?: CadPickCache);
+    /**
+     * Invalidates the cached full-frame pick buffer. Must be called whenever a new frame of the
+     * scene content that affects picking changes (sector loading, styling, clipping or model transforms).
+     */
+    invalidatePickCache(): void;
+    dispose(): void;
     intersectCadNodes(cadNodes: CadNode[], input: IntersectInput, shouldRunAsync?: boolean): Promise<IntersectCadNodesResult[]>;
     private filterOutOfBoundCadNodes;
     private intersectCadNodeDepth;
     private intersectCadNodeTreeIndex;
     private pickTreeIndex;
-    private perspectiveDepthToViewZ;
     private pickDepth;
-    private getPosition;
     private pickPixel;
-    private unpackRGBAToDepth;
 }
-export {};

package/dist/packages/cad-model/src/picking/depthToIntersection.d.ts

@@ -0,0 +1,12 @@
+import { PerspectiveCamera, Vector3 } from 'three';
+/**
+ * Converts a non-linear depth in [0, 1] at the given normalized device coordinates
+ * to a world space position and its distance from the camera.
+ */
+export declare function depthToIntersection(depth: number, camera: PerspectiveCamera, normalizedCoords: {
+    x: number;
+    y: number;
+}): {
+    distance: number;
+    point: Vector3;
+};

package/dist/packages/cad-model/src/picking/types.d.ts

@@ -0,0 +1,9 @@
+import { Object3D, Vector3 } from 'three';
+import { CadNode } from '../wrappers/CadNode';
+export type IntersectCadNodesResult = {
+    distance: number;
+    point: Vector3;
+    treeIndex: number;
+    cadNode: CadNode;
+    object: Object3D;
+};

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

@@ -3,6 +3,7 @@ import { SectorScene, CadModelMetadata, WantedSector, ConsumedSector, RootSector
 import { SectorRepository } from '../../../sector-loader';
 import { ParsedGeometry } from '../../../sector-parser';
 import { CadMaterial } from '../../../rendering';
+import { PickCacheInvalidator } from '../../../utilities';
 import { Plane, Object3DEventMap, Group, Object3D, Matrix4 } from 'three';
 import { TreeIndexToSectorsMap } from '../utilities/TreeIndexToSectorsMap';
 export declare class CadNode extends Object3D<Object3DEventMap & {
@@ -21,12 +22,13 @@ export declare class CadNode extends Object3D<Object3DEventMap & {
     private readonly _cadMaterial;
     private _isDisposed;
     private _needsRedraw;
+    private readonly _pickCacheInvalidator;
     private readonly _meshManager;
     readonly treeIndexToSectorsMap: TreeIndexToSectorsMap;
     private readonly _lockedTreeIndices;
     private readonly _lockedSectorIds;
     readonly type = "CadNode";
-    constructor(model: CadModelMetadata, sectorRepository: SectorRepository);
+    constructor(model: CadModelMetadata, sectorRepository: SectorRepository, pickCacheInvalidator: PickCacheInvalidator);
     get needsRedraw(): boolean;
     resetRedraw(): void;
     get cadMaterial(): CadMaterial;

package/dist/packages/cad-styling/src/NodeAppearanceTextureBuilder.d.ts

@@ -1,10 +1,11 @@
 import { DataTexture } from 'three';
-import { IndexSet } from '../../utilities';
+import { PickCacheInvalidator, IndexSet } from '../../utilities';
 import { NodeAppearance } from './NodeAppearance';
 import { NodeAppearanceProvider } from './NodeAppearanceProvider';
 export declare class NodeAppearanceTextureBuilder {
     private _defaultAppearance;
     private readonly _styleProvider;
+    private readonly _pickCacheInvalidator;
     private readonly _handleStylesChangedListener;
     private _needsUpdate;
     private readonly _allTreeIndices;
@@ -14,7 +15,7 @@ export declare class NodeAppearanceTextureBuilder {
     private readonly _ghostedNodesTreeIndices;
     private readonly _infrontNodesTreeIndices;
     private readonly _visibleNodesTreeIndices;
-    constructor(treeIndexCount: number, styleProvider: NodeAppearanceProvider);
+    constructor(treeIndexCount: number, styleProvider: NodeAppearanceProvider, pickCacheInvalidator: PickCacheInvalidator);
     getDefaultAppearance(): NodeAppearance;
     /**
      * Sets the default style and invalidates the builder. Note that this causes a full
@@ -44,6 +45,8 @@ export declare class NodeAppearanceTextureBuilder {
     get overrideColorPerTreeIndexTexture(): DataTexture;
     dispose(): void;
     build(): void;
+    /** The sets that decide whether a node can be picked: hidden nodes are not visible, ghosted nodes are not drawn. */
+    private snapshotPickableSets;
     private populateTexture;
     private populateNodeSets;
     private applyStyleToNodes;

package/dist/packages/data-providers/src/utilities/gzipUtils.d.ts

@@ -1,2 +1,5 @@
+/*!
+ * Copyright 2026 Cognite AS
+ */
 export declare function parseJsonResponseBody(response: Response): Promise<unknown>;
 export declare function decompressBinaryResponseBody(response: Response): Promise<ArrayBuffer>;

package/dist/packages/pointclouds/src/PointCloudFactory.d.ts

@@ -4,6 +4,7 @@ import { Potree } from './potree-three-loader';
 import { DMDataSourceType, DataSourceType, PointCloudStylableObjectProvider } from '../../data-providers';
 import { IPointClassificationsProvider } from './classificationsProviders/IPointClassificationsProvider';
 import { PointCloudMaterialManager } from '../../rendering';
+import { PickCacheInvalidator } from '../../utilities';
 import { ModelIdentifier } from '../../data-providers/src/ModelIdentifier';
 export declare class PointCloudFactory {
     private readonly _potreeInstance;
@@ -11,7 +12,8 @@ export declare class PointCloudFactory {
     private readonly _pointCloudDMProvider;
     private readonly _classificationsProvider;
     private readonly _pointCloudMaterialManager;
-    constructor(potreeInstance: Potree, pointCloudObjectProvider: PointCloudStylableObjectProvider, pointCloudDMProvider: PointCloudStylableObjectProvider<DMDataSourceType>, classificationsProvider: IPointClassificationsProvider, pointCloudMaterialManager: PointCloudMaterialManager);
+    private readonly _pickCacheInvalidator;
+    constructor(potreeInstance: Potree, pointCloudObjectProvider: PointCloudStylableObjectProvider, pointCloudDMProvider: PointCloudStylableObjectProvider<DMDataSourceType>, classificationsProvider: IPointClassificationsProvider, pointCloudMaterialManager: PointCloudMaterialManager, pickCacheInvalidator: PickCacheInvalidator);
     dispose(): void;
     createModel<T extends DataSourceType>(identifier: T['modelIdentifier'], modelIdentifier: ModelIdentifier, modelMetadata: PointCloudMetadata): Promise<PointCloudNode<T>>;
 }

package/dist/packages/pointclouds/src/PointCloudManager.d.ts

@@ -1,4 +1,5 @@
 import { PerspectiveCamera, Plane, Scene, WebGLRenderer, Mesh } from 'three';
+import { PickCacheInvalidator } from '../../utilities';
 import { LoadingState } from '../../model-base';
 import { PointCloudFactory } from './PointCloudFactory';
 import { PointCloudNode } from './PointCloudNode';
@@ -20,12 +21,18 @@ export declare class PointCloudManager {
     private readonly _budgetSubject;
     private readonly _renderer;
     private _needsRedraw;
-    constructor(metadataRepository: PointCloudMetadataRepository, materialManager: PointCloudMaterialManager, modelFactory: PointCloudFactory, potreeInstance: Potree, scene: Scene, renderer: WebGLRenderer);
+    private readonly _pickCacheInvalidator;
+    constructor(metadataRepository: PointCloudMetadataRepository, materialManager: PointCloudMaterialManager, modelFactory: PointCloudFactory, potreeInstance: Potree, scene: Scene, renderer: WebGLRenderer, pickCacheInvalidator: PickCacheInvalidator);
     requestRedraw(): void;
     resetRedraw(): void;
     get pointBudget(): number;
     set pointBudget(points: number);
     get needsRedraw(): boolean;
+    /**
+     * Requests a pick cache invalidation if point buffers were loaded since the last drawn frame. Call
+     * before drawing, as drawing marks the loaded buffers as seen.
+     */
+    requestPickCacheInvalidationOnUpdatedData(): void;
     set clippingPlanes(planes: Plane[]);
     getLoadingStateObserver(): Observable<LoadingState>;
     updatePointClouds(camera: PerspectiveCamera): void;

package/dist/packages/pointclouds/src/PointCloudNode.d.ts

@@ -1,4 +1,4 @@
-import { CameraConfiguration } from '../../utilities';
+import { CameraConfiguration, PickCacheInvalidator } from '../../utilities';
 import { ClassificationInfo, PointCloudOctree, PickPoint } from './potree-three-loader';
 import { WellKnownAsprsPointClassCodes } from './types';
 import { PointSizeType, PointColorType, PointShape } from '../../rendering';
@@ -11,11 +11,13 @@ export declare class PointCloudNode<T extends DataSourceType = DataSourceType> e
     private readonly _objectIdToAnnotationsMap;
     private readonly _classificationHandler;
     private _needsRedraw;
+    private _clippingPlanes;
+    private readonly _pickCacheInvalidator;
     private static readonly pickingWindowSize;
     private readonly _modelIdentifier;
     private readonly _sourceTransform;
     private readonly _customTransform;
-    constructor(modelIdentifier: symbol, sourceTransform: Matrix4, octree: PointCloudOctree, annotations: PointCloudObject<T>[], classificationInfo: ClassificationInfo, cameraConfiguration?: CameraConfiguration);
+    constructor(modelIdentifier: symbol, sourceTransform: Matrix4, octree: PointCloudOctree, annotations: PointCloudObject<T>[], classificationInfo: ClassificationInfo, pickCacheInvalidator: PickCacheInvalidator, cameraConfiguration?: CameraConfiguration);
     get modelIdentifier(): symbol;
     get octree(): PointCloudOctree;
     get needsRedraw(): boolean;

package/dist/packages/pointclouds/src/PointCloudPickingHandler.d.ts

@@ -3,18 +3,33 @@ import { IntersectInput } from '../../model-base';
 import { PointCloudNode } from './PointCloudNode';
 import { DataSourceType } from '../../data-providers';
 import { IntersectPointCloudNodeResult } from './types';
+import { EdlOptions } from '../../rendering';
 export declare class PointCloudPickingHandler {
     private readonly _normalized;
+    private readonly _drawingBufferSize;
     private readonly _raycaster;
+    private readonly _renderer;
     private readonly _picker;
+    private readonly _edlOptions;
     private readonly _mutex;
-    private static readonly PickingWindowSize;
-    constructor(renderer: WebGLRenderer);
+    /**
+     * @param renderer Renderer used for the pick render.
+     * @param edlOptions EDL options the point clouds are rendered with, if any. EDL shades empty pixels
+     * within its radius of a point, closing small gaps on screen that the pick render (which has no EDL)
+     * still sees as empty, so the pick window is widened to cover that radius.
+     */
+    constructor(renderer: WebGLRenderer, edlOptions?: EdlOptions);
     dispose(): void;
     /**
-     * Invalidates the picker's cached full-frame pick buffer. Must be called whenever a new
-     * frame of the scene is rendered.
+     * Invalidates the picker's cached full-frame pick buffer. Call it when scene content that can
+     * change what a pick hits has changed.
      */
     invalidatePickCache(): void;
     intersectPointClouds(nodes: PointCloudNode<DataSourceType>[], input: IntersectInput): Promise<IntersectPointCloudNodeResult<DataSourceType>[]>;
+    private getPickWindowSize;
 }
+/**
+ * Pick window size in drawing buffer pixels. Odd, so the window is centered on the pick position.
+ * Wide enough to cover the EDL outline, which is drawn around points on screen but not in the pick render.
+ */
+export declare function computePickWindowSize(edlOptions: EdlOptions | undefined, drawingBufferHeight: number): number;

package/dist/packages/pointclouds/src/createPointCloudManager.d.ts

@@ -3,4 +3,5 @@ import { Scene, WebGLRenderer } from 'three';
 import { DMDataSourceType, ModelMetadataProvider, PointCloudStylableObjectProvider, CachedModelDataProvider } from '../../data-providers';
 import { IPointClassificationsProvider } from './classificationsProviders/IPointClassificationsProvider';
 import { PointCloudMaterialManager } from '../../rendering';
-export declare function createPointCloudManager(modelMetadataProvider: ModelMetadataProvider, pointCloudStylableObjectProvider: PointCloudStylableObjectProvider, classificationsProvider: IPointClassificationsProvider, pointCloudDMProvider: PointCloudStylableObjectProvider<DMDataSourceType>, pointCloudMaterialManager: PointCloudMaterialManager, cachedProvider: CachedModelDataProvider, scene: Scene, renderer: WebGLRenderer): PointCloudManager;
+import { PickCacheInvalidator } from '../../utilities';
+export declare function createPointCloudManager(modelMetadataProvider: ModelMetadataProvider, pointCloudStylableObjectProvider: PointCloudStylableObjectProvider, classificationsProvider: IPointClassificationsProvider, pointCloudDMProvider: PointCloudStylableObjectProvider<DMDataSourceType>, pointCloudMaterialManager: PointCloudMaterialManager, cachedProvider: CachedModelDataProvider, scene: Scene, renderer: WebGLRenderer, pickCacheInvalidator: PickCacheInvalidator): PointCloudManager;

package/dist/packages/pointclouds/src/potree-three-loader/tree/PointCloudOctreePicker.d.ts

@@ -16,8 +16,8 @@ export declare class PointCloudOctreePicker {
     constructor(renderer: WebGLRenderer);
     dispose(): void;
     /**
-     * Invalidates the cached full-frame pick buffer. Must be called whenever a new frame of the
-     * scene is rendered (camera, point cloud LOD, styling or clipping changes) and on resize.
+     * Invalidates the cached full-frame pick buffer. Must be called whenever the camera or scene content that
+     * affects picking changes (point cloud LOD, styling or clipping), as the cache does not compare the camera itself.
      */
     invalidateCache(): void;
     pick(camera: Camera, ray: Ray, octrees: PointCloudOctree[], params?: Partial<PickParams>): Promise<PickPoint | null>;