@cognite/reveal 3.0.0-alpha.2 → 3.0.0

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

@@ -1,83 +1,83 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-import { PrioritizedArea } from '../../../../cad-styling';
-import { CadModelMetadata, LevelOfDetail, WantedSector } from '../../../../cad-parsers';
-import { CadLoadingHints } from '../../CadLoadingHints';
-import { CadModelBudget } from '../../CadModelBudget';
-import { CadNode } from '../../../../rendering';
-export interface DetermineSectorsInput {
-    camera: THREE.PerspectiveCamera;
-    clippingPlanes: THREE.Plane[];
-    cadModelsMetadata: CadModelMetadata[];
-    loadingHints: CadLoadingHints;
-    cameraInMotion: boolean;
-    budget: CadModelBudget;
-    prioritizedAreas: PrioritizedArea[];
-}
-export declare type DetermineSectorsPayload = {
-    camera: THREE.PerspectiveCamera;
-    clippingPlanes: THREE.Plane[];
-    models: CadNode[];
-    loadingHints: CadLoadingHints;
-    cameraInMotion: boolean;
-    budget: CadModelBudget;
-    prioritizedAreas: PrioritizedArea[];
-};
-/**
- * Statistics for how much data is required to load set of sectors.
- */
-export declare type SectorLoadingSpent = {
-    /**
-     * Estimated number of bytes to download sectors.
-     */
-    readonly downloadSize: number;
-    /**
-     * Estimated number of draw calls required to draw the sectors.
-     */
-    readonly drawCalls: number;
-    /**
-     * Estimated "render cost" which can be compared to triangle count (but
-     * due to how Reveal renders primitives doesn't map directly to triangles).
-     */
-    readonly renderCost: number;
-    /**
-     * Total number of sectors to load.
-     */
-    readonly loadedSectorCount: number;
-    /**
-     * Number of 'simple' sectors to load.
-     */
-    readonly simpleSectorCount: number;
-    /**
-     * Number of 'detailed' sectors to load.
-     */
-    readonly detailedSectorCount: number;
-    /**
-     * How many sectors that was "forced prioritized".
-     */
-    readonly forcedDetailedSectorCount: number;
-    /**
-     * The total number of sectors in models we are loading.
-     */
-    readonly totalSectorCount: number;
-    /**
-     * How much of the prioritized nodes that are loaded (between 0 and 1).
-     */
-    readonly accumulatedPriority: number;
-};
-export declare type SectorCost = {
-    downloadSize: number;
-    drawCalls: number;
-    renderCost: number;
-};
-export declare function addSectorCost(sum: SectorCost, cost: SectorCost): void;
-export declare function reduceSectorCost(sum: SectorCost, cost: SectorCost): void;
-export declare type PrioritizedWantedSector = WantedSector & {
-    priority: number;
-};
-/**
- * Delegates that computes 'cost' of loading/visualizing a given sector.
- */
-export declare type DetermineSectorCostDelegate<TSectorMetadata> = (sector: TSectorMetadata, levelOfDetail: LevelOfDetail) => SectorCost;
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { PrioritizedArea } from '../../../../cad-styling';
+import { CadModelMetadata, LevelOfDetail, WantedSector } from '../../../../cad-parsers';
+import { CadLoadingHints } from '../../CadLoadingHints';
+import { CadModelBudget } from '../../CadModelBudget';
+import { CadNode } from '../../../../rendering';
+export interface DetermineSectorsInput {
+    camera: THREE.PerspectiveCamera;
+    clippingPlanes: THREE.Plane[];
+    cadModelsMetadata: CadModelMetadata[];
+    loadingHints: CadLoadingHints;
+    cameraInMotion: boolean;
+    budget: CadModelBudget;
+    prioritizedAreas: PrioritizedArea[];
+}
+export declare type DetermineSectorsPayload = {
+    camera: THREE.PerspectiveCamera;
+    clippingPlanes: THREE.Plane[];
+    models: CadNode[];
+    loadingHints: CadLoadingHints;
+    cameraInMotion: boolean;
+    budget: CadModelBudget;
+    prioritizedAreas: PrioritizedArea[];
+};
+/**
+ * Statistics for how much data is required to load set of sectors.
+ */
+export declare type SectorLoadingSpent = {
+    /**
+     * Estimated number of bytes to download sectors.
+     */
+    readonly downloadSize: number;
+    /**
+     * Estimated number of draw calls required to draw the sectors.
+     */
+    readonly drawCalls: number;
+    /**
+     * Estimated "render cost" which can be compared to triangle count (but
+     * due to how Reveal renders primitives doesn't map directly to triangles).
+     */
+    readonly renderCost: number;
+    /**
+     * Total number of sectors to load.
+     */
+    readonly loadedSectorCount: number;
+    /**
+     * Number of 'simple' sectors to load.
+     */
+    readonly simpleSectorCount: number;
+    /**
+     * Number of 'detailed' sectors to load.
+     */
+    readonly detailedSectorCount: number;
+    /**
+     * How many sectors that was "forced prioritized".
+     */
+    readonly forcedDetailedSectorCount: number;
+    /**
+     * The total number of sectors in models we are loading.
+     */
+    readonly totalSectorCount: number;
+    /**
+     * How much of the prioritized nodes that are loaded (between 0 and 1).
+     */
+    readonly accumulatedPriority: number;
+};
+export declare type SectorCost = {
+    downloadSize: number;
+    drawCalls: number;
+    renderCost: number;
+};
+export declare function addSectorCost(sum: SectorCost, cost: SectorCost): void;
+export declare function reduceSectorCost(sum: SectorCost, cost: SectorCost): void;
+export declare type PrioritizedWantedSector = WantedSector & {
+    priority: number;
+};
+/**
+ * Delegates that computes 'cost' of loading/visualizing a given sector.
+ */
+export declare type DetermineSectorCostDelegate<TSectorMetadata> = (sector: TSectorMetadata, levelOfDetail: LevelOfDetail) => SectorCost;

package/packages/cad-geometry-loaders/src/sector/rxSectorUtilities.d.ts

@@ -1,12 +1,12 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { LevelOfDetail } from '../../../cad-parsers';
-import { DetermineSectorsPayload } from './culling/types';
-export declare function loadingEnabled({ models, loadingHints }: DetermineSectorsPayload): boolean;
-export interface ModelState {
-    [id: number]: LevelOfDetail;
-}
-export interface SceneModelState {
-    [modelIdentifier: string]: ModelState;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { LevelOfDetail } from '../../../cad-parsers';
+import { DetermineSectorsPayload } from './culling/types';
+export declare function loadingEnabled({ models, loadingHints }: DetermineSectorsPayload): boolean;
+export interface ModelState {
+    [id: number]: LevelOfDetail;
+}
+export interface SceneModelState {
+    [modelIdentifier: string]: ModelState;
+}

package/packages/cad-geometry-loaders/src/utilities/PromiseUtils.d.ts

@@ -1,28 +1,28 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-/**
- * PromiseResult - Contains the result from a
- * promise together with and indicator of whether the
- * the promise resolved or rejected
- */
-declare type PromiseResult<T> = {
-    result?: T;
-    error?: any;
-};
-/**
- * Extension utilities for Promise.
- */
-export declare class PromiseUtils {
-    /**
-     * Awaits all promises in the list of promises available, returning them in an async iterator
-     * as they finish. The function completes when all promises has completed and the results have
-     * been yielded. Each result is given as a PromiseResult object. This function is similar to
-     * Promise.all(), except that it returns results as they are ready and doesn't wait for all
-     * operations to finish.
-     *
-     * @param promises A list of promises to complete.
-     */
-    static raceUntilAllCompleted<T>(promises: Promise<T>[]): AsyncIterable<PromiseResult<T>>;
-}
-export {};
+/*!
+ * Copyright 2021 Cognite AS
+ */
+/**
+ * PromiseResult - Contains the result from a
+ * promise together with and indicator of whether the
+ * the promise resolved or rejected
+ */
+declare type PromiseResult<T> = {
+    result?: T;
+    error?: any;
+};
+/**
+ * Extension utilities for Promise.
+ */
+export declare class PromiseUtils {
+    /**
+     * Awaits all promises in the list of promises available, returning them in an async iterator
+     * as they finish. The function completes when all promises has completed and the results have
+     * been yielded. Each result is given as a PromiseResult object. This function is similar to
+     * Promise.all(), except that it returns results as they are ready and doesn't wait for all
+     * operations to finish.
+     *
+     * @param promises A list of promises to complete.
+     */
+    static raceUntilAllCompleted<T>(promises: Promise<T>[]): AsyncIterable<PromiseResult<T>>;
+}
+export {};

package/packages/cad-geometry-loaders/src/utilities/rxOperations.d.ts

@@ -1,6 +1,6 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { Observable, OperatorFunction } from 'rxjs';
-export declare function emissionLastMillis(millis: number): OperatorFunction<unknown, boolean>;
-export declare function delayedSwitch(millis: number): Observable<boolean>;
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { Observable, OperatorFunction } from 'rxjs';
+export declare function emissionLastMillis(millis: number): OperatorFunction<unknown, boolean>;
+export declare function delayedSwitch(millis: number): Observable<boolean>;

package/packages/cad-model/index.d.ts

@@ -0,0 +1,12 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+export { CadManager } from './src/CadManager';
+export { GeometryFilter } from './src/GeometryFilter';
+export { CadModelSectorLoadStatistics } from './src/CadModelSectorLoadStatistics';
+export { intersectCadNodes } from './src/picking';
+export { createCadManager } from './src/createCadManager';
+export { BoundingBoxClipper } from './src/BoundingBoxClipper';
+export { InternalRevealCadOptions } from './src/InternalRevealCadOptions';
+export { Cognite3DModel } from './src/Cognite3DModel';
+export { WellKnownUnit } from './src/WellKnownUnit';

package/{core/src/utilities → packages/cad-model/src}/BoundingBoxClipper.d.ts

@@ -1,23 +1,23 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-export declare class BoundingBoxClipper {
-    private readonly _box;
-    private readonly _clippingPlanes;
-    constructor(box?: THREE.Box3);
-    set minX(x: number);
-    get minX(): number;
-    set minY(y: number);
-    get minY(): number;
-    set minZ(z: number);
-    get minZ(): number;
-    set maxX(x: number);
-    get maxX(): number;
-    set maxY(y: number);
-    get maxY(): number;
-    set maxZ(z: number);
-    get maxZ(): number;
-    private updatePlanes;
-    get clippingPlanes(): THREE.Plane[];
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+export declare class BoundingBoxClipper {
+    private readonly _box;
+    private readonly _clippingPlanes;
+    constructor(box?: THREE.Box3);
+    set minX(x: number);
+    get minX(): number;
+    set minY(y: number);
+    get minY(): number;
+    set minZ(z: number);
+    get minZ(): number;
+    set maxX(x: number);
+    get maxX(): number;
+    set maxY(y: number);
+    get maxY(): number;
+    set maxZ(z: number);
+    get maxZ(): number;
+    private updatePlanes;
+    get clippingPlanes(): THREE.Plane[];
+}

package/{core/src/datamodels/cad → packages/cad-model/src}/CadManager.d.ts

@@ -1,43 +1,48 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-import { Observable } from 'rxjs';
-import { CadModelFactory } from './CadModelFactory';
-import { CadModelSectorLoadStatistics } from './CadModelSectorLoadStatistics';
-import { GeometryFilter } from '../../public/types';
-import { CadModelUpdateHandler, CadModelBudget, LoadingState } from '../../../../packages/cad-geometry-loaders';
-import { CadNode, CadMaterialManager, RenderMode } from '../../../../packages/rendering';
-import { ModelIdentifier } from '../../../../packages/modeldata-api';
-export declare class CadManager {
-    private readonly _materialManager;
-    private readonly _cadModelFactory;
-    private readonly _cadModelUpdateHandler;
-    private readonly _cadModelMap;
-    private readonly _subscription;
-    private _needsRedraw;
-    private readonly _markNeedsRedrawBound;
-    private readonly _materialsChangedListener;
-    get materialManager(): CadMaterialManager;
-    get budget(): CadModelBudget;
-    set budget(budget: CadModelBudget);
-    /**
-     * Returns statistics about how data loaded (or data about to be loaded).
-     */
-    get loadedStatistics(): CadModelSectorLoadStatistics;
-    constructor(materialManger: CadMaterialManager, cadModelFactory: CadModelFactory, cadModelUpdateHandler: CadModelUpdateHandler);
-    dispose(): void;
-    requestRedraw(): void;
-    resetRedraw(): void;
-    get needsRedraw(): boolean;
-    updateCamera(camera: THREE.PerspectiveCamera): void;
-    get clippingPlanes(): THREE.Plane[];
-    set clippingPlanes(clippingPlanes: THREE.Plane[]);
-    get renderMode(): RenderMode;
-    set renderMode(renderMode: RenderMode);
-    addModel(modelIdentifier: ModelIdentifier, geometryFilter?: GeometryFilter): Promise<CadNode>;
-    removeModel(model: CadNode): void;
-    getLoadingStateObserver(): Observable<LoadingState>;
-    private markNeedsRedraw;
-    private handleMaterialsChanged;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { Observable } from 'rxjs';
+import { CadModelFactory } from './CadModelFactory';
+import { CadModelSectorLoadStatistics } from './CadModelSectorLoadStatistics';
+import { GeometryFilter } from './GeometryFilter';
+import { CadModelMetadata } from '../../cad-parsers';
+import { CadModelUpdateHandler, CadModelBudget } from '../../cad-geometry-loaders';
+import { LoadingState } from '../../model-base';
+import { CadNode, CadMaterialManager, RenderMode } from '../../rendering';
+import { ModelIdentifier } from '../../modeldata-api';
+export declare class CadManager {
+    private readonly _materialManager;
+    private readonly _cadModelFactory;
+    private readonly _cadModelUpdateHandler;
+    private readonly _cadModelMap;
+    private readonly _subscription;
+    private _compatibleFileFormat;
+    private _needsRedraw;
+    private readonly _markNeedsRedrawBound;
+    private readonly _materialsChangedListener;
+    get materialManager(): CadMaterialManager;
+    get budget(): CadModelBudget;
+    set budget(budget: CadModelBudget);
+    /**
+     * Returns statistics about how data loaded (or data about to be loaded).
+     */
+    get loadedStatistics(): CadModelSectorLoadStatistics;
+    constructor(materialManger: CadMaterialManager, cadModelFactory: CadModelFactory, cadModelUpdateHandler: CadModelUpdateHandler);
+    dispose(): void;
+    requestRedraw(): void;
+    resetRedraw(): void;
+    get needsRedraw(): boolean;
+    updateCamera(camera: THREE.PerspectiveCamera): void;
+    get clippingPlanes(): THREE.Plane[];
+    set clippingPlanes(clippingPlanes: THREE.Plane[]);
+    get renderMode(): RenderMode;
+    set renderMode(renderMode: RenderMode);
+    doesModelHaveCompatibleFormat(modelMetadata: CadModelMetadata): boolean;
+    updateModelCompatibilityFormat(modelMetadata: CadModelMetadata): void;
+    addModel(modelIdentifier: ModelIdentifier, geometryFilter?: GeometryFilter): Promise<CadNode>;
+    removeModel(model: CadNode): void;
+    getLoadingStateObserver(): Observable<LoadingState>;
+    private markNeedsRedraw;
+    private handleMaterialsChanged;
+}

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

@@ -0,0 +1,16 @@
+import { GeometryFilter } from './GeometryFilter';
+import { CadMaterialManager, CadNode } from '../../rendering';
+import { CadModelMetadata } from '../../cad-parsers';
+import { ModelDataProvider, ModelMetadataProvider, ModelIdentifier } from '../../modeldata-api';
+export declare class CadModelFactory {
+    private readonly _materialManager;
+    private readonly _modelDataProvider;
+    private readonly _cadModelMetadataRepository;
+    private _v8SectorRepository;
+    private _gltfSectorRepository;
+    constructor(materialManager: CadMaterialManager, modelMetadataProvider: ModelMetadataProvider, modelDataProvider: ModelDataProvider);
+    loadModelMetadata(externalModelIdentifier: ModelIdentifier): Promise<CadModelMetadata>;
+    createModel(metadata: CadModelMetadata, geometryFilter?: GeometryFilter): Promise<CadNode>;
+    private getSectorRepository;
+    dispose(): void;
+}

package/{core/src/datamodels/cad → packages/cad-model/src}/CadModelSectorLoadStatistics.d.ts

@@ -1,38 +1,38 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-export declare type CadModelSectorLoadStatistics = {
-    /**
-     * Estimated number of bytes to download sectors.
-     */
-    readonly downloadSize: number;
-    /**
-     * Estimated number of draw calls required to draw sectors.
-     */
-    readonly drawCalls: number;
-    /**
-     * Total number of sectors to load.
-     */
-    readonly loadedSectorCount: number;
-    /**
-     * Number of 'simple' sectors to load.
-     */
-    readonly simpleSectorCount: number;
-    /**
-     * Number of 'detailed' sectors to load.
-     */
-    readonly detailedSectorCount: number;
-    /**
-     * How many sectors that was "forced prioritized", e.g.
-     * because they are near the camera.
-     */
-    readonly forcedDetailedSectorCount: number;
-    /**
-     * The total number of sectors in models we are loading.
-     */
-    readonly totalSectorCount: number;
-    /**
-     * How much of the prioritized nodes that are loaded (between 0 and 1).
-     */
-    readonly accumulatedPriority: number;
-};
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export declare type CadModelSectorLoadStatistics = {
+    /**
+     * Estimated number of bytes to download sectors.
+     */
+    readonly downloadSize: number;
+    /**
+     * Estimated number of draw calls required to draw sectors.
+     */
+    readonly drawCalls: number;
+    /**
+     * Total number of sectors to load.
+     */
+    readonly loadedSectorCount: number;
+    /**
+     * Number of 'simple' sectors to load.
+     */
+    readonly simpleSectorCount: number;
+    /**
+     * Number of 'detailed' sectors to load.
+     */
+    readonly detailedSectorCount: number;
+    /**
+     * How many sectors that was "forced prioritized", e.g.
+     * because they are near the camera.
+     */
+    readonly forcedDetailedSectorCount: number;
+    /**
+     * The total number of sectors in models we are loading.
+     */
+    readonly totalSectorCount: number;
+    /**
+     * How much of the prioritized nodes that are loaded (between 0 and 1).
+     */
+    readonly accumulatedPriority: number;
+};