All files / src/views/threejs/cad createThreeJsSectorNode.ts

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
 
 
 
 
 
1x
1x
1x
 
1x
1x
1x
1x
1x
1x
 
 
1x
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/*!
 * Copyright 2020 Cognite AS
 */
 
import { Sector, SectorQuads } from '../../../models/cad/types';
import { ConsumeSectorDelegate, DiscardSectorDelegate } from '../../../models/cad/delegates';
import { initializeSectorLoader } from '../../../models/cad/initializeSectorLoader';
import { SectorNode, RootSectorNodeData } from './SectorNode';
import { createSimpleCache } from '../../../models/createCache';
import { CadModel } from '../../../models/cad/CadModel';
import { buildScene } from './buildScene';
import { findSectorMetadata } from '../../../models/cad/findSectorMetadata';
import { consumeSectorDetailed } from './consumeSectorDetailed';
import { discardSector } from './discardSector';
import { consumeSectorSimple } from './consumeSectorSimple';
import { toThreeMatrix4 } from '../utilities';
import { Materials } from './materials';
 
export function createThreeJsSectorNode(model: CadModel, materials: Materials): RootSectorNodeData {
  const { fetchSectorDetailed, fetchSectorSimple, scene, modelTransformation, parseSimple, parseDetailed } = model;
  // Fetch metadata
  const sectorNodeMap = new Map<number, SectorNode>(); // Populated by buildScene() below
 
  const consumeDetailed: ConsumeSectorDelegate<Sector> = (sectorId, sector) => {
    const sectorNode = sectorNodeMap.get(sectorId);
    if (!sectorNode) {
      throw new Error(`Could not find 3D node for sector ${sectorId} - invalid id?`);
    }
 
    const metadata = findSectorMetadata(scene.root, sectorId);
    consumeSectorDetailed(sectorId, sector, metadata, sectorNode, materials);
  };
  const discard: DiscardSectorDelegate = sectorId => {
    const sectorNode = sectorNodeMap.get(sectorId);
    if (!sectorNode) {
      throw new Error(`Could not find 3D node for sector ${sectorId} - invalid id?`);
    }
    discardSector(sectorId, sectorNode);
  };
  const consumeSimple: ConsumeSectorDelegate<SectorQuads> = (sectorId, sector) => {
    const sectorNode = sectorNodeMap.get(sectorId);
    if (!sectorNode) {
      throw new Error(`Could not find 3D node for sector ${sectorId} - invalid id?`);
    }
 
    const metadata = findSectorMetadata(scene.root, sectorId);
    consumeSectorSimple(sectorId, sector, metadata, sectorNode, materials);
  };
 
  const getDetailed = async (sectorId: number) => {
    const data = await fetchSectorDetailed(sectorId);
    return parseDetailed(sectorId, data);
  };
 
  const getSimple = async (sectorId: number) => {
    const data = await fetchSectorSimple(sectorId);
    return parseSimple(sectorId, data);
  };
 
  const getDetailedCache = createSimpleCache(getDetailed);
  const getSimpleCache = createSimpleCache(getSimple);
  const detailedActivator = initializeSectorLoader(getDetailedCache.request, discard, consumeDetailed);
  const simpleActivator = initializeSectorLoader(getSimpleCache.request, discard, consumeSimple);
  const rootSector = new SectorNode(0, '/');
  rootSector.applyMatrix(toThreeMatrix4(modelTransformation.modelMatrix));
  buildScene(scene.root, rootSector, sectorNodeMap);
 
  return {
    rootSector,
    simpleActivator,
    detailedActivator
  };
}