@cognite/reveal 2.2.2 → 3.0.0-beta.0

package/packages/rendering/src/sector/CadNode.d.ts

@@ -1,54 +1,57 @@
-/**
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-import { CadMaterialManager } from '../CadMaterialManager';
-import { SectorQuads } from '../rendering/types';
-import { NodeTransformProvider } from '../transform/NodeTransformProvider';
-import { RenderMode } from '../rendering/RenderMode';
-import { NodeAppearanceProvider, NodeAppearance } from '../../../cad-styling';
-import { SectorScene, CadModelMetadata, SectorGeometry, InstancedMeshFile, RootSectorNode } from '../../../cad-parsers';
-export declare type ParseCallbackDelegate = (parsed: {
-    lod: string;
-    data: SectorGeometry | SectorQuads;
-}) => void;
-export interface SuggestedCameraConfig {
-    position: THREE.Vector3;
-    target: THREE.Vector3;
-    near: number;
-    far: number;
-}
-export declare class CadNode extends THREE.Object3D {
-    private readonly _rootSector;
-    private readonly _cadModelMetadata;
-    private readonly _materialManager;
-    private readonly _sectorScene;
-    private readonly _previousCameraMatrix;
-    private readonly _instancedMeshManager;
-    constructor(model: CadModelMetadata, materialManager: CadMaterialManager);
-    get nodeTransformProvider(): NodeTransformProvider;
-    get nodeAppearanceProvider(): NodeAppearanceProvider;
-    get defaultNodeAppearance(): NodeAppearance;
-    set defaultNodeAppearance(appearance: NodeAppearance);
-    get clippingPlanes(): THREE.Plane[];
-    set clippingPlanes(planes: THREE.Plane[]);
-    get cadModelMetadata(): CadModelMetadata;
-    get sectorScene(): SectorScene;
-    get rootSector(): RootSectorNode;
-    get materialManager(): CadMaterialManager;
-    set renderMode(mode: RenderMode);
-    get renderMode(): RenderMode;
-    /**
-     * Sets transformation matrix of the model. This overrides the current transformation.
-     * @param matrix Transformation matrix.
-     */
-    setModelTransformation(matrix: THREE.Matrix4): void;
-    /**
-     * Gets transformation matrix of the model
-     * @param out Preallocated `THREE.Matrix4` (optional).
-     */
-    getModelTransformation(out?: THREE.Matrix4): THREE.Matrix4;
-    suggestCameraConfig(): SuggestedCameraConfig;
-    updateInstancedMeshes(instanceMeshFiles: InstancedMeshFile[], modelIdentifier: string, sectorId: number): void;
-    discardInstancedMeshes(sectorId: number): void;
-}
+/**
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+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;
+}) => void;
+export declare class CadNode extends THREE.Object3D {
+    private readonly _rootSector;
+    private readonly _cadModelMetadata;
+    private readonly _materialManager;
+    private readonly _sectorScene;
+    private readonly _instancedMeshManager;
+    private readonly _sectorRepository;
+    private readonly _geometryBatchingManager;
+    constructor(model: CadModelMetadata, materialManager: CadMaterialManager, sectorRepository: SectorRepository);
+    get nodeTransformProvider(): NodeTransformProvider;
+    get nodeAppearanceProvider(): NodeAppearanceProvider;
+    get defaultNodeAppearance(): NodeAppearance;
+    set defaultNodeAppearance(appearance: NodeAppearance);
+    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.
+     */
+    setModelTransformation(matrix: THREE.Matrix4): void;
+    /**
+     * Gets transformation matrix of the model
+     * @param out Preallocated `THREE.Matrix4` (optional).
+     */
+    getModelTransformation(out?: THREE.Matrix4): THREE.Matrix4;
+    get prioritizedAreas(): PrioritizedArea[];
+    updateInstancedMeshes(instanceMeshFiles: InstancedMeshFile[], modelIdentifier: string, sectorId: number): void;
+    discardInstancedMeshes(sectorId: number): void;
+    batchGeometry(geometryBatchingQueue: ParsedGeometry[], sectorId: number): void;
+    removeBatchedSectorGeometries(sectorId: number): void;
+    setCacheSize(sectorCount: number): void;
+    clearCache(): void;
+}

package/packages/rendering/src/transform/NodeTransformProvider.d.ts

@@ -1,13 +1,13 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-import { NumericRange } from '../../../utilities';
-export declare type NodeTransformChangeEventDelegate = (change: 'set' | 'reset', treeIndices: NumericRange, transform: THREE.Matrix4) => void;
-export declare class NodeTransformProvider {
-    private readonly _events;
-    on(event: 'changed', listener: NodeTransformChangeEventDelegate): void;
-    off(event: 'changed', listener: NodeTransformChangeEventDelegate): void;
-    setNodeTransform(treeIndices: NumericRange, transform: THREE.Matrix4): void;
-    resetNodeTransform(treeIndices: NumericRange): void;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { NumericRange } from '../../../utilities';
+export declare type NodeTransformChangeEventDelegate = (change: 'set' | 'reset', treeIndices: NumericRange, transform: THREE.Matrix4) => void;
+export declare class NodeTransformProvider {
+    private readonly _events;
+    on(event: 'changed', listener: NodeTransformChangeEventDelegate): void;
+    off(event: 'changed', listener: NodeTransformChangeEventDelegate): void;
+    setNodeTransform(treeIndices: NumericRange, transform: THREE.Matrix4): void;
+    resetNodeTransform(treeIndices: NumericRange): void;
+}

package/packages/rendering/src/transform/NodeTransformTextureBuilder.d.ts

@@ -1,23 +1,23 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-import { NodeTransformProvider } from './NodeTransformProvider';
-export declare class NodeTransformTextureBuilder {
-    private readonly _transformProvider;
-    private readonly _transformOverrideBuffer;
-    private readonly _transformOverrideIndexTexture;
-    private _needsUpdate;
-    private readonly _handleTransformChangedBound;
-    constructor(treeIndexCount: number, transformProvider: NodeTransformProvider);
-    dispose(): void;
-    get needsUpdate(): boolean;
-    get overrideTransformIndexTexture(): THREE.DataTexture;
-    get transformLookupTexture(): THREE.DataTexture;
-    build(): void;
-    private setNodeTransform;
-    private resetNodeTransform;
-    private setOverrideIndex;
-    private handleNewTransformTexture;
-    private handleTransformChanged;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { NodeTransformProvider } from './NodeTransformProvider';
+export declare class NodeTransformTextureBuilder {
+    private readonly _transformProvider;
+    private readonly _transformOverrideBuffer;
+    private readonly _transformOverrideIndexTexture;
+    private _needsUpdate;
+    private readonly _handleTransformChangedBound;
+    constructor(treeIndexCount: number, transformProvider: NodeTransformProvider);
+    dispose(): void;
+    get needsUpdate(): boolean;
+    get overrideTransformIndexTexture(): THREE.DataTexture;
+    get transformLookupTexture(): THREE.DataTexture;
+    build(): void;
+    private setNodeTransform;
+    private resetNodeTransform;
+    private setOverrideIndex;
+    private handleNewTransformTexture;
+    private handleTransformChanged;
+}

package/packages/rendering/src/transform/TransformOverrideBuffer.d.ts

@@ -1,21 +1,21 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-export declare class TransformOverrideBuffer {
-    private static readonly MIN_NUMBER_OF_TREE_INDICES;
-    private static readonly NUMBER_OF_ELEMENTS_PER_MATRIX;
-    private static readonly BYTES_PER_FLOAT;
-    private _dataTexture;
-    private _textureBuffer;
-    private readonly _unusedIndices;
-    private readonly _treeIndexToOverrideIndex;
-    private readonly _onGenerateNewDataTextureCallback;
-    get dataTexture(): THREE.DataTexture;
-    get overrideIndices(): Map<number, number>;
-    constructor(onGenerateNewDataTexture: (datatexture: THREE.DataTexture) => void);
-    dispose(): void;
-    addOverrideTransform(treeIndex: number, transform: THREE.Matrix4): number;
-    removeOverrideTransform(treeIndex: number): void;
-    private recomputeDataTexture;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+export declare class TransformOverrideBuffer {
+    private static readonly MIN_NUMBER_OF_TREE_INDICES;
+    private static readonly NUMBER_OF_ELEMENTS_PER_MATRIX;
+    private static readonly BYTES_PER_FLOAT;
+    private _dataTexture;
+    private _textureBuffer;
+    private readonly _unusedIndices;
+    private readonly _treeIndexToOverrideIndex;
+    private readonly _onGenerateNewDataTextureCallback;
+    get dataTexture(): THREE.DataTexture;
+    get overrideIndices(): Map<number, number>;
+    constructor(onGenerateNewDataTexture: (datatexture: THREE.DataTexture) => void);
+    dispose(): void;
+    addOverrideTransform(treeIndex: number, transform: THREE.Matrix4): number;
+    removeOverrideTransform(treeIndex: number): void;
+    private recomputeDataTexture;
+}

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

@@ -1,26 +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;
-}
+/*!
+ * 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/GltfSectorLoader.d.ts

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

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

@@ -0,0 +1,19 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { ConsumedSector, WantedSector } from '../../cad-parsers';
+import { BinaryFileProvider } from '../../modeldata-api';
+import { CadMaterialManager } from '../../rendering';
+import { SectorRepository } from './SectorRepository';
+export declare class GltfSectorRepository implements SectorRepository {
+    private readonly _gltfSectorLoader;
+    private readonly _gltfCache;
+    constructor(sectorFileProvider: BinaryFileProvider, materialManager: CadMaterialManager);
+    private getEmptySectorWithLod;
+    private getEmptyDetailedSector;
+    private getEmptyDiscardedSector;
+    loadSector(sector: WantedSector): Promise<ConsumedSector>;
+    setCacheSize(sectorCount: number): void;
+    clearCache(): void;
+    private wantedSectorCacheKey;
+}

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

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

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

@@ -1,25 +1,26 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { SimpleAndDetailedToSector3D } from './SimpleAndDetailedToSector3D';
-import { Repository } from './Repository';
-import { CadSectorParser, WantedSector, ConsumedSector } from '../../../cad-parsers';
-import { BinaryFileProvider } from '../../../modeldata-api';
-export declare class CachedRepository implements Repository {
-    private readonly _consumedSectorCache;
-    private readonly _ctmFileCache;
-    private readonly _modelSectorProvider;
-    private readonly _modelDataParser;
-    private readonly _modelDataTransformer;
-    constructor(modelSectorProvider: BinaryFileProvider, modelDataParser: CadSectorParser, modelDataTransformer: SimpleAndDetailedToSector3D);
-    clear(): void;
-    loadSector(sector: WantedSector): Promise<ConsumedSector>;
-    private loadSimpleSectorFromNetwork;
-    private loadI3DFromNetwork;
-    private loadCtmsFromNetwork;
-    private loadDetailedSectorFromNetwork;
-    private loadCtmFileFromNetwork;
-    private finalizeDetailed;
-    private wantedSectorCacheKey;
-    private ctmFileCacheKey;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+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, materialManager: CadMaterialManager);
+    setCacheSize(sectorCount: number): void;
+    clearCache(): void;
+    loadSector(sector: WantedSector): Promise<ConsumedSector>;
+    private loadSimpleSectorFromNetwork;
+    private loadI3DFromNetwork;
+    private loadCtmsFromNetwork;
+    private loadDetailedSectorFromNetwork;
+    private loadCtmFileFromNetwork;
+    private finalizeDetailed;
+    private wantedSectorCacheKey;
+    private ctmFileCacheKey;
+}

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

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

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

@@ -1,5 +1,5 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-export declare function createOffsets(array: Float64Array): Float64Array;
-export declare function createOffsetsArray(array: number[]): number[];
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export declare function createOffsets(array: Float64Array): Float64Array;
+export declare function createOffsetsArray(array: number[]): number[];

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

@@ -1,8 +1,8 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-export declare function groupMeshesByNumber(id: Float64Array): Generator<{
-    id: number;
-    meshIndices: number[];
-}>;
-export declare function lastIndexOf<T>(sortedArray: T[], value: number, firstSearchIndex: number, elementValueOf: (element: T) => number): number;
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export declare function groupMeshesByNumber(id: Float64Array): Generator<{
+    id: number;
+    meshIndices: number[];
+}>;
+export declare function lastIndexOf<T>(sortedArray: T[], value: number, firstSearchIndex: number, elementValueOf: (element: T) => number): number;

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/DracoDecoderHelper.d.ts

@@ -0,0 +1,32 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import type { Mesh } from 'draco3dgltf';
+import { GltfJson } from './types';
+export declare type VertexBufferDescriptor = {
+    [key: string]: {
+        byteStride: number;
+        byteOffset: number;
+    };
+};
+export declare type MeshGeometryBufferDescriptor = {
+    indexBufferView: Uint16Array | Uint32Array;
+    vertexBufferView: Uint8Array;
+    vertexBufferDescriptor: VertexBufferDescriptor;
+};
+export declare class DracoDecoderHelper {
+    private readonly _dracoDecoderModule;
+    private readonly _dracoDataTypes;
+    constructor();
+    decodeDracoBufferToDracoMesh(dracoMeshBufferView: Int8Array): Promise<Mesh>;
+    decodeDracoMeshToGeometryBuffers(json: GltfJson, dracoMesh: Mesh, dracoAttributes: {
+        [key: string]: number;
+    }, gltfAttributes: {
+        [key: string]: number;
+    }): Promise<MeshGeometryBufferDescriptor>;
+    private decodeVertexBuffer;
+    private computeVertexBufferDescriptor;
+    private getAttributeDescriptors;
+    private decodeIndex;
+    private copyLinearToInterleaved;
+}

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

@@ -0,0 +1,19 @@
+import { ParsedGeometry } from './types';
+export declare class GltfSectorParser {
+    private readonly _glbMetadataParser;
+    private readonly _dracoDecoderHelper;
+    constructor();
+    parseSector(data: ArrayBuffer): Promise<ParsedGeometry[]>;
+    private traverseDefaultSceneNodes;
+    private processNode;
+    private processInstancedTriangleMesh;
+    private processPrimitiveCollection;
+    private processTriangleMesh;
+    private getVertexBuffer;
+    private setIndexBuffer;
+    private setPositionBuffer;
+    private getSharedBufferView;
+    private setInterleavedBufferAttributes;
+    private setAttributes;
+    private getUniqueComponentViews;
+}

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

@@ -0,0 +1,6 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { TypedArrayConstructor } from '../../utilities';
+export declare const COLLECTION_TYPE_SIZES: Map<string, number>;
+export declare const DATA_TYPE_BYTE_SIZES: Map<number, TypedArrayConstructor>;

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;
+}

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

@@ -0,0 +1,12 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { RevealGeometryCollectionType } from '../types';
+export declare function setBoxGeometry(geometry: THREE.BufferGeometry): THREE.Box3;
+export declare function setQuadGeometry(geometry: THREE.BufferGeometry, includeNormal?: boolean): THREE.Box3;
+export declare function setTrapeziumGeometry(geometry: THREE.BufferGeometry): THREE.Box3;
+export declare function setConeGeometry(geometry: THREE.BufferGeometry): THREE.Box3;
+export declare function setTorusGeometry(geometry: THREE.BufferGeometry): THREE.Box3;
+export declare function setNutGeometry(geometry: THREE.BufferGeometry): THREE.Box3;
+export declare function setPrimitiveTopology(primitiveCollectionName: RevealGeometryCollectionType, geometry: THREE.BufferGeometry): void;