@shapediver/viewer.data-engine.geometry-engine 2.9.10 → 2.10.0

package/dist/gltfv1/SDGTFLoader.js

@@ -1,4 +1,3 @@
-"use strict";
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -8,18 +7,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SDGTFLoader = void 0;
-const viewer_shared_node_tree_1 = require("@shapediver/viewer.shared.node-tree");
-const viewer_shared_services_1 = require("@shapediver/viewer.shared.services");
-const viewer_data_engine_shared_types_1 = require("@shapediver/viewer.data-engine.shared-types");
-const viewer_shared_types_1 = require("@shapediver/viewer.shared.types");
-const gl_matrix_1 = require("gl-matrix");
-class SDGTFLoader {
+import { TreeNode } from '@shapediver/viewer.shared.node-tree';
+import { Logger, ShapeDiverViewerDataProcessingError } from '@shapediver/viewer.shared.services';
+import { ACCESSORCOMPONENTTYPE_V1 as ACCESSOR_COMPONENTTYPE, ACCESSORTYPE_V1 as ACCESSORTYPE, } from '@shapediver/viewer.data-engine.shared-types';
+import { AttributeData, GeometryData, PRIMITIVE_MODE, PrimitiveData, } from '@shapediver/viewer.shared.types';
+import { mat4, vec3, vec4 } from 'gl-matrix';
+export class SDGTFLoader {
     constructor() {
         // #region Properties (5)
         this.BINARY_EXTENSION_HEADER_LENGTH = 20;
-        this._logger = viewer_shared_services_1.Logger.instance;
+        this._logger = Logger.instance;
         // #endregion Private Methods (6)
     }
     // #endregion Properties (5)
@@ -36,7 +33,7 @@ class SDGTFLoader {
                     contentFormat: headerDataView.getUint32(17, true)
                 };
                 if (header.magic != 'sdgTF')
-                    throw new viewer_shared_services_1.ShapeDiverViewerDataProcessingError('SDGTFLoader.load: Invalid data: sdgTF magic wrong.');
+                    throw new ShapeDiverViewerDataProcessingError('SDGTFLoader.load: Invalid data: sdgTF magic wrong.');
                 // create content
                 const contentDataView = new DataView(binaryGeometry, gltfLength + this.BINARY_EXTENSION_HEADER_LENGTH + 1, header.contentLength);
                 const contentDecoded = new TextDecoder().decode(contentDataView);
@@ -44,7 +41,7 @@ class SDGTFLoader {
                 this._body = binaryGeometry.slice(gltfLength + this.BINARY_EXTENSION_HEADER_LENGTH + 1 + header.contentLength, gltfLength + header.length);
             }
             else {
-                return new viewer_shared_node_tree_1.TreeNode();
+                return new TreeNode();
             }
             return yield this.loadScene();
         });
@@ -69,12 +66,12 @@ class SDGTFLoader {
                 throw new Error('Accessor not available.');
             const accessor = this._content.accessors[accessorName];
             const bufferView = this._body;
-            const itemSize = viewer_data_engine_shared_types_1.ACCESSORTYPE_V1[accessor.type];
-            const ArrayType = viewer_data_engine_shared_types_1.ACCESSORCOMPONENTTYPE_V1[accessor.componentType];
+            const itemSize = ACCESSORTYPE[accessor.type];
+            const ArrayType = ACCESSOR_COMPONENTTYPE[accessor.componentType];
             const elementBytes = ArrayType.BYTES_PER_ELEMENT;
             const itemBytes = elementBytes * itemSize;
             const byteOffset = accessor.byteOffset || 0;
-            return new viewer_shared_types_1.AttributeData(new ArrayType(bufferView, byteOffset, itemSize * accessor.count), itemSize, itemBytes, byteOffset, elementBytes, false, accessor.count);
+            return new AttributeData(new ArrayType(bufferView, byteOffset, itemSize * accessor.count), itemSize, itemBytes, byteOffset, elementBytes, false, accessor.count);
         });
     }
     loadArcs() {
@@ -82,22 +79,22 @@ class SDGTFLoader {
             if (!this._content.arcs)
                 throw new Error('Arcs not available.');
             const arc = this._content.arcs;
-            const arcNode = new viewer_shared_node_tree_1.TreeNode('arcs');
+            const arcNode = new TreeNode('arcs');
             const data = yield this.loadAccessor(arc.attributes['ARCS']);
             // data with an absolute classic array of Vec12s ...
             // like you usually have it in any good program
             // not 4 Vec3s, no, that would be to logic, but a Vec12 instead
             const count = data.array.length / data.itemSize;
             for (let i = 0; i < count; ++i) {
-                const singleArcNode = new viewer_shared_node_tree_1.TreeNode('arc_' + i);
+                const singleArcNode = new TreeNode('arc_' + i);
                 const index = i * 12;
-                const arcCenter = gl_matrix_1.vec3.fromValues(data.array[index + 0], data.array[index + 1], data.array[index + 2]);
-                const arcXAxis = gl_matrix_1.vec3.fromValues(data.array[index + 3], data.array[index + 4], data.array[index + 5]);
-                const arcYAxis = gl_matrix_1.vec3.fromValues(data.array[index + 6], data.array[index + 7], data.array[index + 8]);
+                const arcCenter = vec3.fromValues(data.array[index + 0], data.array[index + 1], data.array[index + 2]);
+                const arcXAxis = vec3.fromValues(data.array[index + 3], data.array[index + 4], data.array[index + 5]);
+                const arcYAxis = vec3.fromValues(data.array[index + 6], data.array[index + 7], data.array[index + 8]);
                 const arcRadius = data.array[index + 9];
                 const arcMinAngle = data.array[index + 10];
                 const arcMaxAngle = data.array[index + 11];
-                const arcZAxis = gl_matrix_1.vec3.cross(gl_matrix_1.vec3.create(), arcXAxis, arcYAxis);
+                const arcZAxis = vec3.cross(vec3.create(), arcXAxis, arcYAxis);
                 if (arcRadius <= 0) {
                     this._logger.warn('SDGTFLoader.loadArcs: Arc radius is <= 0.');
                     continue;
@@ -123,14 +120,14 @@ class SDGTFLoader {
                     getPointOnArc(d / numberOfPoints);
                 const array = new Float32Array(points);
                 const attributes = {};
-                attributes['POSITION'] = new viewer_shared_types_1.AttributeData(array, 3, 0, 0, 0, false, array.length / 3);
-                const geometry = new viewer_shared_types_1.GeometryData(new viewer_shared_types_1.PrimitiveData(attributes, null), viewer_shared_types_1.PRIMITIVE_MODE.LINE_STRIP);
+                attributes['POSITION'] = new AttributeData(array, 3, 0, 0, 0, false, array.length / 3);
+                const geometry = new GeometryData(new PrimitiveData(attributes, null), PRIMITIVE_MODE.LINE_STRIP);
                 singleArcNode.data.push(geometry);
                 singleArcNode.addTransformation({
                     id: 'arc_' + i + '_translation',
-                    matrix: gl_matrix_1.mat4.translate(gl_matrix_1.mat4.create(), gl_matrix_1.mat4.create(), gl_matrix_1.vec3.fromValues(arcCenter[0], arcCenter[1], arcCenter[2]))
+                    matrix: mat4.translate(mat4.create(), mat4.create(), vec3.fromValues(arcCenter[0], arcCenter[1], arcCenter[2]))
                 });
-                const arcRotationMatrix = gl_matrix_1.mat4.transpose(gl_matrix_1.mat4.create(), gl_matrix_1.mat4.fromValues(arcXAxis[0], arcYAxis[0], arcZAxis[0], 0, arcXAxis[1], arcYAxis[1], arcZAxis[1], 0, arcXAxis[2], arcYAxis[2], arcZAxis[2], 0, 0, 0, 0, 1));
+                const arcRotationMatrix = mat4.transpose(mat4.create(), mat4.fromValues(arcXAxis[0], arcYAxis[0], arcZAxis[0], 0, arcXAxis[1], arcYAxis[1], arcZAxis[1], 0, arcXAxis[2], arcYAxis[2], arcZAxis[2], 0, 0, 0, 0, 1));
                 singleArcNode.addTransformation({
                     id: 'arc_' + i + '_rotation',
                     matrix: arcRotationMatrix
@@ -145,11 +142,11 @@ class SDGTFLoader {
             if (!this._content.beziercurves[beziercurveName])
                 throw new Error('Beziercurve not available.');
             const beziercurve = this._content.beziercurves[beziercurveName];
-            const beziercurveNode = new viewer_shared_node_tree_1.TreeNode(beziercurveName);
+            const beziercurveNode = new TreeNode(beziercurveName);
             const controlPointsData = yield this.loadAccessor(beziercurve.attributes['CONTROLPOINTS']); // vec3
             const controlPoints = [];
             for (let i = 0; i < controlPointsData.array.length; i += 3)
-                controlPoints.push(gl_matrix_1.vec4.fromValues(controlPointsData.array[i], controlPointsData.array[i + 1], controlPointsData.array[i + 2], 1));
+                controlPoints.push(vec4.fromValues(controlPointsData.array[i], controlPointsData.array[i + 1], controlPointsData.array[i + 2], 1));
             const knotsData = yield this.loadAccessor(beziercurve.attributes['KNOTS']); // scalar
             const knots = [knotsData.array[0]];
             for (let i = 0; i < knotsData.array.length; i++)
@@ -199,12 +196,12 @@ class SDGTFLoader {
             const calcBSplinePoint = (u) => {
                 const span = findSpan(u);
                 const N = calcBasisFunctions(span, u);
-                const C = gl_matrix_1.vec4.create();
+                const C = vec4.create();
                 for (let j = 0; j <= degree; ++j) {
                     const point = controlPoints[span - degree + j];
                     const Nj = N[j];
                     const wNj = point[3] * Nj;
-                    gl_matrix_1.vec4.add(C, C, gl_matrix_1.vec4.fromValues(point[0] * wNj, point[1] * wNj, point[2] * wNj, point[3] * Nj));
+                    vec4.add(C, C, vec4.fromValues(point[0] * wNj, point[1] * wNj, point[2] * wNj, point[3] * Nj));
                 }
                 return C;
             };
@@ -215,7 +212,7 @@ class SDGTFLoader {
                 let hpoint = calcBSplinePoint(u);
                 if (hpoint[3] !== 1.0) {
                     // project to 3D space: (wx, wy, wz, w) -> (x, y, z, 1)
-                    hpoint = gl_matrix_1.vec4.divide(gl_matrix_1.vec4.create(), hpoint, gl_matrix_1.vec4.fromValues(hpoint[3], hpoint[3], hpoint[3], hpoint[3]));
+                    hpoint = vec4.divide(vec4.create(), hpoint, vec4.fromValues(hpoint[3], hpoint[3], hpoint[3], hpoint[3]));
                 }
                 points.push(hpoint[0], hpoint[1], hpoint[2]);
             };
@@ -223,14 +220,14 @@ class SDGTFLoader {
             // We go through the control points, measure the distance
             let distance = 0;
             for (let i = 1; i < controlPoints.length; i++)
-                distance += gl_matrix_1.vec3.distance(gl_matrix_1.vec3.fromValues(controlPoints[i - 1][0], controlPoints[i - 1][1], controlPoints[i - 1][2]), gl_matrix_1.vec3.fromValues(controlPoints[i][0], controlPoints[i][1], controlPoints[i][2]));
+                distance += vec3.distance(vec3.fromValues(controlPoints[i - 1][0], controlPoints[i - 1][1], controlPoints[i - 1][2]), vec3.fromValues(controlPoints[i][0], controlPoints[i][1], controlPoints[i][2]));
             const numberOfPoints = Math.min(100, Math.max(25, Math.floor(distance / 0.1)));
             for (let d = 0; d <= numberOfPoints; d++)
                 getPointOnBezierCurve(d / numberOfPoints);
             const array = new Float32Array(points);
             const attributes = {};
-            attributes['POSITION'] = new viewer_shared_types_1.AttributeData(array, 3, 0, 0, 0, false, array.length / 3);
-            const geometry = new viewer_shared_types_1.GeometryData(new viewer_shared_types_1.PrimitiveData(attributes, null), viewer_shared_types_1.PRIMITIVE_MODE.LINE_STRIP);
+            attributes['POSITION'] = new AttributeData(array, 3, 0, 0, 0, false, array.length / 3);
+            const geometry = new GeometryData(new PrimitiveData(attributes, null), PRIMITIVE_MODE.LINE_STRIP);
             beziercurveNode.data.push(geometry);
             return beziercurveNode;
         });
@@ -240,17 +237,17 @@ class SDGTFLoader {
             if (!this._content.circles)
                 throw new Error('Circles not available.');
             const circle = this._content.circles;
-            const circleNode = new viewer_shared_node_tree_1.TreeNode('circles');
+            const circleNode = new TreeNode('circles');
             const data = yield this.loadAccessor(circle.attributes['CIRCLES']);
             const count = data.array.length / data.itemSize;
             for (let i = 0; i < count; i++) {
-                const singleCircleNode = new viewer_shared_node_tree_1.TreeNode('circle_' + i);
+                const singleCircleNode = new TreeNode('circle_' + i);
                 const index = i * 10;
-                const circleCenter = gl_matrix_1.vec3.fromValues(data.array[index + 0], data.array[index + 1], data.array[index + 2]);
-                const circleXAxis = gl_matrix_1.vec3.fromValues(data.array[index + 3], data.array[index + 4], data.array[index + 5]);
-                const circleYAxis = gl_matrix_1.vec3.fromValues(data.array[index + 6], data.array[index + 7], data.array[index + 8]);
+                const circleCenter = vec3.fromValues(data.array[index + 0], data.array[index + 1], data.array[index + 2]);
+                const circleXAxis = vec3.fromValues(data.array[index + 3], data.array[index + 4], data.array[index + 5]);
+                const circleYAxis = vec3.fromValues(data.array[index + 6], data.array[index + 7], data.array[index + 8]);
                 const circleRadius = data.array[index + 9];
-                const circleZAxis = gl_matrix_1.vec3.cross(gl_matrix_1.vec3.create(), circleXAxis, circleYAxis);
+                const circleZAxis = vec3.cross(vec3.create(), circleXAxis, circleYAxis);
                 if (circleRadius <= 0) {
                     this._logger.warn('SDGTFLoader.loadCircles: Circle radius is <= 0.');
                     continue;
@@ -276,14 +273,14 @@ class SDGTFLoader {
                     getPointOnArc(d / numberOfPoints);
                 const array = new Float32Array(points);
                 const attributes = {};
-                attributes['POSITION'] = new viewer_shared_types_1.AttributeData(array, 3, 0, 0, 0, false, array.length / 3);
-                const geometry = new viewer_shared_types_1.GeometryData(new viewer_shared_types_1.PrimitiveData(attributes, null), viewer_shared_types_1.PRIMITIVE_MODE.LINE_STRIP);
+                attributes['POSITION'] = new AttributeData(array, 3, 0, 0, 0, false, array.length / 3);
+                const geometry = new GeometryData(new PrimitiveData(attributes, null), PRIMITIVE_MODE.LINE_STRIP);
                 singleCircleNode.data.push(geometry);
                 singleCircleNode.addTransformation({
                     id: 'circle_' + i + '_translation',
-                    matrix: gl_matrix_1.mat4.translate(gl_matrix_1.mat4.create(), gl_matrix_1.mat4.create(), gl_matrix_1.vec3.fromValues(circleCenter[0], circleCenter[1], circleCenter[2]))
+                    matrix: mat4.translate(mat4.create(), mat4.create(), vec3.fromValues(circleCenter[0], circleCenter[1], circleCenter[2]))
                 });
-                const circleRotationMatrix = gl_matrix_1.mat4.transpose(gl_matrix_1.mat4.create(), gl_matrix_1.mat4.fromValues(circleXAxis[0], circleYAxis[0], circleZAxis[0], 0, circleXAxis[1], circleYAxis[1], circleZAxis[1], 0, circleXAxis[2], circleYAxis[2], circleZAxis[2], 0, 0, 0, 0, 1));
+                const circleRotationMatrix = mat4.transpose(mat4.create(), mat4.fromValues(circleXAxis[0], circleYAxis[0], circleZAxis[0], 0, circleXAxis[1], circleYAxis[1], circleZAxis[1], 0, circleXAxis[2], circleYAxis[2], circleZAxis[2], 0, 0, 0, 0, 1));
                 singleCircleNode.addTransformation({
                     id: 'circle_' + i + '_rotation',
                     matrix: circleRotationMatrix
@@ -298,29 +295,29 @@ class SDGTFLoader {
             if (!this._content.cylinders)
                 throw new Error('Cylinders not available.');
             const cylinder = this._content.cylinders;
-            const cylinderNode = new viewer_shared_node_tree_1.TreeNode('cylinders');
+            const cylinderNode = new TreeNode('cylinders');
             const data = yield this.loadAccessor(cylinder.attributes['CYLINDERS']);
             const count = data.array.length / data.itemSize;
             for (let i = 0; i < count; i++) {
-                const singleCylinderNode = new viewer_shared_node_tree_1.TreeNode('cylinder_' + i);
+                const singleCylinderNode = new TreeNode('cylinder_' + i);
                 const index = i * 7;
-                const cylinderTop = gl_matrix_1.vec3.fromValues(data.array[index + 0], data.array[index + 1], data.array[index + 2]);
-                const cylinderBottom = gl_matrix_1.vec3.fromValues(data.array[index + 3], data.array[index + 4], data.array[index + 5]);
+                const cylinderTop = vec3.fromValues(data.array[index + 0], data.array[index + 1], data.array[index + 2]);
+                const cylinderBottom = vec3.fromValues(data.array[index + 3], data.array[index + 4], data.array[index + 5]);
                 const cylinderRadius = data.array[index + 6];
-                const cylinderAxis = gl_matrix_1.vec3.sub(gl_matrix_1.vec3.create(), cylinderTop, cylinderBottom);
-                const dotX = Math.abs(gl_matrix_1.vec3.dot(cylinderAxis, gl_matrix_1.vec3.fromValues(1, 0, 0)));
-                const dotY = Math.abs(gl_matrix_1.vec3.dot(cylinderAxis, gl_matrix_1.vec3.fromValues(0, 1, 0)));
+                const cylinderAxis = vec3.sub(vec3.create(), cylinderTop, cylinderBottom);
+                const dotX = Math.abs(vec3.dot(cylinderAxis, vec3.fromValues(1, 0, 0)));
+                const dotY = Math.abs(vec3.dot(cylinderAxis, vec3.fromValues(0, 1, 0)));
                 let cylinderXAxis;
                 if (dotX < dotY) {
-                    cylinderXAxis = gl_matrix_1.vec3.cross(gl_matrix_1.vec3.create(), cylinderAxis, gl_matrix_1.vec3.fromValues(1, 0, 0));
+                    cylinderXAxis = vec3.cross(vec3.create(), cylinderAxis, vec3.fromValues(1, 0, 0));
                 }
                 else {
-                    cylinderXAxis = gl_matrix_1.vec3.cross(gl_matrix_1.vec3.create(), cylinderAxis, gl_matrix_1.vec3.fromValues(0, 1, 0));
+                    cylinderXAxis = vec3.cross(vec3.create(), cylinderAxis, vec3.fromValues(0, 1, 0));
                 }
-                const cylinderYAxis = gl_matrix_1.vec3.cross(gl_matrix_1.vec3.create(), cylinderAxis, cylinderXAxis);
-                gl_matrix_1.vec3.normalize(cylinderAxis, cylinderAxis);
-                gl_matrix_1.vec3.normalize(cylinderXAxis, cylinderXAxis);
-                gl_matrix_1.vec3.normalize(cylinderYAxis, cylinderYAxis);
+                const cylinderYAxis = vec3.cross(vec3.create(), cylinderAxis, cylinderXAxis);
+                vec3.normalize(cylinderAxis, cylinderAxis);
+                vec3.normalize(cylinderXAxis, cylinderXAxis);
+                vec3.normalize(cylinderYAxis, cylinderYAxis);
                 if (cylinderRadius <= 0) {
                     this._logger.warn('SDGTFLoader.loadCylinders: Cylinder radius is <= 0.');
                     continue;
@@ -329,14 +326,14 @@ class SDGTFLoader {
                 const vertices = [];
                 const normals = [];
                 const uvs = [];
-                const height = gl_matrix_1.vec3.distance(cylinderTop, cylinderBottom);
+                const height = vec3.distance(cylinderTop, cylinderBottom);
                 const halfHeight = height / 2;
                 const thetaStart = 0, thetaLength = Math.PI * 2;
                 let indexCounter = 0;
                 const indexArray = [];
                 const heightSegments = 1, radialSegments = 50;
-                const normal = gl_matrix_1.vec3.create();
-                const vertex = gl_matrix_1.vec3.create();
+                const normal = vec3.create();
+                const vertex = vec3.create();
                 let groupCount = 0;
                 // this will be used to calculate the normal
                 const slope = 0;
@@ -357,7 +354,7 @@ class SDGTFLoader {
                         vertex[2] = radius * cosTheta;
                         vertices.push(vertex[0], vertex[1], vertex[2]);
                         // normal
-                        gl_matrix_1.vec3.normalize(normal, gl_matrix_1.vec3.fromValues(sinTheta, slope, cosTheta));
+                        vec3.normalize(normal, vec3.fromValues(sinTheta, slope, cosTheta));
                         normals.push(normal[0], normal[1], normal[2]);
                         // uv
                         uvs.push(u, 1 - v);
@@ -383,27 +380,27 @@ class SDGTFLoader {
                     }
                 }
                 const attributes = {};
-                attributes['POSITION'] = new viewer_shared_types_1.AttributeData(new Float32Array(vertices), 3, 0, 0, 0, false, vertices.length / 3);
-                attributes['NORMAL'] = new viewer_shared_types_1.AttributeData(new Float32Array(normals), 3, 0, 0, 0, false, normals.length / 3);
-                attributes['TEXCOORD_0'] = new viewer_shared_types_1.AttributeData(new Float32Array(uvs), 2, 0, 0, 0, false, uvs.length / 2);
-                const geometry = new viewer_shared_types_1.GeometryData(new viewer_shared_types_1.PrimitiveData(attributes, new viewer_shared_types_1.AttributeData(this.convertToIndicesArray(indices), 1, 0, 0, 0, false, indices.length)), viewer_shared_types_1.PRIMITIVE_MODE.TRIANGLES);
+                attributes['POSITION'] = new AttributeData(new Float32Array(vertices), 3, 0, 0, 0, false, vertices.length / 3);
+                attributes['NORMAL'] = new AttributeData(new Float32Array(normals), 3, 0, 0, 0, false, normals.length / 3);
+                attributes['TEXCOORD_0'] = new AttributeData(new Float32Array(uvs), 2, 0, 0, 0, false, uvs.length / 2);
+                const geometry = new GeometryData(new PrimitiveData(attributes, new AttributeData(this.convertToIndicesArray(indices), 1, 0, 0, 0, false, indices.length)), PRIMITIVE_MODE.TRIANGLES);
                 singleCylinderNode.data.push(geometry);
                 singleCylinderNode.addTransformation({
                     id: 'cylinder_' + i + '_translation',
-                    matrix: gl_matrix_1.mat4.translate(gl_matrix_1.mat4.create(), gl_matrix_1.mat4.create(), cylinderBottom)
+                    matrix: mat4.translate(mat4.create(), mat4.create(), cylinderBottom)
                 });
-                const cylinderRotationMatrix = gl_matrix_1.mat4.transpose(gl_matrix_1.mat4.create(), gl_matrix_1.mat4.fromValues(cylinderXAxis[0], cylinderYAxis[0], cylinderAxis[0], 0, cylinderXAxis[1], cylinderYAxis[1], cylinderAxis[1], 0, cylinderXAxis[2], cylinderYAxis[2], cylinderAxis[2], 0, 0, 0, 0, 1));
+                const cylinderRotationMatrix = mat4.transpose(mat4.create(), mat4.fromValues(cylinderXAxis[0], cylinderYAxis[0], cylinderAxis[0], 0, cylinderXAxis[1], cylinderYAxis[1], cylinderAxis[1], 0, cylinderXAxis[2], cylinderYAxis[2], cylinderAxis[2], 0, 0, 0, 0, 1));
                 singleCylinderNode.addTransformation({
                     id: 'cylinder_' + i + '_rotation',
                     matrix: cylinderRotationMatrix
                 });
                 singleCylinderNode.addTransformation({
                     id: 'cylinder_' + i + '_rotation2',
-                    matrix: gl_matrix_1.mat4.rotateX(gl_matrix_1.mat4.create(), gl_matrix_1.mat4.create(), 0.5 * Math.PI)
+                    matrix: mat4.rotateX(mat4.create(), mat4.create(), 0.5 * Math.PI)
                 });
                 singleCylinderNode.addTransformation({
                     id: 'cylinder_' + i + '_translation2',
-                    matrix: gl_matrix_1.mat4.translate(gl_matrix_1.mat4.create(), gl_matrix_1.mat4.create(), gl_matrix_1.vec3.fromValues(0, 0, 0.5 * gl_matrix_1.vec3.distance(cylinderTop, cylinderBottom)))
+                    matrix: mat4.translate(mat4.create(), mat4.create(), vec3.fromValues(0, 0, 0.5 * vec3.distance(cylinderTop, cylinderBottom)))
                 });
                 cylinderNode.addChild(singleCylinderNode);
             }
@@ -415,13 +412,13 @@ class SDGTFLoader {
             if (!this._content.spheres)
                 throw new Error('Spheres not available.');
             const sphere = this._content.spheres;
-            const sphereNode = new viewer_shared_node_tree_1.TreeNode('spheres');
+            const sphereNode = new TreeNode('spheres');
             const data = yield this.loadAccessor(sphere.attributes['SPHERES']);
             const count = data.array.length / data.itemSize;
             for (let i = 0; i < count; i++) {
-                const singleSphereNode = new viewer_shared_node_tree_1.TreeNode('sphere_' + i);
+                const singleSphereNode = new TreeNode('sphere_' + i);
                 const index = i * 4;
-                const sphereTranslation = gl_matrix_1.vec3.fromValues(data.array[index + 0], data.array[index + 1], data.array[index + 2]);
+                const sphereTranslation = vec3.fromValues(data.array[index + 0], data.array[index + 1], data.array[index + 2]);
                 const sphereRadius = data.array[index + 3];
                 if (sphereRadius <= 0) {
                     this._logger.warn('SDGTFLoader.loadSpheres: Sphere radius is <= 0.');
@@ -453,10 +450,10 @@ class SDGTFLoader {
                     for (let ix = 0; ix <= widthSegments; ix++) {
                         const u = ix / widthSegments;
                         // vertex
-                        const vertex = gl_matrix_1.vec3.fromValues(-sphereRadius * Math.cos(phiStart + u * phiLength) * Math.sin(thetaStart + v * thetaLength), sphereRadius * Math.cos(thetaStart + v * thetaLength), sphereRadius * Math.sin(phiStart + u * phiLength) * Math.sin(thetaStart + v * thetaLength));
+                        const vertex = vec3.fromValues(-sphereRadius * Math.cos(phiStart + u * phiLength) * Math.sin(thetaStart + v * thetaLength), sphereRadius * Math.cos(thetaStart + v * thetaLength), sphereRadius * Math.sin(phiStart + u * phiLength) * Math.sin(thetaStart + v * thetaLength));
                         vertices.push(vertex[0], vertex[1], vertex[2]);
                         // normal
-                        const normal = gl_matrix_1.vec3.normalize(gl_matrix_1.vec3.create(), vertex);
+                        const normal = vec3.normalize(vec3.create(), vertex);
                         normals.push(normal[0], normal[1], normal[2]);
                         // uv
                         uvs.push(u + uOffset, 1 - v);
@@ -478,14 +475,14 @@ class SDGTFLoader {
                     }
                 }
                 const attributes = {};
-                attributes['POSITION'] = new viewer_shared_types_1.AttributeData(new Float32Array(vertices), 3, 0, 0, 0, false, vertices.length / 3);
-                attributes['NORMAL'] = new viewer_shared_types_1.AttributeData(new Float32Array(normals), 3, 0, 0, 0, false, normals.length / 3);
-                attributes['TEXCOORD_0'] = new viewer_shared_types_1.AttributeData(new Float32Array(uvs), 2, 0, 0, 0, false, uvs.length / 2);
-                const geometry = new viewer_shared_types_1.GeometryData(new viewer_shared_types_1.PrimitiveData(attributes, new viewer_shared_types_1.AttributeData(this.convertToIndicesArray(indices), 1, 0, 0, 0, false, indices.length)), viewer_shared_types_1.PRIMITIVE_MODE.TRIANGLES);
+                attributes['POSITION'] = new AttributeData(new Float32Array(vertices), 3, 0, 0, 0, false, vertices.length / 3);
+                attributes['NORMAL'] = new AttributeData(new Float32Array(normals), 3, 0, 0, 0, false, normals.length / 3);
+                attributes['TEXCOORD_0'] = new AttributeData(new Float32Array(uvs), 2, 0, 0, 0, false, uvs.length / 2);
+                const geometry = new GeometryData(new PrimitiveData(attributes, new AttributeData(this.convertToIndicesArray(indices), 1, 0, 0, 0, false, indices.length)), PRIMITIVE_MODE.TRIANGLES);
                 singleSphereNode.data.push(geometry);
                 singleSphereNode.addTransformation({
                     id: 'sphere_' + i + '_translation',
-                    matrix: gl_matrix_1.mat4.translate(gl_matrix_1.mat4.create(), gl_matrix_1.mat4.create(), sphereTranslation)
+                    matrix: mat4.translate(mat4.create(), mat4.create(), sphereTranslation)
                 });
                 sphereNode.addChild(singleSphereNode);
             }
@@ -497,11 +494,11 @@ class SDGTFLoader {
             if (!this._content.points[pointName])
                 throw new Error('Point not available.');
             const point = this._content.points[pointName];
-            const pointNode = new viewer_shared_node_tree_1.TreeNode(pointName);
+            const pointNode = new TreeNode(pointName);
             const attributes = {};
             const data = yield this.loadAccessor(point.attributes['POINTS']);
-            attributes['POSITION'] = new viewer_shared_types_1.AttributeData(data.array, 3, data.itemBytes, data.byteOffset, data.elementBytes, data.normalized, data.count);
-            const geometry = new viewer_shared_types_1.GeometryData(new viewer_shared_types_1.PrimitiveData(attributes, null), viewer_shared_types_1.PRIMITIVE_MODE.POINTS);
+            attributes['POSITION'] = new AttributeData(data.array, 3, data.itemBytes, data.byteOffset, data.elementBytes, data.normalized, data.count);
+            const geometry = new GeometryData(new PrimitiveData(attributes, null), PRIMITIVE_MODE.POINTS);
             pointNode.data.push(geometry);
             return pointNode;
         });
@@ -511,11 +508,11 @@ class SDGTFLoader {
             if (!this._content.polylines[polylineName])
                 throw new Error('Polyline not available.');
             const polyLine = this._content.polylines[polylineName];
-            const polyLineNode = new viewer_shared_node_tree_1.TreeNode(polylineName);
+            const polyLineNode = new TreeNode(polylineName);
             const attributes = {};
             const data = yield this.loadAccessor(polyLine.attributes['VERTICES']);
-            attributes['POSITION'] = new viewer_shared_types_1.AttributeData(data.array, 3, data.itemBytes, data.byteOffset, data.elementBytes, data.normalized, data.count);
-            const geometry = new viewer_shared_types_1.GeometryData(new viewer_shared_types_1.PrimitiveData(attributes, null), viewer_shared_types_1.PRIMITIVE_MODE.LINE_STRIP);
+            attributes['POSITION'] = new AttributeData(data.array, 3, data.itemBytes, data.byteOffset, data.elementBytes, data.normalized, data.count);
+            const geometry = new GeometryData(new PrimitiveData(attributes, null), PRIMITIVE_MODE.LINE_STRIP);
             polyLineNode.data.push(geometry);
             return polyLineNode;
         });
@@ -525,7 +522,7 @@ class SDGTFLoader {
             if (!this._content.surfacepatches[surfacepatchName])
                 throw new Error('Surfacepatch not available.');
             const surfacepatch = this._content.surfacepatches[surfacepatchName];
-            const surfacepatchNode = new viewer_shared_node_tree_1.TreeNode(surfacepatchName);
+            const surfacepatchNode = new TreeNode(surfacepatchName);
             const controlPointCountU = surfacepatch.controlPointCountU;
             const controlPointCountV = surfacepatch.controlPointCountV;
             const controlPointsData = yield this.loadAccessor(surfacepatch.attributes['CONTROLPOINTS']); // vec3
@@ -534,7 +531,7 @@ class SDGTFLoader {
             for (let u = 0; u < controlPointCountU; u++) {
                 let innerArray = [];
                 for (let v = 0; v < controlPointCountV; v++) {
-                    innerArray.push(gl_matrix_1.vec4.fromValues(controlPointsData.array[pointCount * 3], controlPointsData.array[pointCount * 3 + 1], controlPointsData.array[pointCount * 3 + 2], 1));
+                    innerArray.push(vec4.fromValues(controlPointsData.array[pointCount * 3], controlPointsData.array[pointCount * 3 + 1], controlPointsData.array[pointCount * 3 + 2], 1));
                     pointCount++;
                 }
                 controlPoints.push(innerArray);
@@ -598,22 +595,22 @@ class SDGTFLoader {
                 const Nv = calcBasisFunctions(knotsV, degreeV, vspan, v);
                 const temp = [];
                 for (let l = 0; l <= degreeV; ++l) {
-                    temp[l] = gl_matrix_1.vec4.create();
+                    temp[l] = vec4.create();
                     for (let k = 0; k <= degreeU; ++k) {
-                        const point = gl_matrix_1.vec4.clone(controlPoints[uspan - degreeU + k][vspan - degreeV + l]);
+                        const point = vec4.clone(controlPoints[uspan - degreeU + k][vspan - degreeV + l]);
                         const w = point[3];
                         point[0] *= w;
                         point[1] *= w;
                         point[2] *= w;
-                        gl_matrix_1.vec4.add(temp[l], temp[l], gl_matrix_1.vec4.multiply(gl_matrix_1.vec4.create(), point, gl_matrix_1.vec4.fromValues(Nu[k], Nu[k], Nu[k], Nu[k])));
+                        vec4.add(temp[l], temp[l], vec4.multiply(vec4.create(), point, vec4.fromValues(Nu[k], Nu[k], Nu[k], Nu[k])));
                     }
                 }
-                const Sw = gl_matrix_1.vec4.create();
+                const Sw = vec4.create();
                 for (let l = 0; l <= degreeV; ++l) {
-                    gl_matrix_1.vec4.add(Sw, Sw, gl_matrix_1.vec4.multiply(gl_matrix_1.vec4.create(), temp[l], gl_matrix_1.vec4.fromValues(Nv[l], Nv[l], Nv[l], Nv[l])));
+                    vec4.add(Sw, Sw, vec4.multiply(vec4.create(), temp[l], vec4.fromValues(Nv[l], Nv[l], Nv[l], Nv[l])));
                 }
-                gl_matrix_1.vec4.divide(Sw, Sw, gl_matrix_1.vec4.fromValues(Sw[3], Sw[3], Sw[3], Sw[3]));
-                return gl_matrix_1.vec3.fromValues(Sw[0], Sw[1], Sw[2]);
+                vec4.divide(Sw, Sw, vec4.fromValues(Sw[3], Sw[3], Sw[3], Sw[3]));
+                return vec3.fromValues(Sw[0], Sw[1], Sw[2]);
             };
             const getPointOnSurfacepatch = (t1, t2) => {
                 const u = knotsU[0] + t1 * (knotsU[knotsU.length - 1] - knotsU[0]); // linear mapping t1->u
@@ -643,18 +640,18 @@ class SDGTFLoader {
                 }
             }
             const attributes = {};
-            attributes['POSITION'] = new viewer_shared_types_1.AttributeData(new Float32Array(vertices), 3, 0, 0, 0, false, vertices.length / 3);
+            attributes['POSITION'] = new AttributeData(new Float32Array(vertices), 3, 0, 0, 0, false, vertices.length / 3);
             // to not compute normals ourselves, we just let three.js do it
             // in our geometry loader, this array will cause the computation of vertex normals
-            attributes['NORMAL'] = new viewer_shared_types_1.AttributeData(new Float32Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 3, 0, 0, 0, false, vertices.length / 3);
-            const geometry = new viewer_shared_types_1.GeometryData(new viewer_shared_types_1.PrimitiveData(attributes, new viewer_shared_types_1.AttributeData(this.convertToIndicesArray(indices), 1, 0, 0, 0, false, indices.length)), viewer_shared_types_1.PRIMITIVE_MODE.TRIANGLES);
+            attributes['NORMAL'] = new AttributeData(new Float32Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 3, 0, 0, 0, false, vertices.length / 3);
+            const geometry = new GeometryData(new PrimitiveData(attributes, new AttributeData(this.convertToIndicesArray(indices), 1, 0, 0, 0, false, indices.length)), PRIMITIVE_MODE.TRIANGLES);
             surfacepatchNode.data.push(geometry);
             return surfacepatchNode;
         });
     }
     loadScene() {
         return __awaiter(this, void 0, void 0, function* () {
-            const sceneNode = new viewer_shared_node_tree_1.TreeNode('sdgtf_content');
+            const sceneNode = new TreeNode('sdgtf_content');
             // arcs
             if (this._content.arcs)
                 sceneNode.addChild(yield this.loadArcs());
@@ -691,5 +688,4 @@ class SDGTFLoader {
         });
     }
 }
-exports.SDGTFLoader = SDGTFLoader;
 //# sourceMappingURL=SDGTFLoader.js.map