@cognite/reveal 4.36.0 → 4.38.0

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

@@ -5,10 +5,27 @@ import { PickParams } from './PointCloudOctreePickerHelper';
 export type { PickParams };
 export declare class PointCloudOctreePicker {
     private static readonly helperVec3;
+    private static readonly helperVec2;
+    private static readonly REBUILD_HOLDOFF_MS;
     private pickState;
     private readonly _renderer;
     private readonly _pickerHelper;
+    private _cache;
+    private _invalidationCount;
+    private _lastInvalidatedAt;
     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.
+     */
+    invalidateCache(): void;
     pick(camera: Camera, ray: Ray, octrees: PointCloudOctree[], params?: Partial<PickParams>): Promise<PickPoint | null>;
+    private pickWindowed;
+    private isCacheUsable;
+    private buildCache;
+    /** Picks the smallest node-index bit width that fits every visible node, or undefined if there are no nodes or none fits. */
+    private computeNodeIndexBits;
+    private renderAndReadBackPixels;
+    private pickFromCache;
 }

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

@@ -29,6 +29,25 @@ export interface PickParams {
      * @param renterTarget The render target used for picking.
      */
     onBeforePickRender: (material: PointCloudMaterial, renterTarget: WebGLRenderTarget) => void;
+    /**
+     * Whether the camera is currently known to be in motion (e.g. during an interactive zoom/pan/
+     * orbit). When true, the full-frame pick cache is never rebuilt for this call, regardless of
+     * how long ago it was last invalidated. Confirmed by measurement: a full-frame rebuild's async
+     * GPU readback (tens to hundreds of ms) routinely doesn't finish before the next camera-change
+     * invalidates it again during continuous motion, so the rebuild is started, pays its full cost,
+     * gets discarded, and the caller still has to fall back to a windowed pick anyway. Falls back to
+     * the time-based holdoff when omitted.
+     */
+    cameraInMotion?: boolean;
+    /**
+     * Unconditionally skips the full-frame pick cache (both serving from it and rebuilding it) for
+     * this call, regardless of camera-motion state. Intended for callers that pick on every input
+     * event of a fast, continuous interaction (e.g. wheel-driven zoom-to-cursor) where even
+     * checking/rebuilding the cache adds latency that matters more than the cache's benefit - unlike
+     * `cameraInMotion`, this doesn't depend on the camera having already started moving, which
+     * matters because some callers pick *before* moving the camera for that same input event.
+     */
+    forceWindowedPick?: boolean;
 }
 /**
  * Helper class for PointCloudOctreePicker.
@@ -40,15 +59,21 @@ export declare class PointCloudOctreePickerHelper {
     private readonly _rendererStateHelper;
     constructor(renderer: WebGLRenderer);
     resetState(): void;
-    prepareRender(x: number, y: number, pickWndSize: number, pickMaterial: PointCloudMaterial, pickState: IPickState): void;
-    render(camera: Camera, pickMaterial: PointCloudMaterial, octrees: PointCloudOctree[], ray: Ray, pickState: IPickState, params: Partial<PickParams>): RenderedNode[];
+    prepareRender(x: number, y: number, width: number, height: number, pickMaterial: PointCloudMaterial, pickState: IPickState): void;
+    render(camera: Camera, pickMaterial: PointCloudMaterial, octrees: PointCloudOctree[], ray: Ray | undefined, pickState: IPickState, params: Partial<PickParams>, nodeIndexBits?: number): RenderedNode[];
     private static nodesOnRay;
-    readPixelsAsync(x: number, y: number, pickWndSize: number, renderTarget: WebGLRenderTarget): Promise<Uint8Array>;
+    readPixelsAsync(x: number, y: number, width: number, height: number, renderTarget: WebGLRenderTarget, pixels?: Uint8Array): Promise<Uint8Array>;
     private static createTempNodes;
     private static updatePickMaterial;
     static updatePickRenderTarget(pickState: IPickState, width: number, height: number): void;
     private static makePickRenderTarget;
-    static findHit(pixels: Uint8Array, pickWndSize: number, nodes: RenderedNode[], camera: Camera): PointCloudHit | null;
+    static computeBitSplit(nodeCount: number, maxPointsPerNode: number): number | undefined;
+    static decodePackedPixel(packedIndex: number, nodeIndexBits: number): {
+        nodeIndex: number;
+        pointIndex: number;
+    };
+    static findHit(pixels: Uint8Array, pickWndSize: number, nodes: RenderedNode[], camera: Camera, nodeIndexBits?: number): PointCloudHit | null;
+    static findHitInBuffer(ibuffer: Uint32Array, bufferWidth: number, bufferHeight: number, centerX: number, centerY: number, windowSize: number, nodes: RenderedNode[], camera: Camera, nodeIndexBits: number): PointCloudHit | null;
     static getPickPoint(hit: PointCloudHit | null, nodes: RenderedNode[]): PickPoint | null;
     static getPointPosition(nodes: RenderedNode[], pcIndex: number, pIndex: number): Vector3;
     private static addPositionToPickPoint;

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

@@ -23,6 +23,7 @@ export interface IPointCloudMaterialUniforms {
     level: IUniform<number>;
     maxSize: IUniform<number>;
     minSize: IUniform<number>;
+    nodeIndexBits: IUniform<number>;
     objectIdLUT: IUniform<Texture>;
     octreeSize: IUniform<number>;
     pcIndex: IUniform<number>;
@@ -47,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>>;
@@ -68,6 +70,8 @@ export declare class PointCloudMaterial extends RawShaderMaterial {
     set maxSize(value: number);
     get minSize(): number;
     set minSize(value: number);
+    get nodeIndexBits(): number;
+    set nodeIndexBits(value: number);
     get octreeSize(): number;
     set octreeSize(value: number);
     get screenHeight(): number;

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

@@ -3,6 +3,7 @@ export declare const DEFAULT_MAX_POINT_SIZE = 10;
 export declare const DEFAULT_MIN_NODE_PIXEL_SIZE = 50;
 export declare const DEFAULT_MIN_POINT_SIZE = 1;
 export declare const DEFAULT_PICK_WINDOW_SIZE = 15;
+export declare const DEFAULT_NODE_INDEX_BITS = 8;
 export declare const DEFAULT_POINT_BUDGET = 3000000;
 export declare const MAX_LOADS_TO_GPU = 15;
 export declare const MAX_NUM_NODES_LOADING = 8;
@@ -11,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.36.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.184.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.184.0",
+    "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.184.0"
+    "three": "0.186.1"
   },
   "files": [
     "dist"
   ],
-  "packageManager": "pnpm@11.21.0"
+  "packageManager": "pnpm@12.11.2"
 }