@cognite/reveal 2.2.2 → 3.0.0-beta.0

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

@@ -1,107 +1,107 @@
-/*!
- * 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;
-}
+/*!
+ * 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/packages/cad-geometry-loaders/src/sector/culling/SectorCuller.d.ts

@@ -1,33 +1,33 @@
-/*!
- * 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;
-}
+/*!
+ * 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/packages/cad-geometry-loaders/src/sector/culling/WeightFunctionsHelper.d.ts

@@ -0,0 +1,50 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { SectorMetadata, V9SectorMetadata } from '../../../../cad-parsers';
+import { PrioritizedArea } from '../../../../cad-styling';
+export declare class WeightFunctionsHelper {
+    private readonly _camera;
+    private _minSectorDistance;
+    private _maxSectorDistance;
+    private readonly _modifiedFrustums;
+    constructor(camera: THREE.PerspectiveCamera);
+    addCandidateSectors(sectors: SectorMetadata[], modelMatrix: THREE.Matrix4): void;
+    computeTransformedSectorBounds(sectorBounds: THREE.Box3, modelMatrix: THREE.Matrix4, out: THREE.Box3): void;
+    /**
+     * Computes a weight in range [0-1], where 1 means close to camera and 0 means far away.
+     */
+    computeDistanceToCameraWeight(transformedSectorBounds: THREE.Box3): number;
+    /**
+     * Compute a weight in range [0-1] where 1 means the sector covers the entire screen
+     * and 0 means no coverage.
+     * @param transformedSectorBounds
+     * @returns
+     */
+    computeScreenAreaWeight(transformedSectorBounds: THREE.Box3): number;
+    /**
+     * Compute a weight in range [0-1] based on at what "depths"
+     * in the frustum the sector is placed.
+     * @param transformedSectorBounds
+     */
+    computeFrustumDepthWeight(transformedSectorBounds: THREE.Box3): number;
+    /**
+     * Computes a weight based on placement in sector tree (i.e. prioritize)
+     * sectors right below root sector.
+     * @param sector
+     */
+    computeSectorTreePlacementWeight(sector: V9SectorMetadata): number;
+    /**
+     * Computes a weight based on how large the biggest node within the sector
+     * will be on screen (a number in range [0-1]).
+     */
+    computeMaximumNodeScreenSizeWeight(transformedSectorBounds: THREE.Box3, maxNodeDiagonalLength: number): number;
+    /**
+     * Returns a weight that is the maximum of the extra priority in intersecting prioritized areas.
+     * @param transformedSectorBounds   Bounds of sectors in "Reveal coordinates".
+     * @param prioritizedAreas          Zero or more areas with associated priorities.
+     */
+    computePrioritizedAreaWeight(transformedSectorBounds: THREE.Box3, prioritizedAreas: PrioritizedArea[]): number;
+    private distanceToCamera;
+}

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

@@ -0,0 +1,12 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+/**
+ * Computes area of the box after converting it to NDC space. The returned value will be a number
+ * in range [0, 1].
+ * @param camera
+ * @param box
+ * @returns
+ */
+export declare function computeNdcAreaOfBox(camera: THREE.Camera, box: THREE.Box3): number;

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

@@ -0,0 +1,7 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { SectorCost } from './types';
+import { LevelOfDetail, SectorMetadata } from '../../../../cad-parsers';
+export declare function computeV9SectorCost(sectorMetadata: SectorMetadata, lod: LevelOfDetail): SectorCost;
+export declare function computeV8SectorCost(sectorMetadata: SectorMetadata, lod: LevelOfDetail): SectorCost;

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

@@ -0,0 +1,7 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { SectorCuller } from './SectorCuller';
+import { OccludingGeometryProvider } from './OccludingGeometryProvider';
+export declare function createV8SectorCuller(renderer: THREE.WebGLRenderer, occludingGeometryProvider: OccludingGeometryProvider): SectorCuller;

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

@@ -0,0 +1,11 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { PrioritizedWantedSector, SectorCost, SectorLoadingSpent } from '../types';
+import { CadModelMetadata } from '../../../../../cad-parsers';
+export declare abstract class TakenSectorMapBase {
+    protected abstract get modelsMetadata(): CadModelMetadata[];
+    abstract get totalCost(): SectorCost;
+    abstract collectWantedSectors(): PrioritizedWantedSector[];
+    computeSpentBudget(): SectorLoadingSpent;
+}

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

@@ -0,0 +1,17 @@
+import { PrioritizedWantedSector, DetermineSectorCostDelegate, SectorCost } from '../types';
+import { CadModelBudget } from '../../../CadModelBudget';
+import { TakenSectorMapBase } from './TakenSectorMapBase';
+import { CadModelMetadata, V8SectorMetadata } from '../../../../../cad-parsers';
+export declare class TakenV8SectorMap extends TakenSectorMapBase {
+    private readonly _takenSectorTrees;
+    private readonly determineSectorCost;
+    get totalCost(): SectorCost;
+    get modelsMetadata(): CadModelMetadata[];
+    constructor(determineSectorCost: DetermineSectorCostDelegate<V8SectorMetadata>);
+    initializeScene(modelMetadata: CadModelMetadata): void;
+    getWantedSectorCount(): number;
+    markSectorDetailed(model: CadModelMetadata, sectorId: number, priority: number): void;
+    isWithinBudget(budget: CadModelBudget): boolean;
+    collectWantedSectors(): PrioritizedWantedSector[];
+    clear(): void;
+}

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

@@ -1,24 +1,24 @@
-/*!
- * 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 readonly _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;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { V8SectorMetadata } from '../../../../../cad-parsers';
+import { PrioritizedWantedSector, DetermineSectorCostDelegate, SectorCost } from '../types';
+export declare class TakenV8SectorTree {
+    get totalCost(): SectorCost;
+    private readonly sectors;
+    private readonly determineSectorCost;
+    private readonly _totalCost;
+    constructor(sectorRoot: V8SectorMetadata, determineSectorCost: DetermineSectorCostDelegate<V8SectorMetadata>);
+    getWantedSectorCount(): 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;
+}

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

@@ -0,0 +1,20 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { DetermineSectorCostDelegate, PrioritizedWantedSector, SectorCost } from '../types';
+import { CadModelBudget } from '../../../CadModelBudget';
+import { TakenSectorMapBase } from './TakenSectorMapBase';
+import { CadModelMetadata, V9SectorMetadata } from '../../../../../cad-parsers';
+export declare class TakenV9SectorMap extends TakenSectorMapBase {
+    private readonly determineSectorCost;
+    private readonly _totalCost;
+    private readonly _models;
+    get totalCost(): SectorCost;
+    get modelsMetadata(): CadModelMetadata[];
+    constructor(determineSectorCost: DetermineSectorCostDelegate<V9SectorMetadata>);
+    initializeScene(modelMetadata: CadModelMetadata): void;
+    markSectorDetailed(model: CadModelMetadata, sectorId: number, priority: number): void;
+    isWithinBudget(budget: CadModelBudget): boolean;
+    collectWantedSectors(): PrioritizedWantedSector[];
+    clear(): void;
+}

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

@@ -0,0 +1,5 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export { TakenV9SectorMap } from './TakenV9SectorMap';
+export { TakenV8SectorMap } from './TakenV8SectorMap';

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

@@ -0,0 +1,5 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+export declare function transformBoxToNDC(box: THREE.Box3, camera: THREE.Camera, out?: THREE.Box3): THREE.Box3;

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

@@ -1,71 +1,83 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-import { SectorMetadata, CadModelMetadata, LevelOfDetail, WantedSector } from '../../../../cad-parsers';
-import { CadLoadingHints } from '../../CadLoadingHints';
-import { CadModelSectorBudget } from '../../CadModelSectorBudget';
-export interface DetermineSectorsInput {
-    camera: THREE.PerspectiveCamera;
-    clippingPlanes: THREE.Plane[];
-    cadModelsMetadata: CadModelMetadata[];
-    loadingHints: CadLoadingHints;
-    cameraInMotion: boolean;
-    budget: CadModelSectorBudget;
-}
-/**
- * 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 = (sector: SectorMetadata, 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;