All files / src/workers parser.worker.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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/*!
 * Copyright 2020 Cognite AS
 */
 
import * as Comlink from 'comlink';
import { ParseSectorResult, ParseCtmResult, ParseQuadsResult, PrimitiveAttributes } from './types/parser.types';
import * as rustTypes from '../../pkg';
const rustModule = import('../../pkg');
 
// TODO see if we can defined this in Rust instead
interface Collection {
  attributes: () => rustTypes.PrimitiveAttributes;
}
 
function collectAttributes(collection: Collection): PrimitiveAttributes {
  // TODO we might need to call free on collection and the attributes
  return {
    f32Attributes: collection.attributes().f32_attributes(),
    f64Attributes: collection.attributes().f64_attributes(),
    u8Attributes: collection.attributes().u8_attributes(),
    vec3Attributes: collection.attributes().vec3_attributes(),
    vec4Attributes: collection.attributes().vec4_attributes(),
    mat4Attributes: collection.attributes().mat4_attributes()
  };
}
 
export class ParserWorker {
  parseSector = async (buffer: Uint8Array): Promise<ParseSectorResult> => {
    const rust = await rustModule;
    const sectorDataHandle = rust.parse_sector(buffer);
    const sectorData = rust.convert_sector(sectorDataHandle);
    const instanceMeshes = (() => {
      const collection = sectorData.instanced_mesh_collection();
      const result = {
        fileIds: collection.file_id().slice(),
        nodeIds: collection.node_id().slice(),
        treeIndices: collection.tree_index().slice(),
        colors: collection.color().slice(),
        triangleOffsets: collection.triangle_offset().slice(),
        triangleCounts: collection.triangle_count().slice(),
        sizes: collection.size().slice(),
        instanceMatrices: collection.instance_matrix().slice()
      };
      collection.free();
      return result;
    })();
    const triangleMeshes = (() => {
      const collection = sectorData.triangle_mesh_collection();
      const result = {
        fileIds: collection.file_id().slice(),
        nodeIds: collection.node_id().slice(),
        treeIndices: collection.tree_index().slice(),
        colors: collection.color().slice(),
        triangleCounts: collection.triangle_count().slice(),
        sizes: collection.size().slice()
      };
      collection.free();
      return result;
    })();
 
    // TODO add instanced meshes
 
    const boxes = collectAttributes(sectorData.box_collection());
    const circles = collectAttributes(sectorData.circle_collection());
    const cones = collectAttributes(sectorData.cone_collection());
    const eccentricCones = collectAttributes(sectorData.eccentric_cone_collection());
    const ellipsoidSegments = collectAttributes(sectorData.ellipsoid_segment_collection());
    const generalCylinders = collectAttributes(sectorData.general_cylinder_collection());
    const generalRings = collectAttributes(sectorData.general_ring_collection());
    const nuts = collectAttributes(sectorData.nut_collection());
    const quads = collectAttributes(sectorData.quad_collection());
    const sphericalSegments = collectAttributes(sectorData.spherical_segment_collection());
    const torusSegments = collectAttributes(sectorData.torus_segment_collection());
    const trapeziums = collectAttributes(sectorData.trapezium_collection());
 
    const parseResult: ParseSectorResult = {
      boxes,
      circles,
      cones,
      eccentricCones,
      ellipsoidSegments,
      generalCylinders,
      generalRings,
      instanceMeshes,
      nuts,
      quads,
      sphericalSegments,
      torusSegments,
      trapeziums,
      triangleMeshes
    };
    sectorDataHandle.free();
    return parseResult;
  };
  parseCtm = async (buffer: Uint8Array): Promise<ParseCtmResult> => {
    const rust = await rustModule;
    // TODO handle parsing failure
    const ctm = rust.parse_ctm(buffer);
    const indices = ctm.indices();
    const vertices = ctm.vertices();
    const normals = ctm.normals();
    const result = {
      indices,
      vertices,
      normals,
      colors: new Float32Array(indices.length),
      treeIndices: new Float32Array(indices.length)
    };
    ctm.free();
    return result;
  };
  parseQuads = async (buffer: Uint8Array): Promise<ParseQuadsResult> => {
    const rust = await rustModule;
    const quads = rust.parse_and_convert_f3df(buffer);
    return {
      data: quads
    };
  };
}
 
const obj = new ParserWorker();
 
Comlink.expose(obj);