@cognite/reveal 4.28.7 → 4.29.0-dev.20260112

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

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

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

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

package/dist/packages/data-providers/index.d.ts

@@ -2,6 +2,7 @@
  * Copyright 2021 Cognite AS
  */
 export { CdfModelDataProvider } from './src/model-data-providers/CdfModelDataProvider';
+export { CachedModelDataProvider } from './src/model-data-providers/CachedModelDataProvider';
 export { CdfModelIdentifier } from './src/model-identifiers/CdfModelIdentifier';
 export { CdfModelMetadataProvider } from './src/metadata-providers/CdfModelMetadataProvider';
 export { Cdf360ImageAnnotationProvider } from './src/image-360-data-providers/Cdf360ImageAnnotationProvider';

package/dist/packages/data-providers/src/model-data-providers/CachedModelDataProvider.d.ts

@@ -0,0 +1,31 @@
+/*!
+ * Copyright 2025 Cognite AS
+ */
+import { ModelDataProvider } from '../ModelDataProvider';
+import { DataFileCacheManager, CacheConfig } from '../../../utilities';
+/**
+ * Wraps a ModelDataProvider with caching capabilities using the Cache API.
+ *
+ * This provider intercepts getBinaryFile and getJsonFile calls and caches
+ * the responses for faster subsequent access.
+ */
+export declare class CachedModelDataProvider implements ModelDataProvider {
+    private readonly baseProvider;
+    private readonly cacheManager;
+    constructor(baseProvider: ModelDataProvider, cacheConfig?: CacheConfig, cacheStorage?: CacheStorage);
+    getBinaryFile(baseUrl: string, fileName: string, abortSignal?: AbortSignal): Promise<ArrayBuffer>;
+    getJsonFile(baseUrl: string, fileName: string): Promise<unknown>;
+    private fetchWithCache;
+    /**
+     * Get the underlying cache manager for direct cache operations
+     */
+    getCacheManager(): DataFileCacheManager;
+    /**
+     * Check if a file is cached
+     */
+    isCached(baseUrl: string, fileName: string): Promise<boolean>;
+    /**
+     * Clear all cached data
+     */
+    clearCache(): Promise<void>;
+}

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

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

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

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

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

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

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

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

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

@@ -35,6 +35,9 @@ export { WebGLRendererStateHelper } from './src/WebGLRendererStateHelper';
 export { TypedArray, TypedArrayConstructor } from './src/types';
 export { MemoryRequestCache } from './src/cache/MemoryRequestCache';
 export { MostFrequentlyUsedCache } from './src/cache/MostFrequentlyUsedCache';
+export { DataFileCacheManager } from './src/cache/DataFileCacheManager';
+export type { CacheConfig } from './src/cache/types';
+export { BINARY_FILES_CACHE_NAME } from './src/cache/constants';
 export { disposeAttributeArrayOnUpload } from './src/disposeAttributeArrayOnUpload';
 export { incrementOrInsertIndex, decrementOrDeleteIndex } from './src/counterMap';
 export { calculateVolumeOfMesh } from './src/calculateVolumeOfMesh';

package/dist/packages/utilities/src/cache/DataFileCacheManager.d.ts

@@ -0,0 +1,49 @@
+import { CacheConfig } from './types';
+/**
+ * Data File Cache Manager using the Browser Cache API for storing various data files
+ * Supports caching of binary files (point clouds, CAD models), images (360 images), and JSON data
+ *
+ * @example
+ * ```typescript
+ * // Default: Cache forever, browser manages eviction
+ * const cache = new DataFileCacheManager({
+ *   cacheName: 'reveal-3d-resources-v1'
+ * });
+ *
+ * // Optional: Add time-based expiration
+ * const cache = new DataFileCacheManager({
+ *   cacheName: 'reveal-3d-resources-v1',
+ *   maxAge: 7 * 24 * 60 * 60 * 1000 // Expire after 7 days
+ * });
+ *
+ * // Store a response
+ * await cache.storeResponse(url, response);
+ *
+ * // Retrieve cached response, returns undefined if expired or not found
+ * const cachedResponse = await cache.getCachedResponse(url);
+ * ```
+ */
+export declare class DataFileCacheManager {
+    private readonly DEFAULT_CONFIG;
+    private readonly _config;
+    private readonly _caches;
+    get cacheConfig(): CacheConfig;
+    constructor(config?: Partial<CacheConfig>, cacheStorage?: CacheStorage);
+    /**
+     * Check if a URL is cached and not expired
+     */
+    has(url: string): Promise<boolean>;
+    /**
+     * Clear all cached entries
+     */
+    clear(): Promise<void>;
+    /**
+     * Get a cached response if it exists and is not expired
+     */
+    getCachedResponse(url: string): Promise<Response | undefined>;
+    /**
+     * Store data in cache
+     * Browser will automatically evict old entries when quota is reached
+     */
+    storeResponse(url: string, data: ArrayBuffer, contentType?: string): Promise<void>;
+}

package/dist/packages/utilities/src/cache/constants.d.ts

@@ -0,0 +1,6 @@
+/*!
+ * Copyright 2025 Cognite AS
+ */
+export declare const BINARY_FILES_CACHE_NAME = "reveal-3d-resources-v1";
+export declare const BINARY_FILES_CACHE_HEADER_DATE = "X-Cache-Date";
+export declare const BINARY_FILES_CACHE_HEADER_SIZE = "X-Cache-Size";

package/dist/packages/utilities/src/cache/types.d.ts

@@ -0,0 +1,14 @@
+/*!
+ * Copyright 2025 Cognite AS
+ */
+/**
+ * Configuration for cache behavior
+ */
+export type CacheConfig = {
+    /** Name of the cache */
+    cacheName: string;
+    /** Maximum age in milliseconds before entries expire (Default is Infinity = never expire) */
+    maxAge: number;
+    /** Maximum cache size in bytes (Default is Infinity = browser manages quota) */
+    maxCacheSize: number;
+};

package/dist/packages/utilities/src/cache/utils.d.ts

@@ -0,0 +1,6 @@
+/*!
+ * Copyright 2025 Cognite AS
+ */
+export declare function safeParseInt(value: string | null | undefined): number | undefined;
+export declare function getCacheDate(response: Response): number | undefined;
+export declare function getCacheSize(response: Response): number | undefined;

package/package.json

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