@cognite/reveal 4.37.0 → 4.39.0

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

@@ -6,6 +6,7 @@ export { CadMaterialManager, createCadMaterial } from './src/CadMaterialManager'
 export { PointCloudMaterialManager } from './src/PointCloudMaterialManager';
 export type { RenderOptions, SsaoParameters, EdlOptions } from './src/rendering/types';
 export { defaultRenderOptions, SsaoSampleQuality, AntiAliasingMode } from './src/rendering/types';
+export { shouldApplyEdl } from './src/render-pipeline-providers/pointCloudParameterUtils';
 export * from './src/pointcloud-rendering/constants';
 export * from './src/pointcloud-rendering/enums';
 export type * from './src/pointcloud-rendering/types';
@@ -17,6 +18,7 @@ export type { StyledTreeIndexSets } from './src/utilities/types';
 export { type Materials, initializeDefinesAndUniforms, forEachMaterial } from './src/rendering/materials';
 export type { OctreeMaterialParams } from './src/pointcloud-rendering';
 export { PointCloudMaterial } from './src/pointcloud-rendering';
+export { CustomObjectEffectMaterial, CadShadowReceiverForCustomObjectMaterial, type TextureVariationType } from './src/rendering/CustomObjectEffectMaterial';
 export { DefaultRenderPipelineProvider } from './src/render-pipeline-providers/DefaultRenderPipelineProvider';
 export { CadGeometryRenderModePipelineProvider } from './src/render-pipeline-providers/CadGeometryRenderModePipelineProvider';
 export { BasicPipelineExecutor } from './src/pipeline-executors/BasicPipelineExecutor';

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

@@ -1,8 +1,8 @@
-import { Plane, RawShaderMaterial, Texture } from 'three';
+import { Camera, Plane, RawShaderMaterial, Texture } from 'three';
 import { Materials } from './rendering/materials';
 import { RenderMode } from './rendering/RenderMode';
 import { NodeAppearance, ClippingPlanesProvider, NodeAppearanceProvider, NodeAppearanceTextureBuilder, NodeTransformProvider, NodeTransformTextureBuilder } from '../../cad-styling';
-import { IndexSet } from '../../utilities';
+import { IndexSet, PickCacheInvalidator } from '../../utilities';
 export type CadMaterial = {
     materials: Materials;
     nodeAppearanceProvider: NodeAppearanceProvider;
@@ -18,8 +18,13 @@ export declare class CadMaterialManager {
     get needsRedraw(): boolean;
     private _renderMode;
     private readonly materialsMap;
+    private readonly _cadLightView;
+    private readonly _cadUpView;
+    private _cadLightingEnabled;
     private _clippingPlanes;
     private _needsRedraw;
+    private readonly _pickCacheInvalidator;
+    constructor(pickCacheInvalidator: PickCacheInvalidator);
     addModelMaterials(modelIdentifier: symbol, cadMaterial: CadMaterial): void;
     removeModelMaterials(modelIdentifier: symbol): void;
     addTexturedMeshMaterial(modelIdentifier: symbol, sectorId: number, texture: Texture): RawShaderMaterial;
@@ -35,6 +40,8 @@ export declare class CadMaterialManager {
     getModelVisibleTreeIndices(modelIdentifier: symbol): IndexSet;
     setRenderMode(mode: RenderMode): void;
     getRenderMode(): RenderMode;
+    setCadLightingEnabled(enabled: boolean): void;
+    updateViewLighting(camera: Camera): void;
     resetRedraw(): void;
     dispose(): void;
     private updateClippingPlanesForModel;
@@ -44,4 +51,4 @@ export declare class CadMaterialManager {
     private applyToAllMaterials;
     private initializeDefinesAndUniforms;
 }
-export declare function createCadMaterial(maxTreeIndex: number): CadMaterial;
+export declare function createCadMaterial(maxTreeIndex: number, pickCacheInvalidator: PickCacheInvalidator): CadMaterial;

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

@@ -1,4 +1,4 @@
-import { WebGLRenderer } from 'three';
+import { WebGLRenderer, Vector3 } from 'three';
 import { RenderPass } from './RenderPass';
 /**
  * Defines a provider that provides a set of renderpasses
@@ -10,4 +10,7 @@ import { RenderPass } from './RenderPass';
 export interface RenderPipelineProvider {
     pipeline(renderer: WebGLRenderer): Generator<RenderPass>;
     dispose(): void;
+    shadowsEnabled?: boolean;
+    setShadowFocus?(focus: Vector3): void;
+    readonly needsRedraw?: boolean;
 }

package/dist/packages/rendering/src/pointcloud-rendering/PointCloudMaterial.d.ts

@@ -48,6 +48,7 @@ export declare class PointCloudMaterial extends RawShaderMaterial {
     private readonly _gradient;
     private gradientTexture;
     private _objectAppearanceTexture;
+    private _ownsObjectAppearanceTexture;
     private _classification;
     private classificationTexture;
     uniforms: IPointCloudMaterialUniforms & Record<string, IUniform<any>>;

package/dist/packages/rendering/src/pointcloud-rendering/PointCloudObjectAppearanceTexture.d.ts

@@ -16,11 +16,18 @@ export declare class PointCloudObjectAppearanceTexture {
     private setObjectStyle;
     private setObjectCollectionStyle;
     private resetTexture;
+    /**
+     * Called when rebuilding the texture changed the visibility of at least one object. Only visibility affects
+     * what can be picked, so color-only style changes do not call it.
+     */
+    onVisibilityChanged: (() => void) | undefined;
     onBeforeRender(): void;
+    private copyVisibility;
     assignStyledObjectSet(styledCollection: StyledPointCloudVolumeCollection<DataSourceType>): void;
     removeStyledObjectSet(collection: StyledPointCloudVolumeCollection<DataSourceType>['volumeCollection']): void;
     removeAllStyledObjectSets(): void;
     set defaultAppearance(appearance: CompletePointCloudAppearance);
     get defaultAppearance(): CompletePointCloudAppearance;
     get objectStyleTexture(): DataTexture;
+    dispose(): void;
 }

package/dist/packages/rendering/src/pointcloud-rendering/constants.d.ts

@@ -12,5 +12,48 @@ export declare const PERSPECTIVE_CAMERA = "PerspectiveCamera";
 export declare const COLOR_BLACK: Color;
 export declare const COLOR_WHITE: Color;
 export declare const DEFAULT_EDL_NEIGHBOURS_COUNT = 16;
+export declare const POINT_SIZE_REFERENCE_SCREEN_HEIGHT = 1080;
+export declare const MAX_EDL_RADIUS = 5;
+/**
+ * Half-width, in samples, of the depth-aware gap fill applied while compositing the point
+ * cloud. An empty pixel with enough covered neighbours adopts the nearest one, closing the gap
+ * without inflating point sizes. Cost is O(radius^2) texture taps per empty pixel per step.
+ * 0 disables it.
+ */
+export declare const DEFAULT_POINTCLOUD_GAP_FILL_RADIUS = 2;
+/**
+ * Number of strided search widths the gap fill tries per empty pixel: step 1px, 2px, 4px, ...
+ * The tight step closes fine gaps seen from a distance; wider steps bridge the large gaps that
+ * open up with the camera close. Reaches ~GAP_FILL_RADIUS * 2^(steps-1) pixels.
+ */
+export declare const DEFAULT_POINTCLOUD_GAP_FILL_STEPS = 5;
+/**
+ * Largest hole the fill will bridge, in world units (scene metres) at the surrounding
+ * surface's depth - NOT pixels. This is what makes the fill camera-distance aware: 0.3 m of
+ * surface projects to many pixels up close (big on-screen gaps get filled) but only a few
+ * pixels from far away (the model keeps its true silhouette). Independent of the depth checks.
+ */
+export declare const DEFAULT_POINTCLOUD_GAP_FILL_MAX_WORLD_GAP = 0.3;
+/**
+ * Depth spread a gap fill tolerates as "one surface", as a fraction of the surface's view-space
+ * distance. Covers curvature and noise. Lower = fills only very flat patches, less bleeding
+ * across silhouettes; higher = fills more aggressively.
+ */
+export declare const DEFAULT_POINTCLOUD_GAP_FILL_DEPTH_TOLERANCE = 0.02;
+/**
+ * Extra depth spread tolerated per world unit of search-window width, to allow steeply grazing
+ * surfaces (a floor seen edge-on) whose depth changes fast across the screen. ~tan of the
+ * steepest grazing angle still treated as a fillable surface (3 ~= 72 degrees).
+ */
+export declare const DEFAULT_POINTCLOUD_GAP_FILL_GRAZE_TOLERANCE = 3;
+/**
+ * Coverage-weight threshold, under point blending, below which a pixel is treated as a gap even
+ * though the depth pre-pass gave it valid depth. The depth pre-pass writes full opaque depth for
+ * any pixel inside a point's circular footprint, including one right at the sprite's edge that
+ * the separate weighted colour pass only gave a sliver of coverage (color.w near 0) - visually a
+ * gap, but invisible to a depth>=1 check alone. 0 disables this (only literal depth>=1 gaps are
+ * filled).
+ */
+export declare const DEFAULT_POINTCLOUD_GAP_FILL_MIN_COVERAGE_WEIGHT = 0.2;
 export declare const OBJECT_STYLING_TEXTURE_WIDTH = 256;
 export declare const OBJECT_STYLING_TEXTURE_HEIGHT = 256;

package/dist/packages/rendering/src/render-passes/CadShadowPass.d.ts

@@ -0,0 +1,31 @@
+import { Camera, RenderTargetOptions, ShaderMaterialParameters, Texture, WebGLRenderer, RawShaderMaterial, WebGLRenderTarget } from 'three';
+import { RenderPass } from '../RenderPass';
+import { createFullScreenTriangleMesh } from '../utilities/renderUtilities';
+import { CadShadowMap } from '../render-pipeline-providers/types';
+export type CadShadowPassFactories = {
+    createRenderTarget: (width: number, height: number, options: RenderTargetOptions) => WebGLRenderTarget;
+    createMaterial: (parameters: ShaderMaterialParameters) => RawShaderMaterial;
+    createFullScreenTriangleMesh: typeof createFullScreenTriangleMesh;
+};
+export declare const defaultCadShadowPassDependencies: CadShadowPassFactories;
+export declare class CadShadowPass implements RenderPass {
+    private readonly _renderTarget;
+    private readonly _material;
+    private readonly _mesh;
+    private readonly _scene;
+    private readonly _shadowMap;
+    private readonly _clearColor;
+    private readonly _focusProbe;
+    private readonly _viewProjection;
+    private _focusDistance;
+    private _disposed;
+    constructor(cameraDepthTexture: Texture | null, shadowMap: CadShadowMap, terminatorFade?: number, factories?: Partial<CadShadowPassFactories>);
+    get texture(): Texture;
+    setSize(width: number, height: number): void;
+    render(renderer: WebGLRenderer, camera: Camera): void;
+    probeFocus(renderer: WebGLRenderer, camera: Camera): void;
+    dispose(): void;
+    private issueFocusReading;
+    private collectFocusReading;
+    private applyFocusReading;
+}

package/dist/packages/rendering/src/render-passes/PostProcessingPass.d.ts

@@ -1,6 +1,7 @@
 import { Camera, Scene, WebGLRenderer } from 'three';
 import { PostProcessingObjectsVisibilityParameters } from './types';
 import { RenderPass } from '../RenderPass';
+import { CadShadowPassFactories } from './CadShadowPass';
 import { PostProcessingPipelineOptions } from '../render-pipeline-providers/types';
 /**
  * Single pass that applies post processing effects and
@@ -13,9 +14,14 @@ export declare class PostProcessingPass implements RenderPass {
     private readonly _postProcessingObjects;
     private readonly _pointcloudBlitMaterial;
     private readonly _postProcessingOptions;
+    private readonly _cadShadowPass;
+    private readonly _cadShadowMap;
+    private readonly _backBlitMaterial;
     private readonly setBlendFactorByBackVisibility;
     updateRenderObjectsVisibility(visibilityParameters: PostProcessingObjectsVisibilityParameters): void;
-    constructor(scene: Scene, postProcessingPipelineOptions: PostProcessingPipelineOptions);
+    constructor(scene: Scene, postProcessingPipelineOptions: PostProcessingPipelineOptions, cadShadowPassDependencies?: Partial<CadShadowPassFactories>);
+    setSize(width: number, height: number): void;
     render(renderer: WebGLRenderer, camera: Camera): void;
+    private renderCadShadows;
     dispose(): void;
 }

package/dist/packages/rendering/src/render-passes/ShadowMapPass.d.ts

@@ -0,0 +1,56 @@
+import { Box3, Camera, Texture, WebGLRenderer, Matrix4, Vector3 } from 'three';
+import { SceneHandler } from '../../../utilities';
+import { CadMaterialManager } from '../CadMaterialManager';
+import { RenderPass } from '../RenderPass';
+import { CadShadowMap } from '../render-pipeline-providers/types';
+export declare function resolveShadowMapResolution(maxTextureSize: number, mobileOrTablet: boolean): number;
+export declare class ShadowMapPass implements RenderPass, CadShadowMap {
+    private readonly _renderTarget;
+    private readonly _depthTexture;
+    private readonly _lightCamera;
+    private readonly _geometryPass;
+    private readonly _matrix;
+    private readonly _center;
+    private readonly _corner;
+    private readonly _rayOrigin;
+    private readonly _rayDir;
+    private readonly _hit;
+    private readonly _focusPoint;
+    private readonly _boundingSphere;
+    private _hasFocus;
+    private _focusDistance;
+    private _renderedFocusDistance;
+    private _focusReadbackPending;
+    private _spanLevel;
+    private _fullLeft;
+    private _fullRight;
+    private _fullBottom;
+    private _fullTop;
+    private _stableTexelWorldSize;
+    private _resolution;
+    private _texelWorldSize;
+    private _depthRange;
+    private _hasValidBounds;
+    private _userEnabled;
+    private readonly _mobileOrTablet;
+    constructor(sceneHandler: SceneHandler, materialManager: CadMaterialManager, userEnabled?: boolean, mobileOrTablet?: boolean);
+    get depthTexture(): Texture;
+    get matrix(): Matrix4;
+    get texelWorldSize(): number;
+    get stableTexelWorldSize(): number;
+    get depthRange(): number;
+    get enabled(): boolean;
+    get userEnabled(): boolean;
+    setEnabled(enabled: boolean): void;
+    setFocusPoint(point: Vector3 | null): void;
+    setFocusDistance(distance: number | undefined, readbackPending?: boolean): void;
+    get focusNeedsRedraw(): boolean;
+    setCadBounds(bounds: Box3): void;
+    render(renderer: WebGLRenderer, camera?: Camera): void;
+    dispose(): void;
+    private applyShadowMapResolution;
+    private fitWindowToFocus;
+    private quantizeSpan;
+    private captureStableTexel;
+    private updateTexelWorldSize;
+}

package/dist/packages/rendering/src/render-passes/types.d.ts

@@ -21,6 +21,7 @@ export type BlitOptions = {
     overrideAlpha?: number;
     edges?: boolean;
     outline?: boolean;
+    cadShadow?: boolean;
 };
 export type DepthBlendBlitOptions = {
     texture: Texture;
@@ -37,6 +38,8 @@ export type PointCloudPostProcessingOptions = {
     depthTexture: DepthTexture | null;
     pointBlending: boolean;
     edlOptions: EdlOptions;
+    /** Half-width in samples of the gap fill. Defaults to DEFAULT_POINTCLOUD_GAP_FILL_RADIUS; 0 disables it. */
+    gapFillRadius?: number;
 };
 export declare const transparentBlendOptions: BlendOptions;
 export type ThreeUniforms = {

package/dist/packages/rendering/src/render-pipeline-providers/DefaultRenderPipelineProvider.d.ts

@@ -1,4 +1,4 @@
-import { WebGLRenderTarget, WebGLRenderer } from 'three';
+import { Vector3, WebGLRenderTarget, WebGLRenderer } from 'three';
 import { CadMaterialManager } from '../CadMaterialManager';
 import { RenderPass } from '../RenderPass';
 import { RenderPipelineProvider } from '../RenderPipelineProvider';
@@ -17,17 +17,22 @@ export declare class DefaultRenderPipelineProvider implements RenderPipelineProv
     private readonly _cadGeometryRenderPipeline;
     private readonly _pointCloudRenderPipeline;
     private readonly _postProcessingPass;
+    private readonly _shadowMapPass;
     private readonly _ssaoPass;
     private readonly _blitToScreenMaterial;
     private readonly _blitToScreenMesh;
     private readonly _materialManager;
     private _rendererStateHelper;
     private _ssaoSampleSize;
+    private readonly _cadBounds;
+    private readonly _cadModelBounds;
+    get shadowsEnabled(): boolean;
+    set shadowsEnabled(enabled: boolean);
     set renderOptions(renderOptions: RenderOptions);
     constructor(materialManager: CadMaterialManager, pointCloudMaterialManager: PointCloudMaterialManager, sceneHandler: SceneHandler, renderOptions: RenderOptions, outputRenderTarget?: {
         target: WebGLRenderTarget;
         autoSize?: boolean;
-    });
+    }, enableShadows?: boolean);
     setOutputRenderTarget(target: WebGLRenderTarget | null, autoSizeRenderTarget?: boolean): void;
     pipeline(renderer: WebGLRenderer): Generator<RenderPass>;
     dispose(): void;
@@ -35,4 +40,7 @@ export declare class DefaultRenderPipelineProvider implements RenderPipelineProv
     private updateRenderTargetSizes;
     private shouldRenderSsao;
     private shouldRenderPointClouds;
+    setShadowFocus(focus: Vector3): void;
+    get needsRedraw(): boolean;
+    private updateShadowCasterBounds;
 }

package/dist/packages/rendering/src/render-pipeline-providers/types.d.ts

@@ -1,5 +1,19 @@
-import { Texture, Vector2, WebGLRenderTarget } from 'three';
+import { Matrix4, Object3D, Texture, Vector2, WebGLRenderTarget } from 'three';
+import { SectorScene } from '../../../cad-parsers';
 import { EdlOptions } from '../rendering/types';
+export type CadNodeLike = Object3D & {
+    readonly sectorScene: SectorScene;
+    readonly rootSector: Object3D;
+};
+export type CadShadowMap = {
+    readonly depthTexture: Texture;
+    readonly matrix: Matrix4;
+    readonly texelWorldSize: number;
+    readonly stableTexelWorldSize: number;
+    readonly depthRange: number;
+    readonly enabled: boolean;
+    setFocusDistance?(distance: number | undefined, readbackPending: boolean): void;
+};
 export type RenderTargetData = {
     currentRenderSize: Vector2;
     ssaoRenderTarget: WebGLRenderTarget;
@@ -17,7 +31,11 @@ export type PointCloudRenderTargets = {
 };
 export type PostProcessingPipelineOptions = CadGeometryRenderTargets & PointCloudRenderTargets & {
     ssaoTexture: Texture;
+    cadShadow?: {
+        map: CadShadowMap;
+    };
     edges: boolean;
     pointBlending?: boolean;
     edlOptions: EdlOptions;
 };
+export type PointCloudBlitUniformName = 'screenWidth' | 'screenHeight' | 'cameraNear' | 'cameraFar' | 'orthographicCamera' | 'worldPerPixel';

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

@@ -0,0 +1,75 @@
+import { ColorRepresentation, Texture, RawShaderMaterial } from 'three';
+/**
+ * Technique that hides the repeat of a tiled texture.
+ * - `'none'`: the texture is sampled as is.
+ * - `'hexTiling'`: cells rotate and shift the texture. Suits ground such as concrete, gravel and grass.
+ * - `'waterTiling'`: cells shift the texture without rotating it, so waves keep their direction.
+ * A second, larger copy of the texture is blended in and the contrast is kept. Suits water and ocean.
+ * @public
+ */
+export type TextureVariationType = 'none' | 'hexTiling' | 'waterTiling';
+/**
+ * Opt-in material for custom objects: an effect is compiled into the shader only while requested.
+ *
+ * {@link CustomObjectEffectMaterial.setReceivesShadow} requests the CAD shadow; the shader recompiles whenever the
+ * viewer's shadow map appears or disappears, so give each viewer its own material if shadow state can differ.
+ *
+ * Only the methods declared here are supported; inherited `RawShaderMaterial` internals may change.
+ * @public
+ */
+export declare class CustomObjectEffectMaterial extends RawShaderMaterial {
+    private _receivesShadow;
+    private _textureVariation;
+    /**
+     * White and no texture when omitted. Effects are requested afterwards through their setters.
+     * @param color - Diffuse color.
+     * @param diffuseTexture - Diffuse texture.
+     */
+    constructor(color?: ColorRepresentation, diffuseTexture?: Texture | null);
+    /** Whether this material requested the CAD shadow. */
+    get receivesShadow(): boolean;
+    /**
+     * Sets the diffuse texture. Pass null to clear it. A requested texture variation follows the
+     * new texture.
+     */
+    setDiffuseTexture(texture: Texture | null): void;
+    /**
+     * Sets the diffuse texture.
+     * @deprecated Use {@link CustomObjectEffectMaterial.setDiffuseTexture}.
+     */
+    setMap(map: Texture | null): void;
+    /**
+     * Chooses the technique that hides the repeat of the texture. It is drawn only while the material has a
+     * texture; the choice itself is kept, so it may be made before or after the texture is set.
+     */
+    setTextureVariation(type: TextureVariationType): void;
+    /** The texture variation this material requested. */
+    get textureVariation(): TextureVariationType;
+    private applyTextureVariation;
+    private setEffectEnabled;
+    /**
+     * Requests or drops the CAD shadow for this material; the request is kept and drawn only while the viewer has
+     * shadows enabled (`Cognite3DViewer.shadowsEnabled`), taking effect on the next draw.
+     */
+    setReceivesShadow(receivesShadow: boolean): void;
+    /**
+     * Sets the diffuse color. With a texture, the color multiplies it: white leaves the texture
+     * unchanged and any other color tints it.
+     */
+    setColor(color: ColorRepresentation): void;
+    private updateShadowUniforms;
+    private clearShadowUniforms;
+    private refreshMapTransform;
+}
+/**
+ * Alias for {@link CustomObjectEffectMaterial}.
+ * @deprecated Use {@link CustomObjectEffectMaterial}.
+ * @public
+ */
+export declare const CadShadowReceiverForCustomObjectMaterial: typeof CustomObjectEffectMaterial;
+/**
+ * Alias for {@link CustomObjectEffectMaterial}, so the old name still works as a type.
+ * @deprecated Use {@link CustomObjectEffectMaterial}.
+ * @public
+ */
+export type CadShadowReceiverForCustomObjectMaterial = CustomObjectEffectMaterial;

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

@@ -0,0 +1,5 @@
+import { Camera, Vector3 } from 'three';
+export declare const CAD_LIGHT_WORLD: Vector3;
+export declare const CAD_SHADOW_STRENGTH = 0.4;
+export declare function cadLightDirectionInViewSpace(camera: Camera, target: Vector3): Vector3;
+export declare function cadUpDirectionInViewSpace(camera: Camera, target: Vector3): Vector3;

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

@@ -34,5 +34,6 @@ export declare const pointCloudShaders: PointCloudShaders;
  */
 export declare const ssaoShaders: ShaderPair;
 export declare const blitShaders: ShaderPair;
+export declare const cadShadowShaders: ShaderPair;
 export declare const depthBlendBlitShaders: ShaderPair;
 export {};

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

@@ -24,6 +24,7 @@ export type EdlOptions = {
     strength: number;
     /**
      * Radius of sampled points in pixels. Determines thickness of edges addet on top of points.
+     * Values above 5 are clamped to 5.
      */
     radius: number;
 };

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

@@ -51,6 +51,7 @@ export { LineGeometry } from './src/three/lines/LineGeometry';
 export { LineMaterial } from './src/three/lines/LineMaterial';
 export { DeferredPromise } from './src/DeferredPromise';
 export { SceneHandler } from './src/SceneHandler';
+export { PickCacheInvalidator } from './src/PickCacheInvalidator';
 export { CustomObject } from './src/customObject/CustomObject';
 export type { ICustomObject } from './src/customObject/ICustomObject';
 export { CustomObjectIntersectInput } from './src/customObject/CustomObjectIntersectInput';
@@ -61,6 +62,7 @@ export { isPointVisibleByPlanes } from './src/three/isPointVisibleByPlanes';
 export { CDF_TO_VIEWER_TRANSFORMATION } from './src/constants';
 export { createUint8View } from './src/createUint8View';
 export { isDefined } from './src/isDefined';
+export { isRenderContextLost, setRenderContextLost } from './src/renderContextState';
 export * from './src/fdm';
 export * from './src/assetMappings';
 export * from './src/shapes';

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

@@ -0,0 +1,17 @@
+/*!
+ * Copyright 2026 Cognite AS
+ */
+/**
+ * Flag for whether the cached picking results are stale. Set it with {@link PickCacheInvalidator.request} wherever
+ * something that can change what a pick hits changes (models, sectors, clipping, transforms, or styling that hides or
+ * ghosts objects). Changes that are only drawn but never picked, such as colors or custom objects, should not set it.
+ * The camera and canvas size do not need to be set, as the pick caches compare them on every pick.
+ */
+export declare class PickCacheInvalidator {
+    private _requested;
+    request(): void;
+    /**
+     * Returns whether an invalidation was requested since the last call, and clears the flag.
+     */
+    consume(): boolean;
+}

package/dist/packages/utilities/src/customObject/CustomObject.d.ts

@@ -13,6 +13,7 @@ export declare class CustomObject implements ICustomObject {
     private _shouldPick;
     private _shouldPickBoundingBox;
     private _useDepthTest;
+    private _receiveShadow;
     /**
      * Constructor
      * @beta
@@ -51,6 +52,15 @@ export declare class CustomObject implements ICustomObject {
      */
     get useDepthTest(): boolean;
     set useDepthTest(value: boolean);
+    /**
+     * Whether CAD shadows fall on this object.
+     * Default is false.
+     * @deprecated No longer read. Request the shadow on the material instead with
+     * `CustomObjectEffectMaterial.setReceivesShadow`.
+     * @beta
+     */
+    get receiveShadow(): boolean;
+    set receiveShadow(value: boolean);
     /**
      * Get the bounding box from the object
      * @beta

package/dist/packages/utilities/src/customObject/ICustomObject.d.ts

@@ -36,6 +36,14 @@ export interface ICustomObject {
      * @beta
      */
     get useDepthTest(): boolean;
+    /**
+     * Whether CAD shadows fall on this object.
+     * Optional. When omitted, the object does not receive shadows.
+     * @deprecated No longer read. Request the shadow on the material instead with
+     * `CustomObjectEffectMaterial.setReceivesShadow`.
+     * @beta
+     */
+    readonly receiveShadow?: boolean;
     /**
      * Get the bounding box from the object
      * @beta

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

@@ -0,0 +1,4 @@
+/*!
+ * Copyright 2026 Cognite AS
+ */
+export declare function isRenderContextLost(): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cognite/reveal",
-  "version": "4.37.0",
+  "version": "4.39.0",
   "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": {
@@ -81,41 +81,41 @@
     "@types/jsdom": "^30.0.0",
     "@types/lodash-es": "^4.17.12",
     "@types/mixpanel-browser": "^2.49.0",
-    "@types/node": "^25.9.3",
+    "@types/node": "^26.0.0",
     "@types/random-seed": "^0.3.5",
     "@types/skmeans": "^0.11.7",
     "@types/stats": "^0.16.30",
-    "@types/three": "^0.185.0",
-    "@vitest/coverage-v8": "^4.1.7",
+    "@types/three": "^0.186.0",
+    "@vitest/coverage-v8": "^5.0.0",
     "dat.gui": "^0.7.9",
     "eslint": "^10.5.0",
     "eslint-config-prettier": "^10.0.0",
-    "eslint-plugin-jsdoc": "^64.0.0",
+    "eslint-plugin-jsdoc": "^65.0.0",
     "eslint-plugin-prettier": "^5.1.3",
     "eslint-plugin-unused-imports": "^4.0.0",
     "globals": "^17.0.0",
     "typescript-eslint": "^8.0.0",
     "glob": "^13.0.0",
-    "happy-dom": "^20.10.6",
+    "happy-dom": "^21.0.0",
     "moq.ts": "10.0.8",
     "prettier": "^3.2.5",
     "shx": "^0.4.0",
     "stats.js": "^0.17.0",
-    "three": "0.185.1",
+    "three": "0.186.1",
     "typescript": "^6.0.3",
     "unplugin-dts": "^1.0.2",
     "vite": "^8.1.0",
     "vite-plugin-glsl": "^1.6.0",
-    "vitest": "^4.1.7",
+    "vitest": "^5.0.0",
     "vitest-canvas-mock": "^1.1.4",
     "wasm-pack": "^0.15.0"
   },
   "peerDependencies": {
     "@cognite/sdk": "^10.0.0",
-    "three": "0.185.1"
+    "three": "0.186.1"
   },
   "files": [
     "dist"
   ],
-  "packageManager": "pnpm@12.5.1"
+  "packageManager": "pnpm@12.15.0"
 }