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

package/src/GeometryEngine.ts

@@ -1,9 +1,9 @@
-import { ITreeNode } from '@shapediver/viewer.shared.node-tree'
-import { HttpClient, Logger, PerformanceEvaluator, ShapeDiverViewerDataProcessingError } from '@shapediver/viewer.shared.services'
+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'
+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)
@@ -52,7 +52,7 @@ export class GeometryEngine {
         if (!content || (content && !content.href))
             throw new ShapeDiverViewerDataProcessingError('GeometryEngine cannot load content.');
 
-        while(this._loadingQueueLength <= this._loadingQueue.length) 
+        while (this._loadingQueueLength <= this._loadingQueue.length)
             await new Promise(resolve => setTimeout(resolve, 10));
 
         const url = content.href!;
@@ -60,19 +60,19 @@ export class GeometryEngine {
         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
@@ -83,18 +83,18 @@ export class GeometryEngine {
                         length: headerDataView.getUint32(8, true),
                         contentLength: headerDataView.getUint32(12, true),
                         contentFormat: headerDataView.getUint32(16, true)
-                    }
-                    if (gltfHeader.magic != 'glTF') 
+                    };
+                    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) {
+
+                    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) {
+                        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 + ').');
@@ -104,42 +104,42 @@ export class GeometryEngine {
                     }
                 } else {
                     gltfContent = JSON.parse(new TextDecoder().decode(axiosResponse.data));
-    
-                    if(gltfContent && gltfContent.asset && gltfContent.asset.version) {
-                        if(gltfContent.asset.version !== '2.0')
+
+                    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 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)
+                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) })
+            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;

package/src/gltfv1/GLTFLoader.ts

@@ -1,12 +1,13 @@
-import { ITreeNode, TreeNode } from '@shapediver/viewer.shared.node-tree'
-import { Converter, HttpClient, PerformanceEvaluator, UuidGenerator, Logger, ShapeDiverViewerDataProcessingError, EventEngine, EVENTTYPE } from '@shapediver/viewer.shared.services'
+/* 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'
+} from '@shapediver/viewer.data-engine.shared-types';
+import { mat4, vec3, vec4 } from 'gl-matrix';
 import {
   AttributeData,
   GeometryData,
@@ -16,9 +17,9 @@ import {
   ITaskEvent,
   TASK_TYPE,
   PRIMITIVE_MODE,
-} from '@shapediver/viewer.shared.types'
+} from '@shapediver/viewer.shared.types';
 
-import { SDGTFLoader } from './SDGTFLoader'
+import { SDGTFLoader } from './SDGTFLoader';
 
 export class GLTFLoader {
     // #region Properties (5)
@@ -36,7 +37,7 @@ export class GLTFLoader {
     private _baseUri: string | undefined;
     private _body: ArrayBuffer | undefined;
     private _content!: IGLTF_v1;
-    private _eventId: string = "";
+    private _eventId: string = '';
     private _numberOfNodes = 0;
     private _numberOfConvertedNodes = 0;
     private _progressTimer = 0;
@@ -80,12 +81,11 @@ export class GLTFLoader {
 
     public async loadWithUrl(url?: string | undefined): Promise<ITreeNode> {
         this._performanceEvaluator.startSection('gltfProcessing.' + url);
-        let binaryGeometry: ArrayBuffer;
 
         this._performanceEvaluator.startSection('loadGltf.' + url);
-        binaryGeometry = (await this._httpClient.get(url!, {
+        const binaryGeometry = (await this._httpClient.get(url!, {
             responseType: 'arraybuffer'
-        })).data;
+        }) as HttpResponse<ArrayBuffer>).data;
         this._performanceEvaluator.endSection('loadGltf.' + url);
 
         // create header data
@@ -96,7 +96,7 @@ export class GLTFLoader {
             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.');
 
@@ -140,7 +140,7 @@ export class GLTFLoader {
     }
 
     private async loadAccessor(accessorName: string): Promise<AttributeData> {
-        if (!this._content.accessors![accessorName]) throw new Error('Accessor not available.')
+        if (!this._content.accessors![accessorName]) throw new Error('Accessor not available.');
         const accessor = this._content.accessors![accessorName];
         const bufferView = await this.loadBufferView(accessor.bufferView!);
 
@@ -155,15 +155,15 @@ export class GLTFLoader {
         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 || [] : [];
+        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.')
+        if (!this._content.buffers![bufferName]) throw new Error('Buffer not available.');
         const buffer = this._content.buffers![bufferName];
 
         if (bufferName === 'binary_glTF')
@@ -172,7 +172,7 @@ export class GLTFLoader {
         if (buffer.type === 'arraybuffer') {
             const binaryGeometry: ArrayBuffer = (await this._httpClient.get(buffer.uri!, {
                 responseType: 'arraybuffer'
-            })).data;
+            }) as HttpResponse<ArrayBuffer>).data;
             return binaryGeometry;
         }
         if(!this._body) throw new Error('Buffer not available.');
@@ -180,7 +180,7 @@ export class GLTFLoader {
     }
 
     private async loadBufferView(bufferViewName: string): Promise<ArrayBuffer> {
-        if (!this._content.bufferViews![bufferViewName]) throw new Error('Buffer View not available.')
+        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;
@@ -190,14 +190,14 @@ export class GLTFLoader {
 
 
     private async loadMaterial(materialName: string): Promise<MaterialStandardData> {
-        if(!this._content.materials![materialName]) throw new Error('Material not available.')
+        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.')
+            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')) 
@@ -209,7 +209,7 @@ export class GLTFLoader {
                 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.')
+                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')) {
@@ -220,7 +220,7 @@ export class GLTFLoader {
             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.')
+                this._logger.warn('GLTFLoader.loadMaterial: The value emission was set for a material, but is not supported in that type.');
             }
 
             if (values.hasOwnProperty('shininess')) {
@@ -244,7 +244,7 @@ export class GLTFLoader {
     }
 
     private async loadMesh(meshName: string): Promise<ITreeNode> {
-        if (!this._content.meshes![meshName]) throw new Error('Mesh not available.')
+        if (!this._content.meshes![meshName]) throw new Error('Mesh not available.');
         const mesh = this._content.meshes![meshName];
         const meshNode = new TreeNode(meshName);
 
@@ -253,16 +253,16 @@ export class GLTFLoader {
             const primitiveNode = new TreeNode('primitive_' + i);
             meshNode.addChild(primitiveNode);
             
-            let primitive = mesh.primitives![i];
+            const primitive = mesh.primitives![i];
             const attributes: {
                 [key: string]: AttributeData
             } = {};
 
-            for (let attribute in primitive.attributes) {
+            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/)
+                    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';
@@ -272,7 +272,7 @@ export class GLTFLoader {
 
                 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)
+                    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;
@@ -286,7 +286,7 @@ export class GLTFLoader {
     }
 
     private async loadNode(nodeName: string): Promise<ITreeNode> {
-        if (!this._content.nodes![nodeName]) throw new Error('Node not available.')
+        if (!this._content.nodes![nodeName]) throw new Error('Node not available.');
         const node = this._content.nodes![nodeName];
         const nodeDef = new TreeNode(nodeName);
 
@@ -337,15 +337,15 @@ export class GLTFLoader {
     }
 
     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.')
+        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") {
+        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++)

package/src/gltfv2/GLTFLoader.ts

@@ -1,39 +1,39 @@
-import { ITreeNode, TreeNode } from '@shapediver/viewer.shared.node-tree'
+import { ITreeNode, TreeNode } from '@shapediver/viewer.shared.node-tree';
 import {
-  Converter,
-  EventEngine,
-  EVENTTYPE,
-  HttpClient,
-  Logger,
-  PerformanceEvaluator,
-  ShapeDiverViewerDataProcessingError,
-  UuidGenerator,
-} from '@shapediver/viewer.shared.services'
-import { IGLTF_v2 } from '@shapediver/viewer.data-engine.shared-types'
-import { mat4, vec3, vec4 } from 'gl-matrix'
+    EventEngine,
+    EVENTTYPE,
+    HttpClient,
+    HttpResponse,
+    Logger,
+    PerformanceEvaluator,
+    ShapeDiverViewerDataProcessingError,
+    UuidGenerator,
+} from '@shapediver/viewer.shared.services';
+import { IGLTF_v2 } from '@shapediver/viewer.data-engine.shared-types';
+import { mat4, vec3, vec4 } from 'gl-matrix';
 import {
-  AnimationData,
-  IAnimationTrack,
-  AttributeData,
-  BoneData,
-  Color,
-  ITaskEvent,
-  TASK_TYPE
-} from '@shapediver/viewer.shared.types'
-import { OrthographicCamera, PerspectiveCamera } from '@shapediver/viewer.rendering-engine.camera-engine'
+    AnimationData,
+    IAnimationTrack,
+    AttributeData,
+    BoneData,
+    Color,
+    ITaskEvent,
+    TASK_TYPE
+} from '@shapediver/viewer.shared.types';
+import { OrthographicCamera, PerspectiveCamera } from '@shapediver/viewer.rendering-engine.camera-engine';
 import {
-  AbstractLight,
-  DirectionalLight,
-  PointLight,
-  SpotLight,
-} from '@shapediver/viewer.rendering-engine.light-engine'
-
-import { BufferLoader } from './loaders/BufferLoader'
-import { BufferViewLoader } from './loaders/BufferViewLoader'
-import { AccessorLoader } from './loaders/AccessorLoader'
-import { TextureLoader } from './loaders/TextureLoader'
-import { MaterialLoader } from './loaders/MaterialLoader'
-import { GeometryLoader } from './loaders/GeometryLoader'
+    AbstractLight,
+    DirectionalLight,
+    PointLight,
+    SpotLight,
+} from '@shapediver/viewer.rendering-engine.light-engine';
+
+import { BufferLoader } from './loaders/BufferLoader';
+import { BufferViewLoader } from './loaders/BufferViewLoader';
+import { AccessorLoader } from './loaders/AccessorLoader';
+import { TextureLoader } from './loaders/TextureLoader';
+import { MaterialLoader } from './loaders/MaterialLoader';
+import { GeometryLoader } from './loaders/GeometryLoader';
 
 export enum GLTF_EXTENSIONS {
     KHR_BINARY_GLTF = 'KHR_binary_glTF',
@@ -53,10 +53,11 @@ export enum GLTF_EXTENSIONS {
     SHAPEDIVER_MATERIALS_PRESET = 'SHAPEDIVER_materials_preset'
 }
 
+// eslint-disable-next-line @typescript-eslint/no-var-requires
 const DRACO = require('./draco/draco_decoder.js');
 
 export class GLTFLoader {
-    // #region Properties (17)
+    // #region Properties (22)
 
     private readonly BINARY_EXTENSION_HEADER_LENGTH = 20;
     private readonly _eventEngine: EventEngine = EventEngine.instance;
@@ -73,18 +74,18 @@ export class GLTFLoader {
     private _bufferLoader!: BufferLoader;
     private _bufferViewLoader!: BufferViewLoader;
     private _content!: IGLTF_v2;
-    private _eventId: string = "";
+    private _eventId: string = '';
     private _geometryLoader!: GeometryLoader;
     private _materialLoader!: MaterialLoader;
     private _nodes: {
         [key: number]: ITreeNode
     } = {};
-    private _numberOfNodes = 0;
     private _numberOfConvertedNodes = 0;
-    private _textureLoader!: TextureLoader;
+    private _numberOfNodes = 0;
     private _progressTimer = 0;
+    private _textureLoader!: TextureLoader;
 
-    // #endregion Properties (17)
+    // #endregion Properties (22)
 
     // #region Public Methods (2)
 
@@ -92,11 +93,11 @@ export class GLTFLoader {
         this._eventId = taskEventId || this._uuidGenerator.create();
         const eventStart: ITaskEvent = { type: TASK_TYPE.GLTF_CONTENT_LOADING, id: this._eventId, progress: 0, status: 'Starting glTF 2.0 loading.' };
         this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_START, eventStart);
-        
+
         this._numberOfConvertedNodes = 0;
         this._numberOfNodes = content.nodes ? 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 + 8, gltfHeader.length);
@@ -128,7 +129,7 @@ export class GLTFLoader {
             for (let i = 0; i < variants.length; i++)
                 this._geometryLoader.materialVariantsData.variants.push(variants[i].name);
             this._geometryLoader.materialVariantsData.variantIndex = 0;
-            node.data.push(this._geometryLoader.materialVariantsData)
+            node.data.push(this._geometryLoader.materialVariantsData);
         }
 
         if (this._content.skins !== undefined && this._content.nodes !== undefined) {
@@ -142,7 +143,7 @@ export class GLTFLoader {
                     const boneInverses: mat4[] = [];
 
                     for (let j = 0; j < skinDef.joints.length; j++) {
-                        this._nodes[skinDef.joints[j]].data.push(new BoneData())
+                        this._nodes[skinDef.joints[j]].data.push(new BoneData());
                         bones.push(this._nodes[skinDef.joints[j]]);
 
                         let mat = mat4.create();
@@ -174,12 +175,11 @@ export class GLTFLoader {
 
     public async loadWithUrl(url?: string | undefined): Promise<ITreeNode> {
         this._performanceEvaluator.startSection('gltfProcessing.' + url);
-        let axiosResponse;
 
         this._performanceEvaluator.startSection('loadGltf.' + url);
-        axiosResponse = await this._httpClient.get(url!, {
+        const axiosResponse = await this._httpClient.get(url!, {
             responseType: 'arraybuffer'
-        });
+        }) as HttpResponse<ArrayBuffer>;
         this._performanceEvaluator.endSection('loadGltf.' + url);
 
         let gltfContent, gltfBinary, gltfBaseUrl, gltfHeader;
@@ -200,8 +200,8 @@ export class GLTFLoader {
                 length: headerDataView.getUint32(8, true),
                 contentLength: headerDataView.getUint32(12, true),
                 contentFormat: headerDataView.getUint32(16, true)
-            }
-            if (gltfHeader.magic != 'glTF') 
+            };
+            if (gltfHeader.magic != 'glTF')
                 throw new ShapeDiverViewerDataProcessingError('GLTFLoader.load: Invalid data: sdgTF magic wrong.');
 
             // create content
@@ -215,11 +215,11 @@ export class GLTFLoader {
             gltfContent = JSON.parse(new TextDecoder().decode(axiosResponse.data));
 
             const removeLastDirectoryPartOf = (the_url: string): string => {
-                const dir_char = the_url.includes("/") ? "/" : "\\";
+                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)
@@ -239,8 +239,8 @@ export class GLTFLoader {
          * @return {Promise<AnimationClip>}
          */
     private loadAnimation(animationId: number): AnimationData {
-        if (!this._content.animations) throw new Error('Animations not available.')
-        if (!this._content.animations[animationId]) throw new Error('Animations not available.')
+        if (!this._content.animations) throw new Error('Animations not available.');
+        if (!this._content.animations[animationId]) throw new Error('Animations not available.');
         const animationDef = this._content.animations[animationId];
         const animationTracks: IAnimationTrack[] = [];
         let min = Infinity, max = -Infinity;
@@ -260,7 +260,7 @@ export class GLTFLoader {
             const output = this._accessorLoader.getAccessor(sampler.output);
             let interpolation = sampler.interpolation;
             if (interpolation === 'CUBICSPLINE') {
-                this._logger.warn('Animation with CUBICSPLINE interpolation is currently not supported. Assigning linear interpolation instead.')
+                this._logger.warn('Animation with CUBICSPLINE interpolation is currently not supported. Assigning linear interpolation instead.');
                 interpolation = 'linear';
             }
 
@@ -277,8 +277,8 @@ export class GLTFLoader {
     }
 
     private loadCamera(cameraId: number): ITreeNode {
-        if (!this._content.cameras) throw new Error('Cameras not available.')
-        if (!this._content.cameras[cameraId]) throw new Error('Cameras not available.')
+        if (!this._content.cameras) throw new Error('Cameras not available.');
+        if (!this._content.cameras[cameraId]) throw new Error('Cameras not available.');
         const cameraDef = this._content.cameras[cameraId];
         const cameraNode = new TreeNode(cameraDef.name || 'camera_' + cameraId);
 
@@ -311,7 +311,7 @@ export class GLTFLoader {
 
     private loadLights(lightId: number): ITreeNode {
         if (!this._content.extensions || !this._content.extensions[GLTF_EXTENSIONS.KHR_LIGHTS_PUNCTUAL] || !this._content.extensions[GLTF_EXTENSIONS.KHR_LIGHTS_PUNCTUAL].lights) throw new Error(`Extension ${GLTF_EXTENSIONS.KHR_LIGHTS_PUNCTUAL} not available.`);
-        if (!this._content.extensions[GLTF_EXTENSIONS.KHR_LIGHTS_PUNCTUAL].lights[lightId]) throw new Error('Light not available.')
+        if (!this._content.extensions[GLTF_EXTENSIONS.KHR_LIGHTS_PUNCTUAL].lights[lightId]) throw new Error('Light not available.');
         const lightDef = this._content.extensions[GLTF_EXTENSIONS.KHR_LIGHTS_PUNCTUAL].lights[lightId];
         const lightNode = new TreeNode(lightDef.name || 'light_' + lightId);
 
@@ -366,8 +366,8 @@ export class GLTFLoader {
     }
 
     private async loadNode(nodeId: number): Promise<ITreeNode> {
-        if (!this._content.nodes) throw new Error('Nodes not available.')
-        if (!this._content.nodes[nodeId]) throw new Error('Node not available.')
+        if (!this._content.nodes) throw new Error('Nodes not available.');
+        if (!this._content.nodes[nodeId]) throw new Error('Node not available.');
         const node = this._content.nodes[nodeId];
         const nodeDef = new TreeNode(node.name || 'node_' + nodeId);
         this._nodes[nodeId] = nodeDef;
@@ -429,7 +429,7 @@ export class GLTFLoader {
         }
 
         this._numberOfConvertedNodes++;
-        if(performance.now() - this._progressTimer > this._progressUpdateLimit) {
+        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.1, status: `GlTF conversion progress: ${this._numberOfConvertedNodes}/${this._numberOfNodes} nodes.` };
             this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_PROCESS, eventProgress);
@@ -440,15 +440,15 @@ export class GLTFLoader {
     }
 
     private async loadScene(): Promise<ITreeNode> {
-        if (!this._content.scenes) throw new Error('Scenes not available.')
+        if (!this._content.scenes) throw new Error('Scenes not available.');
         const sceneId = this._content.scene || 0;
-        if (!this._content.scenes[sceneId]) throw new Error('Scene not available.')
+        if (!this._content.scenes[sceneId]) throw new Error('Scene not available.');
         const scene = this._content.scenes[sceneId];
         const sceneDef = new TreeNode(scene.name || 'scene_' + sceneId + '');
         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]));
@@ -459,8 +459,8 @@ export class GLTFLoader {
         joints: number[],
         inverseBindMatrices: AttributeData | null
     } {
-        if (!this._content.skins) throw new Error('Skins not available.')
-        if (!this._content.skins[skinId]) throw new Error('Skin not available.')
+        if (!this._content.skins) throw new Error('Skins not available.');
+        if (!this._content.skins[skinId]) throw new Error('Skin not available.');
         const skinDef = this._content.skins![skinId];
 
         const skinEntry: {
@@ -475,14 +475,14 @@ export class GLTFLoader {
             return skinEntry;
         }
 
-        skinEntry.inverseBindMatrices = this._accessorLoader.getAccessor(skinDef.inverseBindMatrices)
+        skinEntry.inverseBindMatrices = this._accessorLoader.getAccessor(skinDef.inverseBindMatrices);
         return skinEntry;
     }
 
     private validateVersionAndExtensions(): void {
-        if (!this._content.asset) throw new Error('Asset not available.')
+        if (!this._content.asset) throw new Error('Asset not available.');
         const asset = this._content.asset;
-        if (!asset.version) throw new Error('Asset does not have a version.')
+        if (!asset.version) throw new Error('Asset does not have a version.');
         const version: string = asset.minVersion ? asset.minVersion : asset.version;
         if (!version.startsWith('2')) throw new Error('Version of the glTF not supported.');