@shapediver/viewer.data-engine.geometry-engine 3.3.4 → 3.3.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapediver/viewer.data-engine.geometry-engine",
-  "version": "3.3.4",
+  "version": "3.3.7",
   "description": "",
   "keywords": [],
   "author": "Michael Oppitz <michael@shapediver.com>",
@@ -10,11 +10,10 @@
     "test": "__tests__"
   },
   "files": [
-    "dist",
-    "src",
     "package.json",
+    "dist/",
     "README.md",
-    "tsconfig.json"
+    "LICENSE"
   ],
   "publishConfig": {
     "access": "public"
@@ -40,14 +39,14 @@
   },
   "dependencies": {
     "@shapediver/sdk.geometry-api-sdk-v2": "1.11.0",
-    "@shapediver/viewer.data-engine.material-engine": "3.3.4",
-    "@shapediver/viewer.data-engine.shared-types": "3.3.4",
-    "@shapediver/viewer.rendering-engine.camera-engine": "3.3.4",
-    "@shapediver/viewer.rendering-engine.light-engine": "3.3.4",
-    "@shapediver/viewer.shared.build-data": "3.3.4",
-    "@shapediver/viewer.shared.node-tree": "3.3.4",
-    "@shapediver/viewer.shared.services": "3.3.4",
-    "@shapediver/viewer.shared.types": "3.3.4",
+    "@shapediver/viewer.data-engine.material-engine": "3.3.7",
+    "@shapediver/viewer.data-engine.shared-types": "3.3.7",
+    "@shapediver/viewer.rendering-engine.camera-engine": "3.3.7",
+    "@shapediver/viewer.rendering-engine.light-engine": "3.3.7",
+    "@shapediver/viewer.shared.build-data": "3.3.7",
+    "@shapediver/viewer.shared.node-tree": "3.3.7",
+    "@shapediver/viewer.shared.services": "3.3.7",
+    "@shapediver/viewer.shared.types": "3.3.7",
     "axios": "^1.2.6",
     "gl-matrix": "3.3.0"
   },
@@ -56,5 +55,5 @@
     "path": false,
     "os": false
   },
-  "gitHead": "8193da527b4e3fc4d90181018bd60d6ac70be3e8"
+  "gitHead": "112787d5c5226cca5e89d08102d0b1a3dd4a1d71"
 }

package/src/GeometryEngine.ts

@@ -1,149 +0,0 @@
-import { ITreeNode } from '@shapediver/viewer.shared.node-tree';
-import { HttpClient, HttpResponse, Logger, PerformanceEvaluator, ShapeDiverViewerDataProcessingError } from '@shapediver/viewer.shared.services';
-
-import { GLTFLoader as GLTF_v1Loader } from './gltfv1/GLTFLoader';
-import { GLTFLoader as GLTF_v2Loader } from './gltfv2/GLTFLoader';
-import { ShapeDiverResponseOutputContent } from '@shapediver/sdk.geometry-api-sdk-v2';
-
-export class GeometryEngine {
-    // #region Properties (7)
-
-    private readonly BINARY_EXTENSION_HEADER_LENGTH = 20;
-    private readonly _httpClient: HttpClient = HttpClient.instance;
-    private readonly _loadingQueue: Promise<ITreeNode>[] = [];
-    private readonly _logger: Logger = Logger.instance;
-    private readonly _performanceEvaluator = PerformanceEvaluator.instance;
-
-    private static _instance: GeometryEngine;
-
-    private _loadingQueueLength = Infinity;
-
-    // #endregion Properties (7)
-
-    // #region Public Static Accessors (1)
-
-    public static get instance() {
-        return this._instance || (this._instance = new this());
-    }
-
-    // #endregion Public Static Accessors (1)
-
-    // #region Public Accessors (2)
-
-    public get parallelGlTFProcessing(): number {
-        return this._loadingQueueLength;
-    }
-
-    public set parallelGlTFProcessing(value: number) {
-        this._loadingQueueLength = value;
-    }
-
-    // #endregion Public Accessors (2)
-
-    // #region Public Methods (1)
-
-    /**
-     * Load the geometry content into a scene graph node.
-     * 
-     * @param content the geometry content
-     * @returns the scene graph node 
-     */
-    public async loadContent(content: ShapeDiverResponseOutputContent, taskEventId: string): Promise<ITreeNode> {
-        if (!content || (content && !content.href))
-            throw new ShapeDiverViewerDataProcessingError('GeometryEngine cannot load content.');
-
-        while (this._loadingQueueLength <= this._loadingQueue.length)
-            await new Promise(resolve => setTimeout(resolve, 10));
-
-        const url = content.href!;
-        // eslint-disable-next-line no-async-promise-executor
-        const loadingPromise = new Promise<ITreeNode>(async (resolve, reject) => {
-            let gltfContent, gltfBinary, gltfBaseUrl, gltfHeader;
-            let version = '2.0';
-
-            if (content.format === 'glb' || content.format === 'gltf') {
-                this._performanceEvaluator.startSection('gltfProcessing.' + url);
-
-                this._performanceEvaluator.startSection('loadGltf.' + url);
-                const axiosResponse = await this._httpClient.get(url!, {
-                    responseType: 'arraybuffer'
-                }) as HttpResponse<ArrayBuffer>;
-                this._performanceEvaluator.endSection('loadGltf.' + url);
-
-                const magic = new TextDecoder().decode(new Uint8Array(axiosResponse.data, 0, 4));
-                const isBinary = magic === 'glTF';
-
-                if (isBinary) {
-                    gltfBinary = axiosResponse.data;
-                    // create header data
-                    const headerDataView = new DataView(gltfBinary, 0, this.BINARY_EXTENSION_HEADER_LENGTH);
-                    gltfHeader = {
-                        magic: magic,
-                        version: headerDataView.getUint32(4, true),
-                        length: headerDataView.getUint32(8, true),
-                        contentLength: headerDataView.getUint32(12, true),
-                        contentFormat: headerDataView.getUint32(16, true)
-                    };
-                    if (gltfHeader.magic != 'glTF')
-                        throw new ShapeDiverViewerDataProcessingError('Invalid data: glTF magic wrong.');
-
-                    // create content
-                    const contentDataView = new DataView(gltfBinary, this.BINARY_EXTENSION_HEADER_LENGTH, gltfHeader.contentLength);
-                    const contentDecoded = new TextDecoder().decode(contentDataView);
-                    gltfContent = JSON.parse(contentDecoded);
-
-                    if (gltfContent && gltfContent.asset && gltfContent.asset.version) {
-                        const assetVersion = (gltfContent.asset.version + '').endsWith('.0') ? gltfContent.asset.version : gltfContent.asset.version + '.0';
-                        if (gltfHeader.version + '.0' === assetVersion) {
-                            version = gltfHeader.version + '.0';
-                        } else {
-                            throw new ShapeDiverViewerDataProcessingError('GeometryEngine.loadContent: glTF header version (' + gltfHeader.version + ') is not the same as asset version (' + assetVersion + ').');
-                        }
-                    } else {
-                        version = gltfHeader.version + '.0';
-                    }
-                } else {
-                    gltfContent = JSON.parse(new TextDecoder().decode(axiosResponse.data));
-
-                    if (gltfContent && gltfContent.asset && gltfContent.asset.version) {
-                        if (gltfContent.asset.version !== '2.0')
-                            throw new ShapeDiverViewerDataProcessingError('GeometryEngine.loadContent: Only gltf v2 is supported in a non-binary format.');
-                    } else {
-                        this._logger.warn('GeometryEngine.loadContent: No version specified in asset, trying to load as v2.');
-                        version = '2.0';
-                    }
-
-                    const removeLastDirectoryPartOf = (the_url: string): string => {
-                        const dir_char = the_url.includes('/') ? '/' : '\\';
-                        const the_arr = the_url.split(dir_char);
-                        the_arr.pop();
-                        return the_arr.join(dir_char);
-                    };
-
-                    gltfBaseUrl = removeLastDirectoryPartOf(url!);
-                    if (!gltfBaseUrl && window && window.location && window.location.href)
-                        gltfBaseUrl = removeLastDirectoryPartOf(window.location.href);
-                }
-            }
-
-            let promise: Promise<ITreeNode>;
-            if (version === '1.0') {
-                promise = new GLTF_v1Loader().load(gltfContent, gltfBinary, gltfHeader, gltfBaseUrl, taskEventId);
-            } else {
-                promise = new GLTF_v2Loader().load(gltfContent, gltfBinary, gltfHeader, gltfBaseUrl, taskEventId);
-            }
-            promise.catch(e => { reject(e); });
-            resolve(promise);
-        });
-
-        this._loadingQueue.push(loadingPromise);
-        const node = await loadingPromise;
-        this._loadingQueue.splice(this._loadingQueue.indexOf(loadingPromise), 1);
-
-        this._performanceEvaluator.endSection('gltfProcessing.' + url);
-
-        return node;
-    }
-
-    // #endregion Public Methods (1)
-}

package/src/gltfv1/GLTFLoader.ts

@@ -1,356 +0,0 @@
-/* eslint-disable no-prototype-builtins */
-import { ITreeNode, TreeNode } from '@shapediver/viewer.shared.node-tree';
-import { HttpClient, PerformanceEvaluator, UuidGenerator, Logger, ShapeDiverViewerDataProcessingError, EventEngine, EVENTTYPE, HttpResponse } from '@shapediver/viewer.shared.services';
-import {
-  ACCESSORCOMPONENTTYPE_V1 as ACCESSOR_COMPONENTTYPE,
-  ACCESSORTYPE_V1 as ACCESSORTYPE,
-  IGLTF_v1,
-  IGLTF_v1_Material,
-} from '@shapediver/viewer.data-engine.shared-types';
-import { mat4, vec3, vec4 } from 'gl-matrix';
-import {
-  AttributeData,
-  GeometryData,
-  MATERIAL_SIDE,
-  MaterialStandardData,
-  PrimitiveData,
-  ITaskEvent,
-  TASK_TYPE,
-  PRIMITIVE_MODE,
-} from '@shapediver/viewer.shared.types';
-
-import { SDGTFLoader } from './SDGTFLoader';
-
-export class GLTFLoader {
-    // #region Properties (5)
-
-    private readonly BINARY_EXTENSION_HEADER_LENGTH = 20;
-    private readonly _httpClient: HttpClient = HttpClient.instance;
-    private readonly _uuidGenerator: UuidGenerator = UuidGenerator.instance;
-    private readonly _logger: Logger = Logger.instance;
-    private readonly _implementedExtensions = ['KHR_materials_common'];
-    private readonly _globalTransformation = mat4.fromValues(1, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1);
-    private readonly _eventEngine: EventEngine = EventEngine.instance;
-    private readonly _performanceEvaluator = PerformanceEvaluator.instance;
-    private readonly _progressUpdateLimit = 500;
-
-    private _baseUri: string | undefined;
-    private _body: ArrayBuffer | undefined;
-    private _content!: IGLTF_v1;
-    private _eventId: string = '';
-    private _numberOfNodes = 0;
-    private _numberOfConvertedNodes = 0;
-    private _progressTimer = 0;
-
-    // #endregion Properties (5)
-
-    // #region Public Methods (1)
-
-    public async load(content: IGLTF_v1, gltfBinary?: ArrayBuffer, gltfHeader?: { magic: string, version: number, length: number, contentLength: number, contentFormat: number }, baseUri?: string, taskEventId?: string): Promise<ITreeNode> {
-        this._eventId = taskEventId || this._uuidGenerator.create();
-        const eventStart: ITaskEvent = { type: TASK_TYPE.GLTF_CONTENT_LOADING, id: this._eventId, progress: 0, status: 'Starting glTF 1.0 loading.' };
-        this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_START, eventStart);
-        
-        this._numberOfConvertedNodes = 0;
-        this._numberOfNodes = content.nodes ? Object.values(content.nodes).length : 0;
-        this._progressTimer = performance.now();
-        
-        this._baseUri = baseUri;
-        if(gltfBinary && gltfHeader)
-            this._body = gltfBinary.slice(this.BINARY_EXTENSION_HEADER_LENGTH + gltfHeader.contentLength, gltfHeader.length);
-        this._content = content;
-
-        let sdgtfNode;
-        if(gltfBinary && gltfHeader)
-            sdgtfNode = await new SDGTFLoader().load(gltfBinary, gltfHeader.length);
-
-            
-        const eventProgressSDgTF: ITaskEvent = { type: TASK_TYPE.GLTF_CONTENT_LOADING, id: this._eventId, progress: 0.25, status: 'Loaded SDgTF content.' };
-        this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_PROCESS, eventProgressSDgTF);
-
-
-        this.validateVersionAndExtensions();
-        const node = await this.loadScene();
-        if(sdgtfNode) node.addChild(sdgtfNode);
-
-        const eventEnd: ITaskEvent = { type: TASK_TYPE.GLTF_CONTENT_LOADING, id: this._eventId, progress: 1, status: 'GlTF loading complete.' };
-        this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_END, eventEnd);
-
-        return node;
-    }
-
-    public async loadWithUrl(url?: string | undefined): Promise<ITreeNode> {
-        this._performanceEvaluator.startSection('gltfProcessing.' + url);
-
-        this._performanceEvaluator.startSection('loadGltf.' + url);
-        const binaryGeometry = (await this._httpClient.get(url!, {
-            responseType: 'arraybuffer'
-        }) as HttpResponse<ArrayBuffer>).data;
-        this._performanceEvaluator.endSection('loadGltf.' + url);
-
-        // create header data
-        const headerDataView = new DataView(binaryGeometry, 0, this.BINARY_EXTENSION_HEADER_LENGTH);
-        const header = {
-            magic: String.fromCharCode(headerDataView.getUint8(0)) + String.fromCharCode(headerDataView.getUint8(1)) + String.fromCharCode(headerDataView.getUint8(2)) + String.fromCharCode(headerDataView.getUint8(3)),
-            version: headerDataView.getUint32(4, true),
-            length: headerDataView.getUint32(8, true),
-            contentLength: headerDataView.getUint32(12, true),
-            contentFormat: headerDataView.getUint32(16, true)
-        };
-        if (header.magic != 'glTF') 
-            throw new ShapeDiverViewerDataProcessingError('GLTFLoader.load: Invalid data: glTF magic wrong.');
-
-        // create content
-        const contentDataView = new DataView(binaryGeometry, this.BINARY_EXTENSION_HEADER_LENGTH, header.contentLength);
-        const contentDecoded = new TextDecoder().decode(contentDataView);
-        this._content = JSON.parse(contentDecoded);
-
-        // create body
-        this._body = binaryGeometry.slice(this.BINARY_EXTENSION_HEADER_LENGTH + header.contentLength, header.length);
-
-        const sdgtfNode = await new SDGTFLoader().load(binaryGeometry, header.length);
-
-        this.validateVersionAndExtensions();
-        const node = await this.loadScene();
-        node.addChild(sdgtfNode);
-        this._performanceEvaluator.endSection('gltfProcessing.' + url);
-        return node;
-    }
-
-    // #endregion Public Methods (1)
-
-    // #region Private Methods (6)
-
-    private validateVersionAndExtensions(): void {
-        if(this._content.extensionsUsed) {
-            const notSupported = [];
-            for(let i = 0; i < this._content.extensionsUsed.length; i++) {
-                if(!this._implementedExtensions.includes(this._content.extensionsUsed[i])) 
-                    notSupported.push(this._content.extensionsUsed[i]);
-            }
-            if(notSupported.length > 0) {
-                let message = 'Extension' + (notSupported.length === 1 ? ' ' : 's ');
-                notSupported.forEach((element, index) => {
-                    message += '"' + element + '"' + (index === notSupported.length-1 ? '' : index === notSupported.length-2 ? ' and ' : ', ');
-                });
-                message += (notSupported.length === 1 ? ' is' : ' are') + ' not supported, but used. Loading glTF regardless.';
-                this._logger.info('GLTFLoader.validateVersionAndExtensions: ' + message);
-            }
-        }
-    }
-
-    private async loadAccessor(accessorName: string): Promise<AttributeData> {
-        if (!this._content.accessors![accessorName]) throw new Error('Accessor not available.');
-        const accessor = this._content.accessors![accessorName];
-        const bufferView = await this.loadBufferView(accessor.bufferView!);
-
-        const itemSize = ACCESSORTYPE[<keyof typeof ACCESSORTYPE>accessor.type];
-        if(accessor.componentType === 5124) this._logger.warn('GLTFLoader.loadAccessor: The componentType for this accessor is 5124, which is not allowed. Trying to load it anyway.');
-        const ArrayType = ACCESSOR_COMPONENTTYPE[<keyof typeof ACCESSOR_COMPONENTTYPE>accessor.componentType];
-        const elementBytes = ArrayType.BYTES_PER_ELEMENT;
-        const itemBytes = elementBytes * itemSize;
-
-        const byteOffset = accessor.byteOffset || 0;
-        const byteStride = accessor.byteStride;
-        const normalized = false;
-        const target = this._content.bufferViews![accessor.bufferView] ? this._content.bufferViews![accessor.bufferView].target : undefined;
-
-        const min = this._content.asset && this._content.asset?.generator === 'ShapeDiverGltfV1Writer' ? accessor.min || [] : [];
-        const max = this._content.asset && this._content.asset?.generator === 'ShapeDiverGltfV1Writer' ? accessor.max || [] : [];
-
-        // The buffer is not interleaved if the stride is the item size in bytes.
-        return new AttributeData(new ArrayType(bufferView), itemSize, itemBytes, byteOffset, elementBytes, normalized, accessor.count, min, max, byteStride, target);
-    }
-
-    private async loadBuffer(bufferName: string): Promise<ArrayBuffer> {
-        if (!this._content.buffers![bufferName]) throw new Error('Buffer not available.');
-        const buffer = this._content.buffers![bufferName];
-
-        if (bufferName === 'binary_glTF')
-            return this._body!;
-
-        if (buffer.type === 'arraybuffer') {
-            const binaryGeometry: ArrayBuffer = (await this._httpClient.get(buffer.uri!, {
-                responseType: 'arraybuffer'
-            }) as HttpResponse<ArrayBuffer>).data;
-            return binaryGeometry;
-        }
-        if(!this._body) throw new Error('Buffer not available.');
-        return this._body;
-    }
-
-    private async loadBufferView(bufferViewName: string): Promise<ArrayBuffer> {
-        if (!this._content.bufferViews![bufferViewName]) throw new Error('Buffer View not available.');
-        const bufferView = this._content.bufferViews![bufferViewName];
-        const buffer: ArrayBuffer = await this.loadBuffer(bufferView.buffer!);
-        const byteLength = bufferView.byteLength !== undefined ? bufferView.byteLength : 0;
-
-        return buffer.slice(bufferView.byteOffset!, bufferView.byteOffset! + byteLength);
-    }
-
-
-    private async loadMaterial(materialName: string): Promise<MaterialStandardData> {
-        if(!this._content.materials![materialName]) throw new Error('Material not available.');
-        const material: IGLTF_v1_Material = this._content.materials![materialName];
-        const materialData = new MaterialStandardData();
-        if(material.name !== undefined) materialData.name = material.name;
-
-        if(material.extensions && material.extensions.KHR_materials_common) {
-            const technique = material.extensions.KHR_materials_common.technique;
-            if(technique && technique !== 'BLINN') this._logger.warn('The technique ' + technique + ' is not supported. Trying to load the material either way.');
-            const values = material.extensions.KHR_materials_common.values;
-
-            if (values.hasOwnProperty('doubleSided')) 
-                materialData.side = values.doubleSided ? MATERIAL_SIDE.DOUBLE : MATERIAL_SIDE.FRONT;
-
-            materialData.color = '#d3d3d3';
-            if (values.hasOwnProperty('diffuse') && Array.isArray(values.diffuse)) {
-                const diffuseScaled = (<number[]>values.diffuse).map(element => element *= 255.0);
-                materialData.color = diffuseScaled;
-                materialData.opacity = Math.max(0.0, Math.min(values.diffuse[3], 1.0));
-            } else if(values.hasOwnProperty('diffuse')) {
-                this._logger.warn('GLTFLoader.loadMaterial: The value diffuse was set for a material, but is not supported in that type.');
-            }
-            
-            if (!values.hasOwnProperty('diffuse') && values.hasOwnProperty('ambient')) {
-                const ambientScaled = (<number[]>values.ambient).map(element => element *= 255.0);
-                materialData.color = ambientScaled;
-            }
-
-            if (values.hasOwnProperty('emission') && Array.isArray(values.emission)) {
-                materialData.emissiveness = values.emission;
-            } else if (values.hasOwnProperty('emission')) {
-                this._logger.warn('GLTFLoader.loadMaterial: The value emission was set for a material, but is not supported in that type.');
-            }
-
-            if (values.hasOwnProperty('shininess')) {
-                materialData.metalness = Math.min(1, values.shininess);
-                materialData.roughness = 1 - Math.min(1, values.shininess);
-            }
-
-            if (values.hasOwnProperty('transparency')) 
-                materialData.opacity = Math.max(0.0, Math.min(values.transparency, 1.0));
-
-            if (!values.hasOwnProperty('transparency') && values.hasOwnProperty('transparent') && (values.transparency === 'true' || values.transparency === true))
-                materialData.opacity = 0;
-
-            if (values.hasOwnProperty('_roughness'))
-                materialData.roughness = Math.min(1, Math.max(0, values.roughness));
-
-            if (values.hasOwnProperty('_metalness'))
-                materialData.metalness = Math.min(1, Math.max(0, values.metalness));
-        }
-        return materialData;
-    }
-
-    private async loadMesh(meshName: string): Promise<ITreeNode> {
-        if (!this._content.meshes![meshName]) throw new Error('Mesh not available.');
-        const mesh = this._content.meshes![meshName];
-        const meshNode = new TreeNode(meshName);
-
-        if(!mesh.primitives) return new TreeNode('primitive');
-        for (let i = 0, len = mesh.primitives!.length; i < len; i++) {
-            const primitiveNode = new TreeNode('primitive_' + i);
-            meshNode.addChild(primitiveNode);
-            
-            const primitive = mesh.primitives![i];
-            const attributes: {
-                [key: string]: AttributeData
-            } = {};
-
-            for (const attribute in primitive.attributes) {
-                // attribute name conversion to be consistent witg gltf
-                let attributeName = attribute;
-                if(/\d/.test(attributeName) && !attributeName.includes('_')) {
-                    const index = attributeName.search(/\d/);
-                    attributeName = attributeName.substring(0, index) + '_' + attributeName.substring(index, attributeName.length);
-                } else if(attributeName === 'TEXCOORD' || attributeName === 'COLOR' || attributeName === 'JOINTS' || attributeName === 'WEIGHTS') {
-                    attributeName += '_0';
-                } else if (attributeName === 'UV') {
-                    attributeName = 'TEXCOORD_0';
-                }
-
-                attributes[attributeName] = await this.loadAccessor(primitive.attributes[attribute]);
-                if(attributeName.startsWith('COLOR'))
-                    attributes[attributeName] = new AttributeData(attributes[attributeName].array, attributes[attributeName].itemSize, attributes[attributeName].itemBytes, attributes[attributeName].byteOffset, attributes[attributeName].elementBytes, true, attributes[attributeName].count, [], [], attributes[attributeName].byteStride, attributes[attributeName].target);
-            }
-
-            let material: MaterialStandardData | undefined;
-            if(primitive.material) 
-                material = await this.loadMaterial(primitive.material);
-
-            const geometry = new GeometryData(new PrimitiveData(attributes, await this.loadAccessor(primitive.indices!)), PRIMITIVE_MODE.TRIANGLES, material);
-            primitiveNode.data.push(geometry);
-        }
-        return meshNode;
-    }
-
-    private async loadNode(nodeName: string): Promise<ITreeNode> {
-        if (!this._content.nodes![nodeName]) throw new Error('Node not available.');
-        const node = this._content.nodes![nodeName];
-        const nodeDef = new TreeNode(nodeName);
-
-        if (node.matrix) {
-            nodeDef.addTransformation({
-                id: this._uuidGenerator.create(),
-                matrix: mat4.fromValues(node.matrix[0], node.matrix[1], node.matrix[2], node.matrix[3],
-                node.matrix[4], node.matrix[5], node.matrix[6], node.matrix[7],
-                node.matrix[8], node.matrix[9], node.matrix[10], node.matrix[11],
-                node.matrix[12], node.matrix[13], node.matrix[14], node.matrix[15])
-            });
-        } else if (node.translation || node.scale || node.rotation) {
-            const matT = node.translation ? mat4.fromTranslation(mat4.create(), vec3.fromValues(node.translation[0], node.translation[1], node.translation[2])) : mat4.create();
-            const matS = node.scale ? mat4.fromScaling(mat4.create(), vec3.fromValues(node.scale[0], node.scale[1], node.scale[2])) : mat4.create();
-            const matR = node.rotation ? mat4.fromQuat(mat4.create(), vec4.fromValues(node.rotation[0], node.rotation[1], node.rotation[2], node.rotation[3])) : mat4.create();
-            const matrix = mat4.mul(mat4.create(), mat4.mul(mat4.create(), matT, matS), matR);
-            nodeDef.addTransformation({
-                id: this._uuidGenerator.create(),
-                matrix: matrix
-            });
-        }
-
-        if(node.meshes) {
-            for (let i = 0, len = node.meshes!.length; i < len; i++) {
-                // we create a child node as we one want to have one mesh as in the GLTF2 def
-                nodeDef.addChild(await this.loadMesh(node.meshes![i]));
-            }
-        }
-
-        if (node.children) {
-            for (let i = 0, len = node.children!.length; i < len; i++) {
-                // got through all children
-                nodeDef.addChild(await this.loadNode(node.children![i]));
-            }
-        }
-
-        
-        this._numberOfConvertedNodes++;
-
-        if(performance.now() - this._progressTimer > this._progressUpdateLimit) {
-            this._progressTimer = performance.now();
-            const eventProgress: ITaskEvent = { type: TASK_TYPE.GLTF_CONTENT_LOADING, id: this._eventId, progress: (this._numberOfConvertedNodes / this._numberOfNodes) / 2 + 0.25, status: `GlTF conversion progress: ${this._numberOfConvertedNodes}/${this._numberOfNodes} nodes.` };
-            this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_PROCESS, eventProgress);
-            await new Promise(resolve => setTimeout(resolve, 0));
-        }
-
-        return nodeDef;
-    }
-
-    private async loadScene(): Promise<ITreeNode> {
-        if (!this._content.scene) throw new Error('No scene.');
-        if (!this._content.scenes![this._content.scene!]) throw new Error('Scene not available.');
-        const scene = this._content.scenes![this._content.scene!];
-        const sceneDef = new TreeNode(this._content.scene!);
-        if(this._content.asset && this._content.asset?.generator !== 'ShapeDiverGltfWriter' && this._content.asset?.generator !== 'ShapeDiverGltfV1Writer') {
-            sceneDef.addTransformation({
-                id: this._uuidGenerator.create(),
-                matrix: this._globalTransformation
-            });
-        }
-        if(scene.nodes)
-            for (let i = 0, len = scene.nodes!.length; i < len; i++)
-                sceneDef.addChild(await this.loadNode(scene.nodes![i]));
-        return sceneDef;
-    }
-    // #endregion Private Methods (6)
-}