@shapediver/viewer.data-engine.geometry-engine 2.7.10 → 2.8.1

package/src/gltfv1/GLTFLoader.ts

@@ -1,5 +1,5 @@
 import { ITreeNode, TreeNode } from '@shapediver/viewer.shared.node-tree'
-import { Converter, HttpClient, PerformanceEvaluator, UuidGenerator, Logger, LOGGING_TOPIC, ShapeDiverViewerDataProcessingError } from '@shapediver/viewer.shared.services'
+import { Converter, HttpClient, PerformanceEvaluator, UuidGenerator, Logger, ShapeDiverViewerDataProcessingError } from '@shapediver/viewer.shared.services'
 import {
   ACCESSORCOMPONENTTYPE_V1 as ACCESSOR_COMPONENTTYPE,
   ACCESSORTYPE_V1 as ACCESSORTYPE,
@@ -14,7 +14,6 @@ import {
   MaterialStandardData,
   PrimitiveData,
 } from '@shapediver/viewer.shared.types'
-import { container } from 'tsyringe'
 
 import { SDGTFLoader } from './SDGTFLoader'
 
@@ -22,13 +21,13 @@ export class GLTFLoader {
     // #region Properties (5)
 
     private readonly BINARY_EXTENSION_HEADER_LENGTH = 20;
-    private readonly _httpClient: HttpClient = <HttpClient>container.resolve(HttpClient);
-    private readonly _uuidGenerator: UuidGenerator = <UuidGenerator>container.resolve(UuidGenerator);
-    private readonly _logger: Logger = <Logger>container.resolve(Logger);
+    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 _converter: Converter = <Converter>container.resolve(Converter);
-    private readonly _performanceEvaluator = <PerformanceEvaluator>container.resolve(PerformanceEvaluator);
+    private readonly _converter: Converter = Converter.instance;
+    private readonly _performanceEvaluator = PerformanceEvaluator.instance;
 
     private _baseUri: string | undefined;
     private _body: ArrayBuffer | undefined;
@@ -48,29 +47,22 @@ export class GLTFLoader {
         if(gltfBinary && gltfHeader)
             sdgtfNode = await new SDGTFLoader().load(gltfBinary, gltfHeader.length);
 
-        try {
-            this.validateVersionAndExtensions();
-            const node = await this.loadScene();
-            if(sdgtfNode) node.addChild(sdgtfNode);
-            return node;
-        } catch (e) {            
-            throw this._logger.handleError(LOGGING_TOPIC.DATA_PROCESSING, `GLTFLoader.loadContent`, e);
-        }
+        this.validateVersionAndExtensions();
+        const node = await this.loadScene();
+        if(sdgtfNode) node.addChild(sdgtfNode);
+        return node;
+
     }
 
     public async loadWithUrl(url?: string | undefined): Promise<ITreeNode> {
         this._performanceEvaluator.startSection('gltfProcessing.' + url);
         let binaryGeometry: ArrayBuffer;
 
-        try {
-            this._performanceEvaluator.startSection('loadGltf.' + url);
-            binaryGeometry = (await this._httpClient.get(url!, {
-                responseType: 'arraybuffer'
-            })).data;
-            this._performanceEvaluator.endSection('loadGltf.' + url);
-        } catch (e) {            
-            throw this._logger.handleError(LOGGING_TOPIC.DATA_PROCESSING, `GLTFLoader.load`, e);
-        }
+        this._performanceEvaluator.startSection('loadGltf.' + url);
+        binaryGeometry = (await this._httpClient.get(url!, {
+            responseType: 'arraybuffer'
+        })).data;
+        this._performanceEvaluator.endSection('loadGltf.' + url);
 
         // create header data
         const headerDataView = new DataView(binaryGeometry, 0, this.BINARY_EXTENSION_HEADER_LENGTH);
@@ -81,10 +73,8 @@ export class GLTFLoader {
             contentLength: headerDataView.getUint32(12, true),
             contentFormat: headerDataView.getUint32(16, true)
         }
-        if (header.magic != 'glTF') {
-            const error = new ShapeDiverViewerDataProcessingError('GLTFLoader.load: Invalid data: glTF magic wrong.');
-            throw this._logger.handleError(LOGGING_TOPIC.DATA_PROCESSING, `GLTFLoader.load`, error);
-        }
+        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);
@@ -96,15 +86,11 @@ export class GLTFLoader {
 
         const sdgtfNode = await new SDGTFLoader().load(binaryGeometry, header.length);
 
-        try {
-            this.validateVersionAndExtensions();
-            const node = await this.loadScene();
-            node.addChild(sdgtfNode);
-            this._performanceEvaluator.endSection('gltfProcessing.' + url);
-            return node;
-        } catch (e) {
-            throw this._logger.handleError(LOGGING_TOPIC.DATA_PROCESSING, `GLTFLoader.load`, e);
-        }
+        this.validateVersionAndExtensions();
+        const node = await this.loadScene();
+        node.addChild(sdgtfNode);
+        this._performanceEvaluator.endSection('gltfProcessing.' + url);
+        return node;
     }
 
     // #endregion Public Methods (1)
@@ -124,7 +110,7 @@ export class GLTFLoader {
                     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(LOGGING_TOPIC.DATA_PROCESSING, 'GLTFLoader.validateVersionAndExtensions: ' + message);
+                this._logger.info('GLTFLoader.validateVersionAndExtensions: ' + message);
             }
         }
     }
@@ -135,7 +121,7 @@ export class GLTFLoader {
         const bufferView = await this.loadBufferView(accessor.bufferView!);
 
         const itemSize = ACCESSORTYPE[<keyof typeof ACCESSORTYPE>accessor.type];
-        if(accessor.componentType === 5124) this._logger.warn(LOGGING_TOPIC.DATA_PROCESSING, 'GLTFLoader.loadAccessor: The componentType for this accessor is 5124, which is not allowed. Trying to load it anyway.');
+        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;
@@ -186,7 +172,7 @@ export class GLTFLoader {
 
         if(material.extensions && material.extensions.KHR_materials_common) {
             const technique = material.extensions.KHR_materials_common.technique;
-            if(technique && technique !== 'BLINN') this._logger.warn(LOGGING_TOPIC.DATA_PROCESSING, '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')) 
@@ -198,7 +184,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(LOGGING_TOPIC.DATA_PROCESSING, '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')) {
@@ -209,7 +195,7 @@ export class GLTFLoader {
             if (values.hasOwnProperty('emission') && Array.isArray(values.emission)) {
                 materialData.emissiveness = values.emission;
             } else if (values.hasOwnProperty('emission')) {
-                this._logger.warn(LOGGING_TOPIC.DATA_PROCESSING, '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')) {

package/src/gltfv1/SDGTFLoader.ts

@@ -1,5 +1,5 @@
 import { ITreeNode, TreeNode } from '@shapediver/viewer.shared.node-tree'
-import { Logger, LOGGING_TOPIC, ShapeDiverViewerDataProcessingError } from '@shapediver/viewer.shared.services'
+import { Logger, ShapeDiverViewerDataProcessingError } from '@shapediver/viewer.shared.services'
 import {
   ACCESSORCOMPONENTTYPE_V1 as ACCESSOR_COMPONENTTYPE,
   ACCESSORTYPE_V1 as ACCESSORTYPE,
@@ -12,14 +12,13 @@ import {
   PRIMITIVE_MODE,
   PrimitiveData,
 } from '@shapediver/viewer.shared.types'
-import { container } from 'tsyringe'
 import { mat4, vec3, vec4 } from 'gl-matrix'
 
 export class SDGTFLoader {
     // #region Properties (5)
 
     private readonly BINARY_EXTENSION_HEADER_LENGTH = 20;
-    private readonly _logger: Logger = <Logger>container.resolve(Logger);
+    private readonly _logger: Logger = Logger.instance;
 
     private _body!: ArrayBuffer;
     private _content!: ISDGTF_v1;
@@ -38,10 +37,8 @@ export class SDGTFLoader {
                 contentLength: headerDataView.getUint32(13, true),
                 contentFormat: headerDataView.getUint32(17, true)
             }
-            if (header.magic != 'sdgTF') {
-                const error = new ShapeDiverViewerDataProcessingError('SDGTFLoader.load: Invalid data: sdgTF magic wrong.');
-                throw this._logger.handleError(LOGGING_TOPIC.DATA_PROCESSING, `SDGTFLoader.load`, error);
-            }
+            if (header.magic != 'sdgTF') 
+                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);
@@ -52,11 +49,7 @@ export class SDGTFLoader {
             return new TreeNode();
         }
 
-        try {
-            return await this.loadScene();
-        } catch (e) {
-            throw this._logger.handleError(LOGGING_TOPIC.DATA_PROCESSING, `SDGTFLoader.load`, e);
-        }
+        return await this.loadScene();
     }
 
     // #endregion Public Methods (1)
@@ -115,7 +108,7 @@ export class SDGTFLoader {
             const arcZAxis = vec3.cross(vec3.create(), arcXAxis, arcYAxis)
 
             if (arcRadius <= 0) {
-                this._logger.warn(LOGGING_TOPIC.DATA_PROCESSING, 'SDGTFLoader.loadArcs: Arc radius is <= 0.');
+                this._logger.warn('SDGTFLoader.loadArcs: Arc radius is <= 0.');
                 continue;
             }
             const points: number[] = [];
@@ -295,7 +288,7 @@ export class SDGTFLoader {
             const circleZAxis = vec3.cross(vec3.create(), circleXAxis, circleYAxis)
 
             if (circleRadius <= 0) {
-                this._logger.warn(LOGGING_TOPIC.DATA_PROCESSING, 'SDGTFLoader.loadCircles: Circle radius is <= 0.');
+                this._logger.warn('SDGTFLoader.loadCircles: Circle radius is <= 0.');
                 continue;
             }
 
@@ -382,7 +375,7 @@ export class SDGTFLoader {
             vec3.normalize(cylinderYAxis, cylinderYAxis);
 
             if (cylinderRadius <= 0) {
-                this._logger.warn(LOGGING_TOPIC.DATA_PROCESSING, 'SDGTFLoader.loadCylinders: Cylinder radius is <= 0.');
+                this._logger.warn('SDGTFLoader.loadCylinders: Cylinder radius is <= 0.');
                 continue;
             }
 
@@ -505,7 +498,7 @@ export class SDGTFLoader {
             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(LOGGING_TOPIC.DATA_PROCESSING, 'SDGTFLoader.loadSpheres: Sphere radius is <= 0.');
+                this._logger.warn('SDGTFLoader.loadSpheres: Sphere radius is <= 0.');
                 continue;
             }
 

package/src/gltfv2/GLTFLoader.ts

@@ -3,12 +3,10 @@ import {
   Converter,
   HttpClient,
   Logger,
-  LOGGING_TOPIC,
   PerformanceEvaluator,
   ShapeDiverViewerDataProcessingError,
   UuidGenerator,
 } from '@shapediver/viewer.shared.services'
-import { container } from 'tsyringe'
 import { IGLTF_v2 } from '@shapediver/viewer.data-engine.shared-types'
 import { mat4, vec3, vec4 } from 'gl-matrix'
 import {
@@ -58,12 +56,12 @@ export class GLTFLoader {
     // #region Properties (17)
 
     private readonly BINARY_EXTENSION_HEADER_LENGTH = 20;
-    private readonly _converter: Converter = <Converter>container.resolve(Converter);
+    private readonly _converter: Converter = Converter.instance;
     private readonly _globalTransformation = mat4.fromValues(1, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1);
-    private readonly _httpClient: HttpClient = <HttpClient>container.resolve(HttpClient);
-    private readonly _logger: Logger = <Logger>container.resolve(Logger);
-    private readonly _performanceEvaluator = <PerformanceEvaluator>container.resolve(PerformanceEvaluator);
-    private readonly _uuidGenerator: UuidGenerator = <UuidGenerator>container.resolve(UuidGenerator);
+    private readonly _httpClient: HttpClient = HttpClient.instance;
+    private readonly _logger: Logger = Logger.instance;
+    private readonly _performanceEvaluator = PerformanceEvaluator.instance;
+    private readonly _uuidGenerator: UuidGenerator = UuidGenerator.instance;
 
     private _accessorLoader!: AccessorLoader;
     private _baseUri: string | undefined;
@@ -88,89 +86,81 @@ export class GLTFLoader {
             this._body = gltfBinary.slice(this.BINARY_EXTENSION_HEADER_LENGTH + gltfHeader.contentLength + 8, gltfHeader.length);
         this._content = content;
 
-        try {
-            this.validateVersionAndExtensions();
-
-            const dracoModule = await new DRACO();
-
-            this._bufferLoader = new BufferLoader(this._content, this._body, this._baseUri);
-            await this._bufferLoader.load();
-            this._bufferViewLoader = new BufferViewLoader(this._content, this._bufferLoader);
-            this._bufferViewLoader.load();
-            this._accessorLoader = new AccessorLoader(this._content, this._bufferViewLoader);
-            this._accessorLoader.load();
-            this._textureLoader = new TextureLoader(this._content, this._bufferViewLoader, this._baseUri);
-            await this._textureLoader.load();
-            this._materialLoader = new MaterialLoader(this._content, this._textureLoader);
-            await this._materialLoader.load();
-            this._geometryLoader = new GeometryLoader(this._content, this._accessorLoader, this._bufferViewLoader, this._materialLoader, dracoModule);
-
-            const node = this.loadScene();
-
-            if (this._content.extensions && this._content.extensions[GLTF_EXTENSIONS.KHR_MATERIALS_VARIANTS]) {
-                const variants = this._content.extensions[GLTF_EXTENSIONS.KHR_MATERIALS_VARIANTS].variants;
-                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)
-            }
+        this.validateVersionAndExtensions();
+
+        const dracoModule = await new DRACO();
+
+        this._bufferLoader = new BufferLoader(this._content, this._body, this._baseUri);
+        await this._bufferLoader.load();
+        this._bufferViewLoader = new BufferViewLoader(this._content, this._bufferLoader);
+        this._bufferViewLoader.load();
+        this._accessorLoader = new AccessorLoader(this._content, this._bufferViewLoader);
+        this._accessorLoader.load();
+        this._textureLoader = new TextureLoader(this._content, this._bufferViewLoader, this._baseUri);
+        await this._textureLoader.load();
+        this._materialLoader = new MaterialLoader(this._content, this._textureLoader);
+        await this._materialLoader.load();
+        this._geometryLoader = new GeometryLoader(this._content, this._accessorLoader, this._bufferViewLoader, this._materialLoader, dracoModule);
+
+        const node = this.loadScene();
+
+        if (this._content.extensions && this._content.extensions[GLTF_EXTENSIONS.KHR_MATERIALS_VARIANTS]) {
+            const variants = this._content.extensions[GLTF_EXTENSIONS.KHR_MATERIALS_VARIANTS].variants;
+            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)
+        }
 
-            if (this._content.skins !== undefined && this._content.nodes !== undefined) {
-                for (let i = 0; i < this._content.nodes?.length; i++) {
-                    if (this._content.nodes[i].skin !== undefined) {
-                        const skinDef = this.loadSkin(this._content.nodes[i].skin!);
-
-                        const skinNode = this._nodes[i];
-
-                        const bones: ITreeNode[] = [];
-                        const boneInverses: mat4[] = [];
-
-                        for (let j = 0; j < skinDef.joints.length; j++) {
-                            this._nodes[skinDef.joints[j]].data.push(new BoneData())
-                            bones.push(this._nodes[skinDef.joints[j]]);
-
-                            let mat = mat4.create();
-                            if (skinDef.inverseBindMatrices !== undefined) {
-                                const matricesArray = skinDef.inverseBindMatrices!.array;
-                                mat = mat4.fromValues(matricesArray[j * 16 + 0], matricesArray[j * 16 + 1], matricesArray[j * 16 + 2], matricesArray[j * 16 + 3],
-                                    matricesArray[j * 16 + 4], matricesArray[j * 16 + 5], matricesArray[j * 16 + 6], matricesArray[j * 16 + 7],
-                                    matricesArray[j * 16 + 8], matricesArray[j * 16 + 9], matricesArray[j * 16 + 10], matricesArray[j * 16 + 11],
-                                    matricesArray[j * 16 + 12], matricesArray[j * 16 + 13], matricesArray[j * 16 + 14], matricesArray[j * 16 + 15]);
-                            }
-                            boneInverses.push(mat);
-                        }
+        if (this._content.skins !== undefined && this._content.nodes !== undefined) {
+            for (let i = 0; i < this._content.nodes?.length; i++) {
+                if (this._content.nodes[i].skin !== undefined) {
+                    const skinDef = this.loadSkin(this._content.nodes[i].skin!);
+
+                    const skinNode = this._nodes[i];
 
-                        skinNode.skinNode = true;
-                        skinNode.bones = bones;
-                        skinNode.boneInverses = boneInverses;
+                    const bones: ITreeNode[] = [];
+                    const boneInverses: mat4[] = [];
 
-                        NodeTreeUtils.addBones(skinNode, skinNode);
+                    for (let j = 0; j < skinDef.joints.length; j++) {
+                        this._nodes[skinDef.joints[j]].data.push(new BoneData())
+                        bones.push(this._nodes[skinDef.joints[j]]);
+
+                        let mat = mat4.create();
+                        if (skinDef.inverseBindMatrices !== undefined) {
+                            const matricesArray = skinDef.inverseBindMatrices!.array;
+                            mat = mat4.fromValues(matricesArray[j * 16 + 0], matricesArray[j * 16 + 1], matricesArray[j * 16 + 2], matricesArray[j * 16 + 3],
+                                matricesArray[j * 16 + 4], matricesArray[j * 16 + 5], matricesArray[j * 16 + 6], matricesArray[j * 16 + 7],
+                                matricesArray[j * 16 + 8], matricesArray[j * 16 + 9], matricesArray[j * 16 + 10], matricesArray[j * 16 + 11],
+                                matricesArray[j * 16 + 12], matricesArray[j * 16 + 13], matricesArray[j * 16 + 14], matricesArray[j * 16 + 15]);
+                        }
+                        boneInverses.push(mat);
                     }
+
+                    skinNode.skinNode = true;
+                    skinNode.bones = bones;
+                    skinNode.boneInverses = boneInverses;
+
+                    NodeTreeUtils.addBones(skinNode, skinNode);
                 }
             }
-
-            if (this._content.animations)
-                for (let i = 0; i < this._content.animations?.length; i++)
-                    node.data.push(this.loadAnimation(i));
-            return node;
-        } catch (e) {
-            throw this._logger.handleError(LOGGING_TOPIC.DATA_PROCESSING, `GLTFLoader.load`, e);
         }
+
+        if (this._content.animations)
+            for (let i = 0; i < this._content.animations?.length; i++)
+                node.data.push(this.loadAnimation(i));
+        return node;
     }
 
     public async loadWithUrl(url?: string | undefined): Promise<ITreeNode> {
         this._performanceEvaluator.startSection('gltfProcessing.' + url);
         let axiosResponse;
 
-        try {
-            this._performanceEvaluator.startSection('loadGltf.' + url);
-            axiosResponse = await this._httpClient.get(url!, {
-                responseType: 'arraybuffer'
-            });
-            this._performanceEvaluator.endSection('loadGltf.' + url);
-        } catch (e) {
-            throw this._logger.handleError(LOGGING_TOPIC.DATA_PROCESSING, `GLTFLoader.load`, e);
-        }
+        this._performanceEvaluator.startSection('loadGltf.' + url);
+        axiosResponse = await this._httpClient.get(url!, {
+            responseType: 'arraybuffer'
+        });
+        this._performanceEvaluator.endSection('loadGltf.' + url);
 
         let gltfContent, gltfBinary, gltfBaseUrl, gltfHeader;
 
@@ -191,10 +181,9 @@ export class GLTFLoader {
                 contentLength: headerDataView.getUint32(12, true),
                 contentFormat: headerDataView.getUint32(16, true)
             }
-            if (gltfHeader.magic != 'glTF') {
-                const error = new ShapeDiverViewerDataProcessingError('GLTFLoader.load: Invalid data: sdgTF magic wrong.');
-                throw this._logger.handleError(LOGGING_TOPIC.DATA_PROCESSING, `GLTFLoader.load`, error);
-            }
+            if (gltfHeader.magic != 'glTF') 
+                throw new ShapeDiverViewerDataProcessingError('GLTFLoader.load: Invalid data: sdgTF magic wrong.');
+
             // create content
             const contentDataView = new DataView(gltfBinary, this.BINARY_EXTENSION_HEADER_LENGTH, gltfHeader.contentLength);
             const contentDecoded = new TextDecoder().decode(contentDataView);
@@ -251,7 +240,7 @@ export class GLTFLoader {
             const output = this._accessorLoader.getAccessor(sampler.output);
             let interpolation = sampler.interpolation;
             if (interpolation === 'CUBICSPLINE') {
-                this._logger.warn(LOGGING_TOPIC.DATA_PROCESSING, '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';
             }
 
@@ -481,7 +470,7 @@ export class GLTFLoader {
                     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(LOGGING_TOPIC.DATA_PROCESSING, 'GLTFLoader.validateVersionAndExtensions: ' + message);
+                this._logger.info('GLTFLoader.validateVersionAndExtensions: ' + message);
             }
         }
 

package/src/gltfv2/loaders/AccessorLoader.ts

@@ -2,22 +2,16 @@ import { AttributeData } from '@shapediver/viewer.shared.types'
 import {
   ACCESSORCOMPONENTTYPE_V2 as ACCESSOR_COMPONENTTYPE,
   ACCESSORTYPE_V2 as ACCESSORTYPE,
-  IGLTF_v2,
-  IGLTF_v2_Material,
-  IGLTF_v2_Material_KHR_materials_pbrSpecularGlossiness,
-  IGLTF_v2_Primitive,
-  ISHAPEDIVER_materials_preset,
+  IGLTF_v2
 } from '@shapediver/viewer.data-engine.shared-types'
-import { Logger, LOGGING_TOPIC } from '@shapediver/viewer.shared.services'
-import { container } from 'tsyringe'
+import { Logger } from '@shapediver/viewer.shared.services'
 
-import { BufferLoader } from './BufferLoader'
 import { BufferViewLoader } from './BufferViewLoader'
 
 export class AccessorLoader {
   // #region Properties (2)
 
-  private readonly _logger: Logger = <Logger>container.resolve(Logger);
+  private readonly _logger: Logger = Logger.instance;
 
   private _loaded: {
         [key: string]: AttributeData | null
@@ -58,7 +52,7 @@ export class AccessorLoader {
             const arrayBuffer = this._bufferViewLoader.getBufferView(accessor.bufferView!);
 
             const itemSize = ACCESSORTYPE[<keyof typeof ACCESSORTYPE>accessor.type];
-            if (accessor.componentType === 5124) this._logger.warn(LOGGING_TOPIC.DATA_PROCESSING, 'GLTFLoader.loadAccessor: The componentType for this accessor is 5124, which is not allowed. Trying to load it anyway.');
+            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;

package/src/gltfv2/loaders/BufferLoader.ts

@@ -1,11 +1,10 @@
-import { container } from 'tsyringe'
 import { IGLTF_v2 } from '@shapediver/viewer.data-engine.shared-types'
 import { HttpClient } from '@shapediver/viewer.shared.services'
 
 export class BufferLoader {
     // #region Properties (2)
 
-    private readonly _httpClient: HttpClient = <HttpClient>container.resolve(HttpClient);
+    private readonly _httpClient: HttpClient = HttpClient.instance;
 
     private _loaded: {
         [key: string]: ArrayBuffer

package/src/gltfv2/loaders/GeometryLoader.ts

@@ -17,12 +17,12 @@ export class GeometryLoader {
     // #region Constructors (1)
 
     constructor(
-        private readonly _content: IGLTF_v2, 
-        private readonly _accessorLoader: AccessorLoader, 
-        private readonly _bufferViewLoader: BufferViewLoader, 
+        private readonly _content: IGLTF_v2,
+        private readonly _accessorLoader: AccessorLoader,
+        private readonly _bufferViewLoader: BufferViewLoader,
         private readonly _materialLoader: MaterialLoader,
         private readonly _dracoModule: any
-    ) {}
+    ) { }
 
     // #endregion Constructors (1)
 
@@ -69,19 +69,17 @@ export class GeometryLoader {
             const arrayBuffer = this._bufferViewLoader.getBufferView(dracoDef.bufferView!);
 
             const decoder = new this._dracoModule.Decoder();
-            const buffer = new this._dracoModule.DecoderBuffer();
-            buffer.Init(new Int8Array(arrayBuffer), arrayBuffer.byteLength);
-            const geometryType = decoder.GetEncodedGeometryType(buffer);
+            const array = new Int8Array(arrayBuffer);
+            const geometryType = decoder.GetEncodedGeometryType(array);
 
             let dracoGeometry;
             if (geometryType === this._dracoModule.TRIANGULAR_MESH) {
                 dracoGeometry = new this._dracoModule.Mesh();
-                decoder.DecodeBufferToMesh(buffer, dracoGeometry);
+                decoder.DecodeArrayToMesh(array, array.byteLength, dracoGeometry);
             } else if (geometryType === this._dracoModule.POINT_CLOUD) {
                 dracoGeometry = new this._dracoModule.PointCloud();
-                decoder.DecodeBufferToPointCloud(buffer, dracoGeometry);
+                decoder.DecodeArrayToPointCloud(array, array.byteLength, dracoGeometry);
             }
-            this._dracoModule.destroy(buffer);
 
             if (dracoDef.attributes['POSITION'] === undefined) {
                 const errorMsg = "No position attribute found in the mesh.";
@@ -97,51 +95,41 @@ export class GeometryLoader {
 
                 const byteOffset = attribute.byte_offset();
                 const normalized = attribute.normalized();
-                const num_components = attribute.num_components();
-                const count = attributeData.size();
+                const numComponents = attribute.num_components();
 
-                const array = new Float32Array(count);
+                const numPoints = dracoGeometry.num_points();
+                const numValues = numPoints * numComponents;
+                const byteLength = numValues * Float32Array.BYTES_PER_ELEMENT;
 
-                for (let i = 0; i < count; i++) {
-                    for (let a = 0; a < num_components; a++) {
-                        const temp = i * num_components;
-                        const value = attributeData.GetValue(temp + a);
-                        array[temp + a] = value;
-                    }
-                }
-                this._dracoModule.destroy(attributeData);
+                const ptr = this._dracoModule._malloc(byteLength);
+                decoder.GetAttributeDataArrayForAllPoints(dracoGeometry, attribute, this._dracoModule.DT_FLOAT32, byteLength, ptr);
+                const array = new Float32Array(this._dracoModule.HEAPF32.buffer, ptr, numValues).slice();
+                this._dracoModule._free(ptr);
+
+                if(a.includes("COLOR")) array.forEach((n, i) => array[i] = Math.max(0, Math.min(1, n)));
 
                 attributes[a] = new AttributeData(
                     array,
-                    num_components, // itemSize
-                    array.BYTES_PER_ELEMENT * num_components, // itemBytes = elementBytes * itemSize
+                    numComponents, // itemSize
+                    array.BYTES_PER_ELEMENT * numComponents, // itemBytes = elementBytes * itemSize
                     byteOffset, // byteOffset
                     array.BYTES_PER_ELEMENT, // elementBytes
                     normalized, // normalized
-                    array.length / num_components
+                    array.length / numComponents
                 );
             }
 
-            const numFaces = geometryType == this._dracoModule.TRIANGULAR_MESH ? dracoGeometry.num_faces() : 0;
-            const numIndices = numFaces * 3;
-            const indexArray = new Uint32Array(numIndices);
-
-            // For mesh, we need to generate the faces.
             if (geometryType == this._dracoModule.TRIANGULAR_MESH) {
-                const ia = new this._dracoModule.DracoInt32Array();
-                for (let i = 0; i < numFaces; ++i) {
-                    decoder.GetFaceFromMesh(dracoGeometry, i, ia);
-                    const index = i * 3;
-                    indexArray[index] = ia.GetValue(0);
-                    indexArray[index + 1] = ia.GetValue(1);
-                    indexArray[index + 2] = ia.GetValue(2);
-                }
-                this._dracoModule.destroy(ia);
-            }
-            this._dracoModule.destroy(decoder);
-            this._dracoModule.destroy(dracoGeometry);
 
-            if (geometryType == this._dracoModule.TRIANGULAR_MESH)
+                const numFaces = dracoGeometry.num_faces();
+                const numIndices = numFaces * 3;
+                const byteLength = numIndices * 4;
+
+                const ptr = this._dracoModule._malloc(byteLength);
+                decoder.GetTrianglesUInt32Array(dracoGeometry, byteLength, ptr);
+                const indexArray = new Uint32Array(this._dracoModule.HEAPF32.buffer, ptr, numIndices).slice();
+                this._dracoModule._free(ptr);
+
                 indices = new AttributeData(
                     indexArray,
                     1, // itemSize
@@ -151,6 +139,10 @@ export class GeometryLoader {
                     false, // normalized
                     indexArray.length // count
                 );
+            }
+
+            this._dracoModule.destroy(decoder);
+            this._dracoModule.destroy(dracoGeometry);
         }
 
         for (let attribute in primitive.attributes) {
@@ -159,6 +151,7 @@ export class GeometryLoader {
                 continue;
             }
 
+
             let attributeName = attribute;
             // attribute name conversion to be consistent with gltf
             if (/\d/.test(attributeName) && !attributeName.includes('_')) {
@@ -174,7 +167,7 @@ export class GeometryLoader {
             attributes[attributeName] = (this._accessorLoader.getAccessor(primitive.attributes[attribute]))!;
         }
 
-        if ((primitive.indices || primitive.indices === 0) && !indices)
+        if ((primitive.indices || primitive.indices === 0) && !indices) 
             indices = this._accessorLoader.getAccessor(primitive.indices);
 
         // reading and assigning morph targets