@shapediver/viewer.data-engine.geometry-engine 2.7.9 → 2.8.0

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/MaterialLoader.ts

@@ -1,5 +1,4 @@
 import { Converter, HttpClient } from '@shapediver/viewer.shared.services'
-import { container } from 'tsyringe'
 import {
   IGLTF_v2,
   IGLTF_v2_Material,
@@ -29,8 +28,8 @@ import { TextureLoader } from './TextureLoader'
 export class MaterialLoader {
     // #region Properties (4)
 
-    private readonly _converter: Converter = <Converter>container.resolve(Converter);
-    private readonly _materialEngine: MaterialEngine = <MaterialEngine>container.resolve(MaterialEngine);
+    private readonly _converter: Converter = Converter.instance;
+    private readonly _materialEngine: MaterialEngine = MaterialEngine.instance;
 
     private _loaded: { [key: string]: IMaterialAbstractData } = {};
 

package/src/gltfv2/loaders/TextureLoader.ts

@@ -1,14 +1,13 @@
 import { IGLTF_v2 } from '@shapediver/viewer.data-engine.shared-types'
 import { Converter, HttpClient, HttpResponse } from '@shapediver/viewer.shared.services'
-import { container } from 'tsyringe'
 
 import { BufferViewLoader } from './BufferViewLoader'
 
 export class TextureLoader {
     // #region Properties (4)
 
-    private readonly _converter: Converter = <Converter>container.resolve(Converter);
-    private readonly _httpClient: HttpClient = <HttpClient>container.resolve(HttpClient);
+    private readonly _converter: Converter = Converter.instance;
+    private readonly _httpClient: HttpClient = HttpClient.instance;
 
     private _loaded: {
         [key: string]: HTMLImageElement
@@ -52,7 +51,7 @@ export class TextureLoader {
                     array[i] = dataView.getUint8(i);
     
                 const blob = new Blob([new Uint8Array(array)], { type: image.mimeType });
-                const dataUri = window.URL.createObjectURL(blob);
+                const dataUri = URL.createObjectURL(blob);
     
                 promises.push(
                     new Promise<void>(resolve => {
@@ -60,6 +59,7 @@ export class TextureLoader {
                             .then(response => {
                                 this._converter.responseToImage(response).then(img => {
                                     this._loaded[textureId] = img;
+                                    URL.revokeObjectURL(dataUri)
                                     resolve()
                                 });
                             })