@cognite/reveal 4.31.2 → 4.32.0

package/dist/packages/360-images/src/icons/clustering/HtmlClusterRenderer.d.ts

@@ -34,6 +34,7 @@ export declare class HtmlClusterRenderer {
     setHoveredCluster(icon: Overlay3DIcon | undefined): void;
     getHoveredCluster(): Overlay3DIcon | undefined;
     setVisible(visible: boolean): void;
+    private clearAllElements;
     dispose(): void;
     private createContainer;
     private injectStyles;

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

@@ -10,11 +10,12 @@ import { CadManager, CadModelBudget } from '../../../cad-geometry-loaders';
 import { NodeAppearanceProvider } from '../../../cad-styling';
 import { RenderMode, RenderPipelineExecutor, CadMaterialManager, RenderPipelineProvider, ResizeHandler, SettableRenderTarget } from '../../../rendering';
 import { CameraManager } from '../../../camera-manager';
-import { DataSourceType, InternalDataSourceType } from '../../../data-providers';
+import { DataSourceType, File3dFormat, InternalDataSourceType } from '../../../data-providers';
 import { AddModelOptionsWithModelRevisionId } from '../../../data-providers/src/utilities/internalAddModelOptions';
 export type AddCadModelOptions = {
     nodeAppearanceProvider?: NodeAppearanceProvider;
     geometryFilter?: GeometryFilter;
+    outputFormat?: File3dFormat;
 };
 /**
  * Handler for events about data being loaded.

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

@@ -6,7 +6,7 @@ import { CadModelMetadata } from '../../cad-parsers';
 import { CadModelUpdateHandler } from './CadModelUpdateHandler';
 import { LoadingState } from '../../model-base';
 import { CadMaterialManager, RenderMode } from '../../rendering';
-import { ModelIdentifier } from '../../data-providers';
+import { File3dFormat, ModelIdentifier } from '../../data-providers';
 import { CadModelBudget } from './CadModelBudget';
 import { CadModelFactory, CadModelSectorLoadStatistics, CadNode, GeometryFilter } from '../../cad-model';
 export declare class CadManager {
@@ -21,6 +21,7 @@ export declare class CadManager {
     private readonly _loadingStateChangedTrigger;
     private readonly _markNeedsRedrawBound;
     private readonly _sectorBufferTime;
+    private readonly _compatibleGltfFormats;
     get materialManager(): CadMaterialManager;
     get budget(): CadModelBudget;
     set budget(budget: CadModelBudget);
@@ -40,7 +41,7 @@ export declare class CadManager {
     set renderMode(renderMode: RenderMode);
     doesModelHaveCompatibleFormat(modelMetadata: CadModelMetadata): boolean;
     updateModelCompatibilityFormat(modelMetadata: CadModelMetadata): void;
-    addModel(modelIdentifier: ModelIdentifier, geometryFilter?: GeometryFilter): Promise<CadNode>;
+    addModel(modelIdentifier: ModelIdentifier, geometryFilter?: GeometryFilter, outputFormat?: File3dFormat): Promise<CadNode>;
     removeModel(model: CadNode): void;
     on(event: 'loadingStateChanged', listener: (loadingState: LoadingState) => void): void;
     off(event: 'loadingStateChanged', listener: (loadingState: LoadingState) => void): void;

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

@@ -14,6 +14,11 @@ export declare class TakenV9SectorMap extends TakenSectorMapBase {
     constructor(determineSectorCost: DetermineSectorCostDelegate<SectorMetadata>);
     initializeScene(modelMetadata: CadModelMetadata): void;
     markSectorDetailed(model: CadModelMetadata, sectorId: number, priority: number): void;
+    /**
+     * Marks a sector as forced-detailed with infinite priority.
+     * These sectors are always loaded regardless of budget constraints.
+     */
+    markSectorForced(model: CadModelMetadata, sectorId: number): void;
     isWithinBudget(budget: CadModelBudget): boolean;
     collectWantedSectors(): PrioritizedWantedSector[];
     clear(): void;

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

@@ -15,6 +15,16 @@ export interface DetermineSectorsInput {
     cameraInMotion: boolean;
     budget: CadModelBudget;
     prioritizedAreas: PrioritizedArea[];
+    /**
+     * Models whose sectors must always be loaded regardless of budget.
+     * Identified by their `revealInternalId` symbol.
+     */
+    lockedModelIdentifiers: Set<symbol>;
+    /**
+     * Per-model set of specific sector IDs that must always be loaded
+     * regardless of budget. Keyed by model `revealInternalId`.
+     */
+    lockedSectorIdsByModel: Map<symbol, ReadonlySet<number>>;
 }
 export type DetermineSectorsPayload = {
     camera: THREE.PerspectiveCamera;
@@ -24,6 +34,8 @@ export type DetermineSectorsPayload = {
     cameraInMotion: boolean;
     budget: CadModelBudget;
     prioritizedAreas: PrioritizedArea[];
+    lockedModelIdentifiers: Set<symbol>;
+    lockedSectorIdsByModel: Map<symbol, ReadonlySet<number>>;
 };
 /**
  * Statistics for how much data is required to load set of sectors.

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

@@ -1,7 +1,7 @@
 import { GeometryFilter } from './types';
 import { CadMaterialManager } from '../../rendering';
 import { CadModelMetadata } from '../../cad-parsers';
-import { ModelDataProvider, ModelMetadataProvider, ModelIdentifier } from '../../data-providers';
+import { ModelDataProvider, ModelMetadataProvider, ModelIdentifier, File3dFormat } from '../../data-providers';
 import { CadNode } from './wrappers/CadNode';
 export declare class CadModelFactory {
     private readonly _materialManager;
@@ -9,7 +9,7 @@ export declare class CadModelFactory {
     private readonly _cadModelMetadataRepository;
     private _gltfSectorRepository;
     constructor(materialManager: CadMaterialManager, modelMetadataProvider: ModelMetadataProvider, modelDataProvider: ModelDataProvider);
-    loadModelMetadata(externalModelIdentifier: ModelIdentifier): Promise<CadModelMetadata>;
+    loadModelMetadata(externalModelIdentifier: ModelIdentifier, outputFormat?: File3dFormat): Promise<CadModelMetadata>;
     createModel(metadata: CadModelMetadata, geometryFilter?: GeometryFilter): CadNode;
     private getSectorRepository;
     dispose(): void;

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

@@ -28,6 +28,8 @@ export declare class CadNode extends Object3D<Object3DEventMap & {
     private _needsRedraw;
     private readonly _meshManager;
     readonly treeIndexToSectorsMap: TreeIndexToSectorsMap;
+    private readonly _lockedTreeIndices;
+    private readonly _lockedSectorIds;
     readonly type = "CadNode";
     constructor(model: CadModelMetadata, materialManager: CadMaterialManager, sectorRepository: SectorRepository);
     get needsRedraw(): boolean;
@@ -58,6 +60,16 @@ export declare class CadNode extends Object3D<Object3DEventMap & {
     getCdfToDefaultModelTransformation(out?: Matrix4): Matrix4;
     setModelRenderLayers(root?: Object3D): void;
     get prioritizedAreas(): PrioritizedArea[];
+    get lockedSectorIds(): ReadonlySet<number>;
+    lockTreeIndices(treeIndices: number[]): void;
+    unlockTreeIndices(treeIndices: number[]): void;
+    unlockAllTreeIndices(): void;
+    /**
+     * Called when a new sector is discovered for a tree index.
+     * If that tree index is locked, the sector is added to the locked set.
+     */
+    onTreeIndexSectorDiscovered(treeIndex: number, sectorId: number): void;
+    private recomputeLockedSectorIds;
     batchGeometry(geometryBatchingQueue: ParsedGeometry[], sectorId: number): void;
     removeBatchedSectorGeometries(sectorId: number): void;
     /**

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

@@ -111,6 +111,26 @@ export declare class CogniteCadModel implements CdfModelNodeCollectionDataProvid
      * default appearance.
      */
     removeAllStyledNodeCollections(): void;
+    /**
+     * Locks the sectors containing the given tree indices so they are never
+     * evicted when the CAD budget is reduced. The lock is reactive: if a
+     * tree index's geometry is later discovered in a new sector (when that
+     * sector loads), the new sector is automatically locked as well.
+     *
+     * @param treeIndices Tree indices of nodes whose sectors should be locked.
+     */
+    lockTreeIndices(treeIndices: number[]): void;
+    /**
+     * Removes the lock for the given tree indices. Sectors that were only
+     * locked because of these tree indices will become eligible for eviction.
+     *
+     * @param treeIndices Tree indices to unlock.
+     */
+    unlockTreeIndices(treeIndices: number[]): void;
+    /**
+     * Removes all tree-index-based sector locks on this model.
+     */
+    unlockAllTreeIndices(): void;
     /**
      * Apply a transformation matrix to the tree indices given, changing
      * rotation, scale and/or position.

package/dist/packages/cad-parsers/src/metadata/CadModelMetadataRepository.d.ts

@@ -3,13 +3,13 @@
  */
 import { CadModelMetadata } from './CadModelMetadata';
 import { MetadataRepository } from '../../../model-base';
-import { ModelDataProvider, ModelMetadataProvider, ModelIdentifier } from '../../../data-providers';
+import { ModelDataProvider, ModelMetadataProvider, ModelIdentifier, File3dFormat } from '../../../data-providers';
 export declare class CadModelMetadataRepository implements MetadataRepository<Promise<CadModelMetadata>> {
     private readonly _modelMetadataProvider;
     private readonly _modelDataProvider;
     private readonly _cadSceneParser;
     private readonly _blobFileName;
     constructor(modelMetadataProvider: ModelMetadataProvider, modelDataProvider: ModelDataProvider, blobFileName?: string);
-    loadData(modelIdentifier: ModelIdentifier): Promise<CadModelMetadata>;
+    loadData(modelIdentifier: ModelIdentifier, outputFormat?: File3dFormat): Promise<CadModelMetadata>;
     private getSupportedOutput;
 }

package/dist/packages/data-providers/src/ModelIdentifier.d.ts

@@ -2,6 +2,7 @@
  * Copyright 2021 Cognite AS
  */
 import { ClassicModelIdentifierType, DMModelIdentifierType, LocalModelIdentifierType } from './DataSourceType';
+import { File3dFormat } from './types';
 /**
  * Identifies a 3D model. Typically, implementations will use {@link CdfModelIdentifier}.
  */
@@ -16,4 +17,4 @@ export interface ModelIdentifier {
      */
     sourceModelIdentifier(): string;
 }
-export declare function createModelIdentifier(identifier: ClassicModelIdentifierType | (DMModelIdentifierType & ClassicModelIdentifierType) | LocalModelIdentifierType): ModelIdentifier;
+export declare function createModelIdentifier(identifier: ClassicModelIdentifierType | (DMModelIdentifierType & ClassicModelIdentifierType) | LocalModelIdentifierType, outputFormat?: File3dFormat): ModelIdentifier;

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

@@ -2,6 +2,7 @@
  * Copyright 2021 Cognite AS
  */
 import { ModelIdentifier } from '../ModelIdentifier';
+import { File3dFormat } from '../types';
 /**
  * Identifies a 3D model stored in CDF by the combination of a modelId, a revisionId
  * and a format.
@@ -10,7 +11,8 @@ export declare class CdfModelIdentifier implements ModelIdentifier {
     readonly revealInternalId: symbol;
     readonly modelId: number;
     readonly revisionId: number;
-    constructor(modelId: number, revisionId: number);
+    readonly outputFormat: File3dFormat | undefined;
+    constructor(modelId: number, revisionId: number, outputFormat?: File3dFormat);
     toString(): string;
     /**
      * Returns an identifier in a serialized form, which uniquely identifies

package/dist/packages/data-providers/src/types.d.ts

@@ -110,6 +110,12 @@ export declare enum File3dFormat {
      * Reveal v9 and above (GLTF based output)
      */
     GltfCadModel = "gltf-directory",
+    /**
+     * High-detail geometry for a prioritized subset of nodes.
+     * Same GLTF structure as GltfCadModel but only contains
+     * geometry for nodes specified in a PrioritizedNodes job.
+     */
+    GltfPrioritizedNodes = "gltf-prioritized-nodes-directory",
     AnyFormat = "all-outputs"
 }
 export interface BlobOutputMetadata {

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

@@ -3,6 +3,7 @@
  */
 import { GeometryFilter } from '../../../cad-model';
 import { ClassicModelIdentifierType, InternalDataSourceType, LocalModelIdentifierType } from '../DataSourceType';
+import { File3dFormat } from '../types';
 /**
  * Model options common to all model types.
  */
@@ -15,6 +16,12 @@ export type CommonModelOptions = {
      * An optional geometryFilter which will be applied to loading model.
      */
     geometryFilter?: GeometryFilter;
+    /**
+     * Override which output format to load for this model revision.
+     * Defaults to 'gltf-directory'. Set to 'gltf-prioritized-nodes-directory'
+     * to load high-detail geometry from a PrioritizedNodes job output.
+     */
+    outputFormat?: File3dFormat;
 };
 export type LocalAddModelOptions = CommonModelOptions & LocalModelIdentifierType;
 export type InternalAddModelOptions<T extends InternalDataSourceType> = CommonModelOptions & T['modelIdentifier'];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cognite/reveal",
-  "version": "4.31.2",
+  "version": "4.32.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": {