@cognite/reveal 2.1.2 → 3.0.0-alpha.0

package/packages/nodes-api/src/NodesApiClient.d.ts

@@ -3,7 +3,10 @@
  */
 import * as THREE from 'three';
 import { CogniteInternalId } from '@cognite/sdk';
-import { NodeTreeIndexAndSubtreeSize } from './types';
+/**
+ * Client for retrieving metadata information about CAD nodes.
+ * @version New since 2.2
+ */
 export interface NodesApiClient {
     /**
      * Maps a set of "tree indexes" that identify nodes, to the respective
@@ -19,7 +22,10 @@ export interface NodesApiClient {
      * Determines tree index and subtreeSize (i.e. span of the subtree a node is parent
      * of) given a set of node IDs.
      */
-    determineTreeIndexAndSubtreeSizesByNodeIds(modelId: CogniteInternalId, revisionId: CogniteInternalId, nodeIds: CogniteInternalId[]): Promise<NodeTreeIndexAndSubtreeSize[]>;
+    determineTreeIndexAndSubtreeSizesByNodeIds(modelId: CogniteInternalId, revisionId: CogniteInternalId, nodeIds: CogniteInternalId[]): Promise<{
+        treeIndex: number;
+        subtreeSize: number;
+    }[]>;
     /**
      * Determine ancestor subtree span of a given node. If the node doesn't have an
      * ancestor at the generation given, the span of the root node is returned.
@@ -28,16 +34,18 @@ export interface NodesApiClient {
      * @param nodeId        Node ID of node
      * @param generation    Generation to retrieve (0 means node itself, 1 is parent, 2 grand-parent etc).
      */
-    determineNodeAncestorsByNodeId(modelId: CogniteInternalId, revisionId: CogniteInternalId, nodeId: CogniteInternalId, generation: number): Promise<NodeTreeIndexAndSubtreeSize>;
+    determineNodeAncestorsByNodeId(modelId: CogniteInternalId, revisionId: CogniteInternalId, nodeId: CogniteInternalId, generation: number): Promise<{
+        treeIndex: number;
+        subtreeSize: number;
+    }>;
     /**
-     * Determines the bounds of the node provided. Note that the returned
-     * box returned will be in "CDF coordinates" and not transformed using
+     * Determines the bounds of the individual nodes provided. Note that the returned
+     * boxes will be in "CDF coordinates" and not transformed using
      * the model transformation for the given model.
      *
      * @param modelId       ID of 3D model
      * @param revisionId    ID of 3D model revision
-     * @param nodeId        Node ID of node
-     * @param box           Pre-allocated THREE.Box3 (optional).
+     * @param nodeIds       Node IDs of nodes
      */
-    getBoundingBoxByNodeId(modelId: CogniteInternalId, revisionId: CogniteInternalId, nodeId: CogniteInternalId, box?: THREE.Box3): Promise<THREE.Box3>;
+    getBoundingBoxesByNodeIds(modelId: CogniteInternalId, revisionId: CogniteInternalId, nodeIds: CogniteInternalId[]): Promise<THREE.Box3[]>;
 }

package/packages/nodes-api/src/NodesCdfClient.d.ts

@@ -4,16 +4,21 @@
 import * as THREE from 'three';
 import { CogniteClient, CogniteInternalId } from '@cognite/sdk';
 import { NodesApiClient } from './NodesApiClient';
-import { NodeTreeIndexAndSubtreeSize } from './types';
 export declare class NodesCdfClient implements NodesApiClient {
     private static readonly MaxItemsPerRequest;
     private readonly _client;
     constructor(client: CogniteClient);
     mapTreeIndicesToNodeIds(modelId: CogniteInternalId, revisionId: CogniteInternalId, treeIndices: number[]): Promise<number[]>;
     mapNodeIdsToTreeIndices(modelId: CogniteInternalId, revisionId: CogniteInternalId, treeIndices: number[]): Promise<CogniteInternalId[]>;
-    determineTreeIndexAndSubtreeSizesByNodeIds(modelId: CogniteInternalId, revisionId: CogniteInternalId, nodeIds: CogniteInternalId[]): Promise<NodeTreeIndexAndSubtreeSize[]>;
-    determineNodeAncestorsByNodeId(modelId: CogniteInternalId, revisionId: CogniteInternalId, nodeId: CogniteInternalId, generation: number): Promise<NodeTreeIndexAndSubtreeSize>;
-    getBoundingBoxByNodeId(modelId: CogniteInternalId, revisionId: CogniteInternalId, nodeId: CogniteInternalId, box?: THREE.Box3): Promise<THREE.Box3>;
+    determineTreeIndexAndSubtreeSizesByNodeIds(modelId: CogniteInternalId, revisionId: CogniteInternalId, nodeIds: CogniteInternalId[]): Promise<{
+        treeIndex: number;
+        subtreeSize: number;
+    }[]>;
+    determineNodeAncestorsByNodeId(modelId: CogniteInternalId, revisionId: CogniteInternalId, nodeId: CogniteInternalId, generation: number): Promise<{
+        treeIndex: number;
+        subtreeSize: number;
+    }>;
+    getBoundingBoxesByNodeIds(modelId: CogniteInternalId, revisionId: CogniteInternalId, nodeIds: CogniteInternalId[]): Promise<THREE.Box3[]>;
     private postByTreeIndicesRequest;
     private postByNodeIdsRequest;
 }

package/packages/nodes-api/src/NodesLocalClient.d.ts

@@ -4,22 +4,27 @@
 import * as THREE from 'three';
 import { NodesApiClient } from './NodesApiClient';
 import { CogniteInternalId } from '@cognite/sdk';
-import { NodeTreeIndexAndSubtreeSize } from './types';
 export declare class NodesLocalClient implements NodesApiClient {
-    constructor(_modelBaseUrl: string);
+    constructor();
     mapTreeIndicesToNodeIds(_modelId: CogniteInternalId, _revisionId: CogniteInternalId, treeIndices: number[]): Promise<CogniteInternalId[]>;
     mapNodeIdsToTreeIndices(_modelId: CogniteInternalId, _revisionId: CogniteInternalId, nodeIds: CogniteInternalId[]): Promise<number[]>;
     /**
      * Determines tree index and subtreeSize (i.e. span of the subtree a node is parent
      * of) given a set of node IDs.
      */
-    determineTreeIndexAndSubtreeSizesByNodeIds(_modelId: CogniteInternalId, _revisionId: CogniteInternalId, _nodeIds: CogniteInternalId[]): Promise<NodeTreeIndexAndSubtreeSize[]>;
+    determineTreeIndexAndSubtreeSizesByNodeIds(_modelId: CogniteInternalId, _revisionId: CogniteInternalId, _nodeIds: CogniteInternalId[]): Promise<{
+        treeIndex: number;
+        subtreeSize: number;
+    }[]>;
     /**
      * Not supported.
      */
-    determineNodeAncestorsByNodeId(_modelId: CogniteInternalId, _revisionId: CogniteInternalId, _nodeId: CogniteInternalId, _generation: number): Promise<NodeTreeIndexAndSubtreeSize>;
+    determineNodeAncestorsByNodeId(_modelId: CogniteInternalId, _revisionId: CogniteInternalId, _nodeId: CogniteInternalId, _generation: number): Promise<{
+        treeIndex: number;
+        subtreeSize: number;
+    }>;
     /**
      * Not supported.
      */
-    getBoundingBoxByNodeId(_modelId: CogniteInternalId, _revisionId: CogniteInternalId, _nodeId: CogniteInternalId, _box?: THREE.Box3): Promise<THREE.Box3>;
+    getBoundingBoxesByNodeIds(_modelId: CogniteInternalId, _revisionId: CogniteInternalId, _nodeIds: CogniteInternalId[]): Promise<THREE.Box3[]>;
 }

package/packages/nodes-api/src/types.d.ts

@@ -8,7 +8,3 @@ export declare type ByTreeIndicesResponse = {
 export declare type ByNodeIdsResponse = {
     items: number[];
 };
-export declare type NodeTreeIndexAndSubtreeSize = {
-    treeIndex: number;
-    subtreeSize: number;
-};

package/packages/rendering/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright 2021 Cognite AS
+ */
+export { SectorQuads } from './src/rendering/types';
+export { CadMaterialManager } from './src/CadMaterialManager';
+export { createSimpleGeometryMesh } from './src/rendering/createSimpleGeometryMesh';
+export { NodeAppearanceTextureBuilder } from './src/rendering/NodeAppearanceTextureBuilder';
+export { NodeTransformTextureBuilder } from './src/transform/NodeTransformTextureBuilder';
+export { NodeTransformProvider } from './src/transform/NodeTransformProvider';
+export { CogniteColors, RevealColors } from './src/utilities/types';
+export { CadNode, SuggestedCameraConfig } from './src/sector/CadNode';
+export { RenderOptions, defaultRenderOptions, SsaoParameters, SsaoSampleQuality, AntiAliasingMode } from './src/rendering/types';
+export { EffectRenderManager } from './src/rendering/EffectRenderManager';
+export { RenderMode } from './src/rendering/RenderMode';
+export { coverageShaders } from './src/rendering/shaders';
+export { Materials, createMaterials } from './src/rendering/materials';
+export { createPrimitives } from './src/rendering/primitives';

package/packages/{cad-geometry-loaders/src/material-manager → rendering/src}/CadMaterialManager.d.ts

@@ -2,11 +2,11 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { NodeAppearance } from '../../../cad-styling';
-import { NodeTransformProvider } from './styling/NodeTransformProvider';
-import { Materials, RenderMode } from '../../../cad-parsers';
-import { NodeAppearanceProvider } from '../../../cad-styling';
-import { IndexSet } from '../../../utilities';
+import { NodeTransformProvider } from './transform/NodeTransformProvider';
+import { Materials } from './rendering/materials';
+import { RenderMode } from './rendering/RenderMode';
+import { NodeAppearance, NodeAppearanceProvider } from '../../cad-styling';
+import { IndexSet } from '../../utilities';
 export declare class CadMaterialManager {
     private readonly _events;
     get clippingPlanes(): THREE.Plane[];

package/packages/rendering/src/GeometryBatchingManager.d.ts

@@ -0,0 +1,30 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { ParsedGeometry } from '../../sector-parser';
+import { Materials } from './rendering/materials';
+export declare class GeometryBatchingManager {
+    private readonly _batchedGeometriesGroup;
+    private readonly _materials;
+    private readonly _instancedTypeMap;
+    private readonly _sectorMap;
+    private static readonly TypedArrayViews;
+    constructor(group: THREE.Group, materials: Materials);
+    batchGeometries(geometryBatchingQueue: ParsedGeometry[], sectorId: number): void;
+    removeSectorBatches(sectorId: number): void;
+    private processGeometries;
+    private updateInstanceAttributes;
+    private extendUpdateRange;
+    private reallocateBufferGeometry;
+    private createSectorBatch;
+    private createInstanceMeshGeometry;
+    private getInstanceAttributesSharedView;
+    private getTreeIndexAttribute;
+    private removeTreeIndicesFromMeshUserData;
+    private createDefragmentedBufferGeometry;
+    private createInstanceMesh;
+    private getAttributes;
+    private copyGeometryWithBufferAttributes;
+    private getShaderMaterial;
+}

package/packages/{cad-geometry-loaders → rendering}/src/InstancedMeshManager.d.ts

@@ -2,8 +2,8 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { CadMaterialManager } from './material-manager/CadMaterialManager';
 import { InstancedMeshFile } from '../../cad-parsers';
+import { CadMaterialManager } from './CadMaterialManager';
 export declare class InstancedMeshManager {
     private readonly _instancedGeometryMap;
     private readonly _instancedAttributeMap;

package/packages/{cad-geometry-loaders/src/material-manager → rendering/src}/rendering/EffectRenderManager.d.ts

@@ -11,7 +11,7 @@ export declare class EffectRenderManager {
     private readonly _compositionScene;
     private readonly _fxaaScene;
     private readonly _ssaoScene;
-    private readonly _ssaoBlurScene;
+    private readonly _ssaoBlurCombineScene;
     private readonly _cadScene;
     private readonly _normalScene;
     private readonly _inFrontScene;
@@ -19,17 +19,17 @@ export declare class EffectRenderManager {
     private readonly _normalSceneBuilder;
     private readonly _inFrontSceneBuilder;
     private _renderOptions;
-    private _combineOutlineDetectionMaterial;
-    private _fxaaMaterial;
+    private readonly _combineOutlineDetectionMaterial;
+    private readonly _fxaaMaterial;
     private _ssaoMaterial;
-    private _ssaoBlurMaterial;
-    private _customObjectRenderTarget;
-    private _ghostObjectRenderTarget;
-    private _normalRenderedCadModelTarget;
-    private _inFrontRenderedCadModelTarget;
-    private _compositionTarget;
-    private _ssaoTarget;
-    private _ssaoBlurTarget;
+    private readonly _ssaoBlurCombineMaterial;
+    private readonly _customObjectRenderTarget;
+    private readonly _ghostObjectRenderTarget;
+    private readonly _normalRenderedCadModelTarget;
+    private readonly _inFrontRenderedCadModelTarget;
+    private readonly _compositionTarget;
+    private readonly _ssaoTarget;
+    private readonly _ssaoBlurCombineTarget;
     /**
      * Holds state of how the last frame was rendered by `render()`. This is used to explicit clear
      * WebGL2 render targets which might cause geometry to "get stuck" after e.g. removing models.
@@ -40,8 +40,11 @@ export declare class EffectRenderManager {
     private readonly _renderer;
     private _renderTarget;
     private _autoSetTargetSize;
+    private _debugRenderTimings;
     private _uiObjects;
     set renderOptions(options: RenderOptions);
+    set debugRenderTimings(logTimings: boolean);
+    get debugRenderTimings(): boolean;
     addUiObject(object: THREE.Object3D, screenPos: THREE.Vector2, size: THREE.Vector2): void;
     removeUiObject(object: THREE.Object3D): void;
     private ssaoParameters;
@@ -70,14 +73,27 @@ export declare class EffectRenderManager {
     private setSsaoParameters;
     private renderPostProcessStep;
     private renderSsao;
+    private renderStep;
+    private readonly _deepFlushRendererArgs;
+    private deepFlushRenderer;
     private createOutlineColorTexture;
     private setupCompositionScene;
     private setupFxaaScene;
     private setupSsaoScene;
     private setupSsaoBlurCombineScene;
-    private createNoiseTexture;
     private createKernel;
     private createRenderTriangle;
     private traverseForRootSectorNode;
     private setVisibilityOfSectors;
+    /**
+     * Assign SpectorJS metadata containing names for the render targets when running Reveal
+     * in development mode.
+     */
+    private setupRenderTargetSpectorDebugging;
+    /**
+     * Assigns SpectorJS metadata to the current framebuffer (render target).
+     * This is useful to assign e.g. names to framebuffers to easy debugging in SpectorJS. The metadata
+     * will be visible in 'bindFramebuffer'-commands in the SpectorJS report.
+     */
+    private assignSpectorJsMetadataToRenderTarget;
 }

package/packages/{cad-geometry-loaders/src/material-manager/styling → rendering/src/rendering}/NodeAppearanceTextureBuilder.d.ts

@@ -2,8 +2,8 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { IndexSet } from '../../../../utilities';
-import { NodeAppearanceProvider, NodeAppearance } from '../../../../cad-styling';
+import { IndexSet } from '../../../utilities';
+import { NodeAppearanceProvider, NodeAppearance } from '../../../cad-styling';
 export declare class NodeAppearanceTextureBuilder {
     private _defaultAppearance;
     private readonly _styleProvider;
@@ -32,11 +32,12 @@ export declare class NodeAppearanceTextureBuilder {
      * A texture holding at least one element per node with color override
      * and style information. RGB is used to store color, A is used to store
      * style toggles, with the following bit layout:
-     * - 0  : visible bit   - when set the node is visible
-     * - 1  : in front bit  - when set the node is rendered in front of other objects
-     * - 2  : ghosted bit   - when set the node is rendered 'ghosted'
-     * - 3-5: outline color - outline toggle and color ({@see OutlineColor}).
-     * - 6-7: unused
+     * - 0  : visible bit         - when set the node is visible
+     * - 1  : in front bit        - when set the node is rendered in front of other objects
+     * - 2  : ghosted bit         - when set the node is rendered 'ghosted'
+     * - 3  : unused
+     * - 4  : unused
+     * - 5-7: outline color - outline toggle and color ({@see OutlineColor}).
      * Note that in-front and ghost information also is available from
      * the {@see inFrontTreeIndices} and {@see ghostedTreeIndices} collections.
      */

package/packages/{cad-geometry-loaders/src/material-manager → rendering/src}/rendering/createSimpleGeometryMesh.d.ts

@@ -2,5 +2,5 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { Materials } from '../../../../cad-parsers';
+import { Materials } from './materials';
 export declare function createSimpleGeometryMesh(attributeValues: Float32Array, materials: Materials, sectorBounds: THREE.Box3, geometryClipBox: THREE.Box3 | null): THREE.Mesh | undefined;

package/packages/{cad-parsers/src/cad → rendering/src/rendering}/primitives.d.ts

@@ -2,10 +2,10 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { Materials } from './materials';
-import { SectorGeometry } from './types';
+import { SectorGeometry } from '../../../cad-parsers';
 import { BoundingBoxLOD } from '../../../utilities';
-export declare function createPrimitives(sector: SectorGeometry, materials: Materials, sectorBounds: THREE.Box3, geometryClipBox?: THREE.Box3 | null): Generator<THREE.Mesh<THREE.BufferGeometry, THREE.Material | THREE.Material[]> | BoundingBoxLOD | THREE.Mesh<THREE.InstancedBufferGeometry, THREE.ShaderMaterial>, void, unknown>;
+import { Materials } from './materials';
+export declare function createPrimitives(sector: SectorGeometry, materials: Materials, sectorBounds: THREE.Box3, geometryClipBox?: THREE.Box3 | null): Generator<THREE.Mesh | BoundingBoxLOD>;
 export declare function determineBoundsFromInstanceMatrices(geometry: THREE.InstancedBufferGeometry): {
     boundingBox: THREE.Box3;
     boundingSphere: THREE.Sphere;

package/packages/{cad-parsers/src/cad → rendering/src/rendering}/shaders.d.ts

@@ -86,7 +86,7 @@ export declare const ssaoShaders: {
     vertex: string;
 };
 /**
- * Shader to blur ambient occlusion texture and combine with diffuse
+ * Full one-pass SSAO blur shader
  */
 export declare const ssaoBlurCombineShaders: {
     fragment: string;

package/packages/{cad-geometry-loaders/src/material-manager → rendering/src}/rendering/types.d.ts

@@ -62,7 +62,7 @@ export declare type EdgeDetectionParameters = {
  */
 export declare type SsaoParameters = {
     /**
-     * Quality (Number of samples) to estimate occlusion factor.
+     * Quality (Number of samples) tond estimate occlusion factor.
      */
     sampleSize: SsaoSampleQuality;
     /**

package/packages/{cad-geometry-loaders/src → rendering/src/sector}/CadNode.d.ts

@@ -1,13 +1,15 @@
-/*!
+/**
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { SectorQuads } from './material-manager/rendering/types';
-import { RootSectorNode } from './sector/RootSectorNode';
-import { CadMaterialManager } from './material-manager/CadMaterialManager';
-import { NodeTransformProvider } from './material-manager/styling/NodeTransformProvider';
-import { SectorScene, CadModelMetadata, RenderMode, SectorGeometry, InstancedMeshFile } from '../../cad-parsers';
-import { NodeAppearanceProvider, NodeAppearance } from '../../cad-styling';
+import { CadMaterialManager } from '../CadMaterialManager';
+import { SectorQuads } from '../rendering/types';
+import { NodeTransformProvider } from '../transform/NodeTransformProvider';
+import { RenderMode } from '../rendering/RenderMode';
+import { NodeAppearanceProvider, NodeAppearance, PrioritizedArea } from '../../../cad-styling';
+import { SectorScene, CadModelMetadata, SectorGeometry, InstancedMeshFile, RootSectorNode, WantedSector, ConsumedSector } from '../../../cad-parsers';
+import { SectorRepository } from '../../../sector-loader';
+import { ParsedGeometry } from '../../../sector-parser';
 export declare type ParseCallbackDelegate = (parsed: {
     lod: string;
     data: SectorGeometry | SectorQuads;
@@ -23,9 +25,10 @@ export declare class CadNode extends THREE.Object3D {
     private readonly _cadModelMetadata;
     private readonly _materialManager;
     private readonly _sectorScene;
-    private readonly _previousCameraMatrix;
     private readonly _instancedMeshManager;
-    constructor(model: CadModelMetadata, materialManager: CadMaterialManager);
+    private readonly _sectorRepository;
+    private readonly _geometryBatchingManager;
+    constructor(model: CadModelMetadata, materialManager: CadMaterialManager, sectorRepository: SectorRepository);
     get nodeTransformProvider(): NodeTransformProvider;
     get nodeAppearanceProvider(): NodeAppearanceProvider;
     get defaultNodeAppearance(): NodeAppearance;
@@ -33,11 +36,13 @@ export declare class CadNode extends THREE.Object3D {
     get clippingPlanes(): THREE.Plane[];
     set clippingPlanes(planes: THREE.Plane[]);
     get cadModelMetadata(): CadModelMetadata;
+    get cadModelIdentifier(): string;
     get sectorScene(): SectorScene;
     get rootSector(): RootSectorNode;
     get materialManager(): CadMaterialManager;
     set renderMode(mode: RenderMode);
     get renderMode(): RenderMode;
+    loadSector(sector: WantedSector): Promise<ConsumedSector>;
     /**
      * Sets transformation matrix of the model. This overrides the current transformation.
      * @param matrix Transformation matrix.
@@ -48,7 +53,11 @@ export declare class CadNode extends THREE.Object3D {
      * @param out Preallocated `THREE.Matrix4` (optional).
      */
     getModelTransformation(out?: THREE.Matrix4): THREE.Matrix4;
+    get prioritizedAreas(): PrioritizedArea[];
     suggestCameraConfig(): SuggestedCameraConfig;
     updateInstancedMeshes(instanceMeshFiles: InstancedMeshFile[], modelIdentifier: string, sectorId: number): void;
     discardInstancedMeshes(sectorId: number): void;
+    batchGeometry(geometryBatchingQueue: ParsedGeometry[], sectorId: number): void;
+    removeBatchedSectorGeometries(sectorId: number): void;
+    clearCache(): void;
 }

package/packages/{cad-geometry-loaders/src/material-manager/styling → rendering/src/transform}/NodeTransformProvider.d.ts

@@ -2,7 +2,7 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { NumericRange } from '../../../../utilities';
+import { NumericRange } from '../../../utilities';
 export declare type NodeTransformChangeEventDelegate = (change: 'set' | 'reset', treeIndices: NumericRange, transform: THREE.Matrix4) => void;
 export declare class NodeTransformProvider {
     private readonly _events;

package/packages/{cad-geometry-loaders/src/material-manager/styling → rendering/src/transform}/NodeTransformTextureBuilder.d.ts

@@ -8,7 +8,7 @@ export declare class NodeTransformTextureBuilder {
     private readonly _transformOverrideBuffer;
     private readonly _transformOverrideIndexTexture;
     private _needsUpdate;
-    private _handleTransformChangedBound;
+    private readonly _handleTransformChangedBound;
     constructor(treeIndexCount: number, transformProvider: NodeTransformProvider);
     dispose(): void;
     get needsUpdate(): boolean;

package/packages/{cad-geometry-loaders/src/material-manager/styling → rendering/src/transform}/TransformOverrideBuffer.d.ts

@@ -8,9 +8,9 @@ export declare class TransformOverrideBuffer {
     private static readonly BYTES_PER_FLOAT;
     private _dataTexture;
     private _textureBuffer;
-    private _unusedIndices;
-    private _treeIndexToOverrideIndex;
-    private _onGenerateNewDataTextureCallback;
+    private readonly _unusedIndices;
+    private readonly _treeIndexToOverrideIndex;
+    private readonly _onGenerateNewDataTextureCallback;
     get dataTexture(): THREE.DataTexture;
     get overrideIndices(): Map<number, number>;
     constructor(onGenerateNewDataTexture: (datatexture: THREE.DataTexture) => void);

package/packages/rendering/src/utilities/types.d.ts

@@ -0,0 +1,26 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+/**
+ * Colors from the Cognite theme.
+ */
+export declare class CogniteColors {
+    static readonly Black: THREE.Color;
+    static readonly White: THREE.Color;
+    static readonly Cyan: THREE.Color;
+    static readonly Blue: THREE.Color;
+    static readonly Purple: THREE.Color;
+    static readonly Pink: THREE.Color;
+    static readonly Orange: THREE.Color;
+    static readonly Yellow: THREE.Color;
+    static readonly VeryLightGray: THREE.Color;
+    static readonly LightGray: THREE.Color;
+}
+/**
+ * Some additional colors to supplement {@link CogniteColors}.
+ */
+export declare class RevealColors {
+    static readonly Red: THREE.Color;
+    static readonly Green: THREE.Color;
+}

package/packages/sector-loader/index.d.ts

@@ -0,0 +1,6 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export { SectorRepository } from './src/SectorRepository';
+export { V8SectorRepository } from './src/V8SectorRepository';
+export { GltfSectorRepository } from './src/GltfSectorRepository';

package/packages/sector-loader/src/GltfSectorRepository.d.ts

@@ -0,0 +1,14 @@
+import { ConsumedSector, WantedSector } from '../../cad-parsers';
+import { BinaryFileProvider } from '../../modeldata-api';
+import { CadMaterialManager } from '../../rendering';
+import { SectorRepository } from '..';
+export declare class GltfSectorRepository implements SectorRepository {
+    private readonly _gltfSectorParser;
+    private readonly _sectorFileProvider;
+    private readonly _materialManager;
+    constructor(sectorFileProvider: BinaryFileProvider, materialManager: CadMaterialManager);
+    loadSector(sector: WantedSector): Promise<ConsumedSector>;
+    private createTreeIndexSet;
+    private createMesh;
+    clear(): void;
+}

package/packages/{cad-geometry-loaders/src/sector/Repository.d.ts → sector-loader/src/SectorRepository.d.ts}

@@ -1,9 +1,9 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-import { ConsumedSector, WantedSector } from '../../../cad-parsers';
+import { ConsumedSector, WantedSector } from '../../cad-parsers';
 export declare type SectorId = number;
-export interface Repository {
+export interface SectorRepository {
     loadSector(sector: WantedSector): Promise<ConsumedSector>;
     clear(): void;
 }

package/packages/{cad-geometry-loaders/src/sector/CachedRepository.d.ts → sector-loader/src/V8SectorRepository.d.ts}

@@ -1,17 +1,17 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-import { CadSectorParser, WantedSector, ConsumedSector } from '../../../cad-parsers';
-import { SimpleAndDetailedToSector3D } from './SimpleAndDetailedToSector3D';
-import { Repository } from './Repository';
-import { BinaryFileProvider } from '../../../modeldata-api';
-export declare class CachedRepository implements Repository {
+import { WantedSector, ConsumedSector } from '../../cad-parsers';
+import { SectorRepository } from './SectorRepository';
+import { BinaryFileProvider } from '../../modeldata-api';
+import { CadMaterialManager } from '../../rendering';
+export declare class V8SectorRepository implements SectorRepository {
     private readonly _consumedSectorCache;
     private readonly _ctmFileCache;
     private readonly _modelSectorProvider;
     private readonly _modelDataParser;
     private readonly _modelDataTransformer;
-    constructor(modelSectorProvider: BinaryFileProvider, modelDataParser: CadSectorParser, modelDataTransformer: SimpleAndDetailedToSector3D);
+    constructor(modelSectorProvider: BinaryFileProvider, materialManager: CadMaterialManager);
     clear(): void;
     loadSector(sector: WantedSector): Promise<ConsumedSector>;
     private loadSimpleSectorFromNetwork;

package/packages/{cad-geometry-loaders/src/sector → sector-loader/src/v8}/SimpleAndDetailedToSector3D.d.ts

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

package/packages/sector-loader/src/v8/sectorUtilities.d.ts

@@ -0,0 +1,16 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { SectorQuads } from '@cognite/reveal-parser-worker';
+import { Materials } from '../../../rendering';
+import { AutoDisposeGroup } from '../../../utilities';
+import { InstancedMeshFile, SectorGeometry, V8SectorMetadata } from '../../../cad-parsers';
+export declare function consumeSectorSimple(sector: SectorQuads, sectorBounds: THREE.Box3, materials: Materials, geometryClipBox: THREE.Box3 | null): {
+    sectorMeshes: AutoDisposeGroup;
+    instancedMeshes: InstancedMeshFile[];
+};
+export declare function consumeSectorDetailed(sector: SectorGeometry, metadata: V8SectorMetadata, materials: Materials, geometryClipBox: THREE.Box3 | null): {
+    sectorMeshes: AutoDisposeGroup;
+    instancedMeshes: InstancedMeshFile[];
+};

package/packages/sector-parser/index.d.ts

@@ -0,0 +1,5 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export { GltfSectorParser } from './src/GltfSectorParser';
+export { RevealGeometryCollectionType, ParsedGeometry } from './src/types';

package/packages/sector-parser/src/GltfSectorParser.d.ts

@@ -0,0 +1,18 @@
+import { GeometryProcessingPayload, ParsedGeometry } from './types';
+export declare class GltfSectorParser {
+    private readonly _glbMetadataParser;
+    private static readonly COLLECTION_TYPE_SIZES;
+    private static readonly DATA_TYPE_BYTE_SIZES;
+    constructor();
+    parseSector(data: ArrayBuffer): ParsedGeometry[];
+    private traverseDefaultSceneNodes;
+    private processNode;
+    processInstancedTriangleMesh(payload: GeometryProcessingPayload): ParsedGeometry;
+    private processPrimitiveCollection;
+    private processTriangleMesh;
+    private setIndexBuffer;
+    private setPositionBuffer;
+    private setInterleavedBufferAttributes;
+    private setAttributes;
+    private getUniqueComponentViews;
+}

package/packages/sector-parser/src/reveal-glb-parser/GlbMetadataParser.d.ts

@@ -0,0 +1,14 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { GlbHeaderData } from '../types';
+export declare class GlbMetadataParser {
+    private readonly _textDecoder;
+    private static readonly GLB_HEADER_BYTE_SIZE;
+    private static readonly CHUNK_HEADER_BYTE_SIZE;
+    constructor();
+    parseGlbMetadata(glbByteData: ArrayBuffer): GlbHeaderData;
+    private verifyGlbHeaders;
+    private parseJson;
+    private parseBinHeaders;
+}