@cognite/reveal 2.0.0-beta.3 → 2.1.2

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

@@ -0,0 +1,28 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { ConsumedSector } from '../../../cad-parsers';
+import { DetermineSectorsInput, SectorLoadingSpent } from './culling/types';
+import { SectorCuller } from './culling/SectorCuller';
+import { ModelStateHandler } from './ModelStateHandler';
+import { Repository } from './Repository';
+/**
+ * Loads sector based on a given camera pose, a set of models and budget.
+ * Uses {@link SectorCuller} to determine what to load, {@link Repository} to
+ * load sectors and {@link ModelStateHandler} to keep track of what has been
+ * loaded to avoid loading data that's already available.
+ *
+ * The caller is responsible for making the result from the load operation visible
+ * on screen.
+ */
+export declare class SectorLoader {
+    private readonly _modelStateHandler;
+    private readonly _sectorCuller;
+    private readonly _sectorRepository;
+    private readonly _progressCallback;
+    private readonly _collectStatisticsCallback;
+    constructor(sectorRepository: Repository, sectorCuller: SectorCuller, modelStateHandler: ModelStateHandler, collectStatisticsCallback: (spent: SectorLoadingSpent) => void, progressCallback: (sectorsLoaded: number, sectorsScheduled: number, sectorsCulled: number) => void);
+    loadSectors(input: DetermineSectorsInput): AsyncIterable<ConsumedSector>;
+    private filterSectors;
+    private startLoadingBatch;
+}

package/{datamodels/cad → packages/cad-geometry-loaders/src}/sector/SectorNode.d.ts

@@ -1,20 +1,21 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-import { AutoDisposeGroup } from '../../../utilities/three';
-import { LevelOfDetail } from './LevelOfDetail';
-export declare class SectorNode extends THREE.Group {
-    readonly sectorId: number;
-    readonly bounds: THREE.Box3;
-    readonly depth: number;
-    private _group?;
-    private _lod;
-    private _updatedTimestamp;
-    constructor(sectorId: number, sectorPath: string, bounds: THREE.Box3);
-    get levelOfDetail(): LevelOfDetail;
-    get group(): THREE.Group | undefined;
-    get updatedTimestamp(): number;
-    updateGeometry(geomtryGroup: AutoDisposeGroup | undefined, levelOfDetail: LevelOfDetail): void;
-    resetGeometry(): void;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { AutoDisposeGroup } from '../../../utilities';
+import { LevelOfDetail } from '../../../cad-parsers';
+export declare class SectorNode extends THREE.Group {
+    readonly sectorPath: string;
+    readonly sectorId: number;
+    readonly bounds: THREE.Box3;
+    readonly depth: number;
+    private _group?;
+    private _lod;
+    private _updatedTimestamp;
+    constructor(sectorId: number, sectorPath: string, bounds: THREE.Box3);
+    get levelOfDetail(): LevelOfDetail;
+    get group(): THREE.Group | undefined;
+    get updatedTimestamp(): number;
+    updateGeometry(geomtryGroup: AutoDisposeGroup | undefined, levelOfDetail: LevelOfDetail): void;
+    resetGeometry(): void;
+}

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

@@ -0,0 +1,20 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { SectorQuads } from '@cognite/reveal-parser-worker';
+import { SectorMetadata, InstancedMeshFile, SectorGeometry } from '../../../cad-parsers';
+import { AutoDisposeGroup } from '../../../utilities';
+import { CadMaterialManager } from '../material-manager/CadMaterialManager';
+export declare class SimpleAndDetailedToSector3D {
+    private readonly materialManager;
+    constructor(materialManager: CadMaterialManager);
+    transformSimpleSector(modelIdentifier: string, sector: SectorMetadata, geometry: SectorQuads, geometryClipBox: THREE.Box3 | null): Promise<{
+        sectorMeshes: AutoDisposeGroup;
+        instancedMeshes: InstancedMeshFile[];
+    }>;
+    transformDetailedSector(modelIdentifier: string, sector: SectorMetadata, geometry: SectorGeometry, geometryClipBox: THREE.Box3 | null): Promise<{
+        sectorMeshes: AutoDisposeGroup;
+        instancedMeshes: InstancedMeshFile[];
+    }>;
+}

package/{datamodels/cad → packages/cad-geometry-loaders/src}/sector/culling/ByVisibilityGpuSectorCuller.d.ts

@@ -1,53 +1,53 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-import { OrderSectorsByVisibilityCoverage } from './OrderSectorsByVisibilityCoverage';
-import { SectorCuller } from './SectorCuller';
-import { DetermineSectorCostDelegate, DetermineSectorsInput, SectorLoadingSpendage } from './types';
-import { WantedSector } from '../types';
-import { OccludingGeometryProvider } from './OccludingGeometryProvider';
-/**
- * Options for creating GpuBasedSectorCuller.
- */
-export declare type ByVisibilityGpuSectorCullerOptions = {
-    /**
-     * Renderer used to determine what sector to load.
-     */
-    renderer: THREE.WebGLRenderer;
-    /**
-     * Optional callback for determining the cost of a sector. The default unit of the cost
-     * function is bytes downloaded.
-     */
-    determineSectorCost?: DetermineSectorCostDelegate;
-    /**
-     * Use a custom coverage utility to determine how "visible" each sector is.
-     */
-    coverageUtil: OrderSectorsByVisibilityCoverage;
-    /**
-     * Logging function for debugging.
-     */
-    logCallback?: (message?: any, ...optionalParameters: any[]) => void;
-};
-/**
- * SectorCuller that uses the GPU to determine an approximation
- * of how "visible" each sector is to get a priority for each sector
- * and loads sectors based on priority within a budget.
- */
-export declare class ByVisibilityGpuSectorCuller implements SectorCuller {
-    private readonly options;
-    private readonly takenSectors;
-    constructor(options: ByVisibilityGpuSectorCullerOptions);
-    dispose(): void;
-    determineSectors(input: DetermineSectorsInput): {
-        wantedSectors: WantedSector[];
-        spendage: SectorLoadingSpendage;
-    };
-    filterSectorsToLoad(input: DetermineSectorsInput, wantedSectors: WantedSector[]): Promise<WantedSector[]>;
-    private update;
-    private addHighDetailsForNearSectors;
-    private testForClippingOcclusion;
-    private markSectorsAsDetailed;
-    private log;
-}
-export declare function createDefaultSectorCuller(renderer: THREE.WebGLRenderer, occludingGeometryProvider: OccludingGeometryProvider): SectorCuller;
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { WantedSector } from '../../../../cad-parsers';
+import { OrderSectorsByVisibilityCoverage } from './OrderSectorsByVisibilityCoverage';
+import { SectorCuller } from './SectorCuller';
+import { DetermineSectorCostDelegate, DetermineSectorsInput, SectorLoadingSpent } from './types';
+import { OccludingGeometryProvider } from './OccludingGeometryProvider';
+/**
+ * Options for creating GpuBasedSectorCuller.
+ */
+export declare type ByVisibilityGpuSectorCullerOptions = {
+    /**
+     * Renderer used to determine what sector to load.
+     */
+    renderer: THREE.WebGLRenderer;
+    /**
+     * Optional callback for determining the cost of a sector. The default unit of the cost
+     * function is bytes downloaded.
+     */
+    determineSectorCost?: DetermineSectorCostDelegate;
+    /**
+     * Use a custom coverage utility to determine how "visible" each sector is.
+     */
+    coverageUtil: OrderSectorsByVisibilityCoverage;
+    /**
+     * Logging function for debugging.
+     */
+    logCallback?: (message?: any, ...optionalParameters: any[]) => void;
+};
+/**
+ * SectorCuller that uses the GPU to determine an approximation
+ * of how "visible" each sector is to get a priority for each sector
+ * and loads sectors based on priority within a budget.
+ */
+export declare class ByVisibilityGpuSectorCuller implements SectorCuller {
+    private readonly options;
+    private readonly takenSectors;
+    constructor(options: ByVisibilityGpuSectorCullerOptions);
+    dispose(): void;
+    determineSectors(input: DetermineSectorsInput): {
+        wantedSectors: WantedSector[];
+        spentBudget: SectorLoadingSpent;
+    };
+    filterSectorsToLoad(input: DetermineSectorsInput, wantedSectors: WantedSector[]): Promise<WantedSector[]>;
+    private update;
+    private addHighDetailsForNearSectors;
+    private testForClippingOcclusion;
+    private markSectorsAsDetailed;
+    private log;
+}
+export declare function createDefaultSectorCuller(renderer: THREE.WebGLRenderer, occludingGeometryProvider: OccludingGeometryProvider): SectorCuller;

package/{datamodels/cad → packages/cad-geometry-loaders/src}/sector/culling/OccludingGeometryProvider.d.ts

@@ -1,6 +1,6 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-export interface OccludingGeometryProvider {
-    renderOccludingGeometry(target: THREE.WebGLRenderTarget | null, camera: THREE.PerspectiveCamera): void;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export interface OccludingGeometryProvider {
+    renderOccludingGeometry(target: THREE.WebGLRenderTarget | null, camera: THREE.PerspectiveCamera): void;
+}

package/{datamodels/cad → packages/cad-geometry-loaders/src}/sector/culling/OrderSectorsByVisibilityCoverage.d.ts

@@ -1,108 +1,107 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-import { WantedSector } from '../types';
-import { CadModelMetadata } from '../../CadModelMetadata';
-import { OccludingGeometryProvider } from './OccludingGeometryProvider';
-/**
- * Options for OrderSectorsByVisibleCoverage.
- */
-export interface OrderSectorsByVisibleCoverageOptions {
-    /**
-     * Renderer used to render coverage.
-     */
-    renderer: THREE.WebGLRenderer;
-    /**
-     * Initializes a render target with already loaded geometry for pre-load
-     * occlusion.
-     */
-    occludingGeometryProvider: OccludingGeometryProvider;
-}
-export declare type PrioritizedSectorIdentifier = {
-    /**
-     * The CAD model that holds the sector.
-     */
-    model: CadModelMetadata;
-    /**
-     * Sector ID contained in the model provided.
-     */
-    sectorId: number;
-    /**
-     * A number between 0 and 1 indicating how 'important' the sector is.
-     */
-    priority: number;
-};
-/**
- * Interface for classes that estimates how visible a sector will be on screen.
- */
-export interface OrderSectorsByVisibilityCoverage {
-    /**
-     * Dispose any resources that cannot be garbage collected.
-     */
-    dispose(): void;
-    /**
-     * Specifies what CAD models to estimate sector visibility for.
-     * @param models Models to estimate sector visibility for.
-     */
-    setModels(models: CadModelMetadata[]): void;
-    /**
-     * Specify clipping planes.
-     * @param planes            A list of clip planes or null to disable clipping.
-     * @param clipIntersection  When true, intersection clipping is enabled.
-     */
-    setClipping(planes: THREE.Plane[] | null, clipIntersection: boolean): void;
-    /**
-     * Cull a set of sectors potentially being loaded towards already loaded geometry to determine if
-     * the sector is visible or occluded.
-     */
-    cullOccludedSectors(camera: THREE.PerspectiveCamera, sectors: WantedSector[]): WantedSector[];
-    /**
-     * Estimates how visible the different sectors for the models added are and returns
-     * a prioritized list.
-     * @param camera The current viewpoint.
-     */
-    orderSectorsByVisibility(camera: THREE.Camera): PrioritizedSectorIdentifier[];
-}
-/**
- * Estimates sector visibility by rendering their bounds with a pattern confirming to how
- * much of the geometry covers of the bounding box.
- */
-export declare class GpuOrderSectorsByVisibilityCoverage implements OrderSectorsByVisibilityCoverage {
-    /**
-     * Factor of how big render target we use for determining visibility of sectors
-     * compared to the full render size.
-     */
-    private static readonly CoverageRenderTargetScalingFactor;
-    private sectorIdOffset;
-    private readonly scene;
-    private readonly _renderer;
-    private readonly _alreadyLoadedProvider;
-    private _debugImageElement?;
-    private readonly renderTarget;
-    private readonly containers;
-    private readonly buffers;
-    private readonly coverageMaterial;
-    constructor(options: OrderSectorsByVisibleCoverageOptions);
-    dispose(): void;
-    get renderer(): THREE.WebGLRenderer;
-    createDebugCanvas(options?: {
-        width: number;
-        height: number;
-    }): HTMLElement;
-    setModels(models: CadModelMetadata[]): void;
-    setClipping(planes: THREE.Plane[] | null, clipIntersection: boolean): void;
-    cullOccludedSectors(camera: THREE.PerspectiveCamera, sectors: WantedSector[]): WantedSector[];
-    orderSectorsByVisibility(camera: THREE.PerspectiveCamera): PrioritizedSectorIdentifier[];
-    private readonly _ensureBuffersCorrectSizeVars;
-    private ensureBuffersCorrectSize;
-    private renderSectors;
-    private setAllSectorsVisible;
-    private setSectorsVisibility;
-    private removeModel;
-    private addModel;
-    private updateModel;
-    private findSectorContainer;
-    private unpackSectorVisibility;
-    private createSectorTreeGeometry;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { CadModelMetadata, WantedSector } from '../../../../cad-parsers';
+import { OccludingGeometryProvider } from './OccludingGeometryProvider';
+/**
+ * Options for OrderSectorsByVisibleCoverage.
+ */
+export interface OrderSectorsByVisibleCoverageOptions {
+    /**
+     * Renderer used to render coverage.
+     */
+    renderer: THREE.WebGLRenderer;
+    /**
+     * Initializes a render target with already loaded geometry for pre-load
+     * occlusion.
+     */
+    occludingGeometryProvider: OccludingGeometryProvider;
+}
+export declare type PrioritizedSectorIdentifier = {
+    /**
+     * The CAD model that holds the sector.
+     */
+    model: CadModelMetadata;
+    /**
+     * Sector ID contained in the model provided.
+     */
+    sectorId: number;
+    /**
+     * A number between 0 and 1 indicating how 'important' the sector is.
+     */
+    priority: number;
+};
+/**
+ * Interface for classes that estimates how visible a sector will be on screen.
+ */
+export interface OrderSectorsByVisibilityCoverage {
+    /**
+     * Dispose any resources that cannot be garbage collected.
+     */
+    dispose(): void;
+    /**
+     * Specifies what CAD models to estimate sector visibility for.
+     * @param models Models to estimate sector visibility for.
+     */
+    setModels(models: CadModelMetadata[]): void;
+    /**
+     * Specify clipping planes.
+     * @param planes            A list of clip planes or null to disable clipping.
+     */
+    setClipping(planes: THREE.Plane[] | null): void;
+    /**
+     * Cull a set of sectors potentially being loaded towards already loaded geometry to determine if
+     * the sector is visible or occluded.
+     */
+    cullOccludedSectors(camera: THREE.PerspectiveCamera, sectors: WantedSector[]): WantedSector[];
+    /**
+     * Estimates how visible the different sectors for the models added are and returns
+     * a prioritized list.
+     * @param camera The current viewpoint.
+     */
+    orderSectorsByVisibility(camera: THREE.Camera): PrioritizedSectorIdentifier[];
+}
+/**
+ * Estimates sector visibility by rendering their bounds with a pattern confirming to how
+ * much of the geometry covers of the bounding box.
+ */
+export declare class GpuOrderSectorsByVisibilityCoverage implements OrderSectorsByVisibilityCoverage {
+    /**
+     * Factor of how big render target we use for determining visibility of sectors
+     * compared to the full render size.
+     */
+    private static readonly CoverageRenderTargetScalingFactor;
+    private sectorIdOffset;
+    private readonly scene;
+    private readonly _renderer;
+    private readonly _alreadyLoadedProvider;
+    private _debugImageElement?;
+    private readonly renderTarget;
+    private readonly containers;
+    private readonly buffers;
+    private readonly coverageMaterial;
+    constructor(options: OrderSectorsByVisibleCoverageOptions);
+    dispose(): void;
+    get renderer(): THREE.WebGLRenderer;
+    createDebugCanvas(options?: {
+        width: number;
+        height: number;
+    }): HTMLElement;
+    setModels(models: CadModelMetadata[]): void;
+    setClipping(planes: THREE.Plane[] | null): void;
+    cullOccludedSectors(camera: THREE.PerspectiveCamera, sectors: WantedSector[]): WantedSector[];
+    orderSectorsByVisibility(camera: THREE.PerspectiveCamera): PrioritizedSectorIdentifier[];
+    private readonly _ensureBuffersCorrectSizeVars;
+    private ensureBuffersCorrectSize;
+    private renderSectors;
+    private setAllSectorsVisible;
+    private setSectorsVisibility;
+    private removeModel;
+    private deleteSectorsFromBuffers;
+    private addModel;
+    private updateModel;
+    private findSectorContainer;
+    private unpackSectorVisibility;
+    private createSectorTreeGeometry;
+}

package/{datamodels/cad → packages/cad-geometry-loaders/src}/sector/culling/SectorCuller.d.ts

@@ -1,33 +1,33 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { DetermineSectorsInput, SectorLoadingSpendage } from './types';
-import { WantedSector } from '../types';
-/**
- * Interface for implementations that are responsible for determining
- * what sectors should be loaded (i.e. "culls" sectors).
- */
-export interface SectorCuller {
-    /**
-     * Determine initial sector prioritization about what we think to load. This provides an initial guesstimate of
-     * what sectors we should load. Use {@link filterSectorsToLoad} to improve this estimate as new data is loaded.
-     * @param input
-     */
-    determineSectors(input: DetermineSectorsInput): {
-        wantedSectors: WantedSector[];
-        spendage: SectorLoadingSpendage;
-    };
-    /**
-     * Evaluates if sectors provided should be loaded or not, e.g. based on geometry we have now loaded
-     * since {@link determineSectors} was called. This can be used to e.g. implement pre-load occlusion culling
-     * of sectors based on geometry that has been loaded.
-     *
-     * @param input Same input as used in {@link determineSectors}.
-     * @param wantedSectorsBatch A set of sectors from {@link determineSectors}, e.g. in batches of 5-10.
-     */
-    filterSectorsToLoad(input: DetermineSectorsInput, wantedSectorsBatch: WantedSector[]): Promise<WantedSector[]>;
-    /**
-     * Dispose all non-GCed resoures held.
-     */
-    dispose(): void;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { WantedSector } from '../../../../cad-parsers';
+import { DetermineSectorsInput, SectorLoadingSpent } from './types';
+/**
+ * Interface for implementations that are responsible for determining
+ * what sectors should be loaded (i.e. "culls" sectors).
+ */
+export interface SectorCuller {
+    /**
+     * Determine initial sector prioritization about what we think to load. This provides an initial guesstimate of
+     * what sectors we should load. Use {@link filterSectorsToLoad} to improve this estimate as new data is loaded.
+     * @param input
+     */
+    determineSectors(input: DetermineSectorsInput): {
+        wantedSectors: WantedSector[];
+        spentBudget: SectorLoadingSpent;
+    };
+    /**
+     * Evaluates if sectors provided should be loaded or not, e.g. based on geometry we have now loaded
+     * since {@link determineSectors} was called. This can be used to e.g. implement pre-load occlusion culling
+     * of sectors based on geometry that has been loaded.
+     *
+     * @param input Same input as used in {@link determineSectors}.
+     * @param wantedSectorsBatch A set of sectors from {@link determineSectors}, e.g. in batches of 5-10.
+     */
+    filterSectorsToLoad(input: DetermineSectorsInput, wantedSectorsBatch: WantedSector[]): Promise<WantedSector[]>;
+    /**
+     * Dispose all non-GCed resoures held.
+     */
+    dispose(): void;
+}

package/{datamodels/cad → packages/cad-geometry-loaders/src}/sector/culling/TakenSectorTree.d.ts

@@ -1,24 +1,24 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { SectorMetadata } from '../types';
-import { PrioritizedWantedSector, DetermineSectorCostDelegate, SectorCost } from './types';
-export declare class TakenSectorTree {
-    get totalCost(): SectorCost;
-    private readonly sectors;
-    private readonly determineSectorCost;
-    private _totalCost;
-    constructor(sectorRoot: SectorMetadata, determineSectorCost: DetermineSectorCostDelegate);
-    determineWantedSectorCount(): number;
-    toWantedSectors(modelBlobUrl: string, geometryClipBox: THREE.Box3 | null): PrioritizedWantedSector[];
-    markSectorDetailed(sectorId: number, priority: number): void;
-    /**
-     * Replaces a Simple sector by marking all its non-detailed children as Simple and
-     * marking the sector itself Detailed.
-     */
-    private replaceSimpleWithDetailed;
-    private markAllDiscardedChildrenAsSimple;
-    private setSectorLod;
-    private setSectorPriority;
-    private getSectorLod;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { SectorMetadata } from '../../../../cad-parsers';
+import { PrioritizedWantedSector, DetermineSectorCostDelegate, SectorCost } from './types';
+export declare class TakenSectorTree {
+    get totalCost(): SectorCost;
+    private readonly sectors;
+    private readonly determineSectorCost;
+    private _totalCost;
+    constructor(sectorRoot: SectorMetadata, determineSectorCost: DetermineSectorCostDelegate);
+    determineWantedSectorCount(): number;
+    toWantedSectors(modelIdentifier: string, modelBaseUrl: string, geometryClipBox: THREE.Box3 | null): PrioritizedWantedSector[];
+    markSectorDetailed(sectorId: number, priority: number): void;
+    /**
+     * Replaces a Simple sector by marking all its non-detailed children as Simple and
+     * marking the sector itself Detailed.
+     */
+    private replaceSimpleWithDetailed;
+    private markAllDiscardedChildrenAsSimple;
+    private setSectorLod;
+    private setSectorPriority;
+    private getSectorLod;
+}