@cognite/reveal 4.37.0 → 4.38.0

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

@@ -45,6 +45,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[]);

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.

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,15 @@ 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}.
+     * GPU resources for shadows are only allocated the first time they are 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, CadShadowReceiverForCustomObjectMaterial } from '../../../rendering';
 /**
  * A tuple of a 360 image and its collection.
  */

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

@@ -3,13 +3,22 @@ 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
@@ -17,4 +26,10 @@ export declare class PointCloudPickingHandler {
      */
     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/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 { CadShadowReceiverForCustomObjectMaterial } from './src/rendering/CadShadowReceiverForCustomObjectMaterial';
 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,4 +1,4 @@
-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';
@@ -18,6 +18,9 @@ export declare class CadMaterialManager {
     get needsRedraw(): boolean;
     private _renderMode;
     private readonly materialsMap;
+    private readonly _cadLightView;
+    private readonly _cadUpView;
+    private _cadLightingEnabled;
     private _clippingPlanes;
     private _needsRedraw;
     addModelMaterials(modelIdentifier: symbol, cadMaterial: CadMaterial): void;
@@ -35,6 +38,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;

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

@@ -23,4 +23,5 @@ export declare class PointCloudObjectAppearanceTexture {
     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,7 +1,9 @@
 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';
+import { ICustomObject } from '../../../utilities';
 /**
  * Single pass that applies post processing effects and
  * combines results from geometry passes.
@@ -13,9 +15,18 @@ 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;
+    private _receiversForCustomObjectsEnabled;
     updateRenderObjectsVisibility(visibilityParameters: PostProcessingObjectsVisibilityParameters): void;
-    constructor(scene: Scene, postProcessingPipelineOptions: PostProcessingPipelineOptions);
+    constructor(scene: Scene, postProcessingPipelineOptions: PostProcessingPipelineOptions, cadShadowPassDependencies?: Partial<CadShadowPassFactories>);
+    setSize(width: number, height: number): void;
+    adoptCustomObject(customObject: ICustomObject): void;
+    releaseCustomObject(customObject: ICustomObject): void;
+    setReceiversForCustomObjectsEnabled(enabled: boolean): 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/CadShadowReceiverForCustomObjectMaterial.d.ts

@@ -0,0 +1,15 @@
+import { Camera, ColorRepresentation, Texture, WebGLRenderer, Scene, RawShaderMaterial } from 'three';
+/**
+ * Surface on a custom object that samples a color or texture and receives CAD shadows.
+ * The viewer creates one for each up-facing plane that receives shadows.
+ * A skybox stays on its own material when `receiveShadow` is false.
+ * @public
+ */
+export declare class CadShadowReceiverForCustomObjectMaterial extends RawShaderMaterial {
+    private static frameShadowMap;
+    constructor(color?: ColorRepresentation, map?: Texture | null);
+    onBeforeRender(_renderer: WebGLRenderer, _scene: Scene, camera: Camera, _geometry: unknown, _object: unknown, _group: unknown): void;
+    setMap(map: Texture | null): void;
+    setColor(color: ColorRepresentation): void;
+    private refreshMapTransform;
+}

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

@@ -61,6 +61,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/SceneHandler.d.ts

@@ -5,6 +5,8 @@ export declare class SceneHandler {
     private readonly _cadModels;
     private readonly _pointCloudModels;
     private readonly _customObjects;
+    onCustomObjectAdded: ((customObject: ICustomObject) => void) | undefined;
+    onCustomObjectRemoved: ((customObject: ICustomObject) => void) | undefined;
     get scene(): Scene;
     get cadModels(): {
         cadNode: Object3D;

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,13 @@ export declare class CustomObject implements ICustomObject {
      */
     get useDepthTest(): boolean;
     set useDepthTest(value: boolean);
+    /**
+     * Whether CAD shadows fall on this object.
+     * Default is false.
+     * @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,12 @@ export interface ICustomObject {
      * @beta
      */
     get useDepthTest(): boolean;
+    /**
+     * Whether CAD shadows fall on this object.
+     * Optional. When omitted, the object does not receive shadows.
+     * @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.38.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": {
@@ -85,12 +85,12 @@
     "@types/random-seed": "^0.3.5",
     "@types/skmeans": "^0.11.7",
     "@types/stats": "^0.16.30",
-    "@types/three": "^0.185.0",
+    "@types/three": "^0.186.0",
     "@vitest/coverage-v8": "^4.1.7",
     "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",
@@ -101,7 +101,7 @@
     "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",
@@ -112,10 +112,10 @@
   },
   "peerDependencies": {
     "@cognite/sdk": "^10.0.0",
-    "three": "0.185.1"
+    "three": "0.186.1"
   },
   "files": [
     "dist"
   ],
-  "packageManager": "pnpm@12.5.1"
+  "packageManager": "pnpm@12.11.2"
 }