@cognite/reveal 3.0.2 → 3.2.0

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

@@ -1,51 +1,51 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-import { OrderSectorsByVisibilityCoverage } from './OrderSectorsByVisibilityCoverage';
-import { SectorCuller } from './SectorCuller';
-import { DetermineSectorCostDelegate, DetermineSectorsInput, SectorLoadingSpent } from './types';
-import { WantedSector, V8SectorMetadata } from '../../../../cad-parsers';
-/**
- * Options for creating {@link ByVisibilityGpuSectorCuller}.
- */
-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<V8SectorMetadata>;
-    /**
-     * 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;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { OrderSectorsByVisibilityCoverage } from './OrderSectorsByVisibilityCoverage';
+import { SectorCuller } from './SectorCuller';
+import { DetermineSectorCostDelegate, DetermineSectorsInput, SectorLoadingSpent } from './types';
+import { WantedSector, V8SectorMetadata } from '../../../../cad-parsers';
+/**
+ * Options for creating {@link ByVisibilityGpuSectorCuller}.
+ */
+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<V8SectorMetadata>;
+    /**
+     * 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;
+}

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

@@ -1,106 +1,106 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-import { CadModelMetadata, WantedSector } from '../../../../cad-parsers';
-import { EffectRenderManager } from '../../../../rendering';
-/**
- * Options for OrderSectorsByVisibleCoverage.
- */
-export interface OrderSectorsByVisibleCoverageOptions {
-    /**
-     * Renderer used to render coverage.
-     */
-    renderer: THREE.WebGLRenderer;
-    /**
-     * EffectRenderManager used to initialize the RenderAlreadyLoadedGeometryProvider
-     */
-    renderManager: EffectRenderManager;
-}
-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 { CadGeometryRenderModePipelineProvider } from '../../../../rendering';
+/**
+ * Options for OrderSectorsByVisibleCoverage.
+ */
+export interface OrderSectorsByVisibleCoverageOptions {
+    /**
+     * Renderer used to render coverage.
+     */
+    renderer: THREE.WebGLRenderer;
+    /**
+     * GeometryDepthRenderPipeline used to initialize the RenderAlreadyLoadedGeometryProvider
+     */
+    depthOnlyRenderPipeline: CadGeometryRenderModePipelineProvider;
+}
+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/RenderAlreadyLoadedGeometryProvider.d.ts

@@ -1,9 +1,11 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { EffectRenderManager } from '../../../../rendering';
-export declare class RenderAlreadyLoadedGeometryProvider {
-    private readonly _renderManager;
-    constructor(renderManager: EffectRenderManager);
-    renderOccludingGeometry(target: THREE.WebGLRenderTarget | null, camera: THREE.PerspectiveCamera): void;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { CadGeometryRenderModePipelineProvider } from '../../../../rendering';
+export declare class RenderAlreadyLoadedGeometryProvider {
+    private readonly _depthOnlyRenderPipeline;
+    private readonly _basicPipelineExecutor;
+    constructor(renderer: THREE.WebGLRenderer, depthOnlyRenderPipeline: CadGeometryRenderModePipelineProvider);
+    renderOccludingGeometry(target: THREE.WebGLRenderTarget | null, camera: THREE.PerspectiveCamera): void;
+}

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

@@ -1,50 +1,51 @@
-/*!
- * 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;
-}
+/*!
+ * 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);
+    reset(): void;
+    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

@@ -1,12 +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;
+/*!
+ * 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

@@ -1,7 +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;
+/*!
+ * 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

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

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

@@ -1,11 +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;
-}
+/*!
+ * 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

@@ -1,17 +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;
-}
+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;
+}