@colijnit/homedecorator 255.1.1

package/esm2015/app/core/service/utils.service.js

@@ -0,0 +1,566 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Injectable } from '@angular/core';
+import { Box3, Camera, Group, Light, Mesh, Object3D, ObjectLoader, RepeatWrapping, SRGBColorSpace, TextureLoader, Vector3 } from 'three';
+// import OBJLoader from 'app/three-loaders/OBJLoader2';
+// import MTLLoader from 'app/three-loaders/MTLLoader';
+import { OBJLoader } from 'three/examples/jsm/loaders/OBJLoader';
+import { MTLLoader } from 'three/examples/jsm/loaders/MTLLoader';
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader';
+import { GLTFExporter } from 'three/examples/jsm/exporters/GLTFExporter';
+import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader';
+import { KTX2Loader } from 'three/examples/jsm/loaders/KTX2Loader';
+// import {MeshoptDecoder} from '../../../../../lib/meshopt_decoder.js';
+import { USDZExporter } from 'three/examples/jsm/exporters/USDZExporter';
+import { Utils } from '../../plugins/core3d/core/utils';
+import { ExportDialogComponent } from '../../shared/export-dialog/export-dialog.component';
+import { ExportType } from '../enum/export-type.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "./3dm-api";
+import * as i2 from "./homedecorator-settings.service";
+import * as i3 from "./json-utils.service";
+import * as i4 from "./progress.service";
+import * as i5 from "../../plugins/core3d/service/item.service";
+import * as i6 from "../../plugins/core3d/service/scene.service";
+import * as i7 from "@angular/material/dialog";
+import * as i8 from "../../plugins/core3d/service/camera.service";
+// const mtlLoader = new MTLLoader();
+// mtlLoader.setMaterialOptions({invertTrProperty: true});
+// const noop = () => {
+// };
+export class UtilsService {
+    constructor(apiServiceModule, _settingsService, _jsonUtilsService, _progressService, _itemsService, _sceneService, _dialog, _cameraService) {
+        this.apiServiceModule = apiServiceModule;
+        this._settingsService = _settingsService;
+        this._jsonUtilsService = _jsonUtilsService;
+        this._progressService = _progressService;
+        this._itemsService = _itemsService;
+        this._sceneService = _sceneService;
+        this._dialog = _dialog;
+        this._cameraService = _cameraService;
+        this.clips = [];
+        this._objectCache = new Map();
+        this._subs = [];
+        this._ktx2Loader = new KTX2Loader();
+        this._usdzExporter = new USDZExporter();
+        this._gltfExporter = new GLTFExporter();
+        this._subs.push(this._itemsService.removeAllItems.subscribe(() => this._clearCache()));
+    }
+    ngOnDestroy() {
+        this._subs.forEach(s => s.unsubscribe());
+        this._clearCache();
+    }
+    readFileAsText(file) {
+        const fileReader = new FileReader();
+        return new Promise((resolve, reject) => {
+            fileReader.onload = (e) => resolve(e.target.result);
+            fileReader.onerror = error => reject(error);
+            fileReader.readAsText(file);
+        });
+    }
+    /**
+     * Returns a new function that is a throttled version of given function func. Enforces that there is a always minimum amount of time
+     * between two subsequent calls of the function. Tail calls are always executed. In-between calls are lost and not executed.
+     *
+     * @param func The function to return as a throttled version
+     * @param throttleMs Number of milliseconds for throttle: the minimum time between any two subsequent function calls of function
+     * @param [thisArg] Optionally supply the this context of the caller
+     * @returns The given function, with the above-mentioned time constraints
+     */
+    getAsThrottledFunction(func, throttleMs = 250, thisArg) {
+        let lastCallTime;
+        let deferTimer;
+        return function () {
+            const context = thisArg || this;
+            const now = +new Date;
+            const args = arguments;
+            if (lastCallTime && now < lastCallTime + throttleMs) {
+                clearTimeout(deferTimer);
+                deferTimer = window.setTimeout(function () {
+                    lastCallTime = now;
+                    func.apply(context, args);
+                }, throttleMs);
+            }
+            else {
+                lastCallTime = now;
+                func.apply(context, args);
+            }
+        };
+    }
+    loadJsonModel(filePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._objectCache.has(filePath)) {
+                return Promise.resolve(this._objectCache.get(filePath));
+            }
+            filePath = this._includeBaseUrl(filePath);
+            const json = yield this._jsonUtilsService.readJsonFile(filePath, false);
+            const loader = new ObjectLoader();
+            loader.crossOrigin = 'Anonymous';
+            return new Promise((resolve, reject) => {
+                try {
+                    const obj = loader.parse(json);
+                    this._objectCache.set(filePath, obj);
+                    resolve(obj);
+                }
+                catch (e) {
+                    reject(null);
+                }
+            });
+        });
+    }
+    loadJsonObjectModel(filePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            filePath = this._includeBaseUrl(filePath);
+            if (this._objectCache.has(filePath)) {
+                return Promise.resolve(this._objectCache.get(filePath));
+            }
+            const loader = new ObjectLoader();
+            loader.setCrossOrigin('Anonymous');
+            loader.setResourcePath('');
+            return new Promise((resolve, reject) => {
+                loader.load(filePath, (object) => {
+                    const obj = (object.type === 'Scene' && object.children[0].type === 'Object3D') ? object.children[0] : object;
+                    this._objectCache.set(filePath, obj);
+                    resolve(obj);
+                }, xhr => this._progressService.setLoaded(filePath, xhr.loaded), error => reject(error));
+            });
+        });
+    }
+    // private loadMtl(mtlUrl: string): Promise<MTLLoader.MaterialCreator> {
+    //   // mtlUrl = this._includeBaseUrl(mtlUrl);
+    //   return new Promise((resolve, reject) => {
+    //
+    //     const mtlDirectory: string = mtlUrl.split('/').slice(0, -1).join('/') + '/';
+    //     // mtlLoader.setTexturePath(mtlDirectory);
+    //     // mtlLoader.setResouPath(this._settingsService.settings.assetPath);
+    //     mtlLoader.setCrossOrigin('Anonymous');
+    //     mtlLoader.setPath(this._settingsService.settings.assetPath);
+    //
+    //     return mtlLoader.load(mtlUrl, resolve, noop, reject);
+    //
+    //   });
+    // }
+    _absPosition(bgMesh) {
+        bgMesh.geometry.computeBoundingBox();
+        const boundingBox = bgMesh.geometry.boundingBox;
+        const position = new Vector3();
+        position.subVectors(boundingBox.max, boundingBox.min);
+        position.multiplyScalar(0.5);
+        position.add(boundingBox.min);
+        position.applyMatrix4(bgMesh.matrixWorld);
+        return position;
+    }
+    loadObjModel(filePath, mtlUrl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // filePath = this._includeBaseUrl(filePath);
+            // const objLoader = new OBJLoader();
+            // if (mtlUrl) {
+            //   const materialCreator = await this.loadMtl(mtlUrl);
+            //   materialCreator.preload();
+            //   objLoader.setMaterials(materialCreator.materials);
+            // }
+            // return new Promise((resolve, reject) => {
+            //   objLoader.load(
+            //     filePath,
+            //     (node: any) => {
+            //       resolve(this.loadGroup(node));
+            //     },
+            //     undefined, reject
+            //   );
+            // });
+            if (this._objectCache.has(filePath)) {
+                return Promise.resolve(this._objectCache.get(filePath));
+            }
+            return new Promise((resolve, reject) => {
+                new MTLLoader()
+                    .setPath(this._settingsService.settings.assetPath)
+                    .load(mtlUrl, (materials) => {
+                    materials.preload();
+                    new OBJLoader()
+                        .setMaterials(materials)
+                        .setPath(this._settingsService.settings.assetPath)
+                        .load(filePath, (object) => {
+                        const obj = this._cleanedUpObjects(object);
+                        obj.traverse((child) => {
+                            if (child instanceof Mesh && child.material) {
+                                const material = !Array.isArray(child.material) ? [child.material] : child.material;
+                                material.forEach(m => {
+                                    if (m.map) {
+                                        m.map.colorSpace = SRGBColorSpace;
+                                    }
+                                });
+                            }
+                        });
+                        this._objectCache.set(filePath, obj);
+                        resolve(obj);
+                    });
+                }, xhr => this._progressService.setLoaded(filePath, xhr.loaded));
+            });
+        });
+    }
+    loadGlbModel(file, relativePath = true, cleanUp = true) {
+        if (relativePath) {
+            file = this._settingsService.settings.assetPath + file;
+        }
+        if (this._objectCache.has(file)) {
+            return Promise.resolve(this._objectCache.get(file));
+        }
+        return new Promise((resolve, reject) => {
+            const loader = new GLTFLoader();
+            loader.setDRACOLoader(new DRACOLoader());
+            loader.dracoLoader.setDecoderPath(this._settingsService.settings.dracoPath);
+            loader.dracoLoader.setDecoderConfig({ type: 'js' });
+            loader.load(file, (object) => __awaiter(this, void 0, void 0, function* () {
+                // const obj: Object3D = new Object3D();
+                // object.scene.children.forEach((c: Object3D) => {
+                /*
+                            if (c instanceof Group) {
+                              c.children.forEach(gc => obj.add(gc.clone()));
+                            } else {
+                */
+                // reset origin of children for groups
+                // if (c instanceof Group) {
+                //   const boundingBox = new Box3().setFromObject(c);
+                //   const bbCenterPivot = new Vector3();
+                //   boundingBox.getCenter(bbCenterPivot);
+                //   const delta: Vector3 = new Vector3().add(bbCenterPivot).sub(new Vector3(0, c.position.y, 0));
+                //   c.children.forEach((cc) => {
+                //     cc.position.add(new Vector3(0, c.position.y, 0));
+                //   });
+                //   c.position.set(0, 0, 0);
+                // }
+                // }
+                // });
+                this.clips = object.animations || [];
+                const obj = this._cleanedUpObjects(object.scene, cleanUp);
+                this._objectCache.set(file, obj);
+                resolve(obj);
+            }), xhr => this._progressService.setLoaded(file, xhr.loaded), error => {
+                console.log('Error! ', error);
+                reject(error);
+            });
+        });
+    }
+    loadGlbFromFile(file) {
+        return new Promise((resolve, reject) => {
+            const loader = new GLTFLoader();
+            loader.parse(file, '', (object) => __awaiter(this, void 0, void 0, function* () {
+                resolve(object);
+            }), error => {
+                reject(error);
+            });
+        });
+    }
+    loadGlbRoom(file) {
+        if (this._objectCache.has(file)) {
+            return Promise.resolve(this._objectCache.get(file));
+        }
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            yield this._progressService.prepareDownloads([{ model_url: file }]);
+            const loader = new GLTFLoader();
+            loader.load(file, (object) => __awaiter(this, void 0, void 0, function* () {
+                const obj = object.scene;
+                obj.traverse(c => {
+                    if (c.name.toLowerCase().indexOf('glas') < 0 && ((c.parent && c.parent.name.toLowerCase().indexOf('glas') < 0) || !c.parent)) {
+                        c.castShadow = true;
+                        c.receiveShadow = true;
+                    }
+                });
+                this._objectCache.set(file, obj);
+                this._progressService.finishDownloads();
+                resolve(obj);
+            }), xhr => this._progressService.setLoaded(file, xhr.loaded), error => {
+                console.log('Error! ', error);
+                this._progressService.finishDownloads();
+                reject(error);
+            });
+        }));
+    }
+    saveRoomAsGlb() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const elementsToRemove = ['ground-plane', 'hud-ring', 'hud-circle', 'rotationCircle'];
+            let scene;
+            scene = this._sceneService.scene.clone();
+            scene.children.forEach(c => {
+                if (c instanceof Light) {
+                    scene.remove(c);
+                }
+            });
+            elementsToRemove.forEach(elementName => {
+                const selectedObject = scene.getObjectByName(elementName);
+                scene.remove(selectedObject);
+            });
+            scene.name = 'mrp_room';
+            this._download3DModelAsGLB(scene);
+        });
+    }
+    prepRoomForRender(standalone = false, renderParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const camera = this._cameraService.camera;
+            const elementsToRemove = ['ground-plane', 'hud-ring', 'hud-circle', 'rotationCircle'];
+            if (standalone) {
+                elementsToRemove.push('floor-plane');
+            }
+            let scene;
+            scene = this._sceneService.scene.clone();
+            scene.children.forEach(c => {
+                if (c instanceof Light) {
+                    scene.remove(c);
+                }
+                if (c.name && c.name.indexOf('edge') > -1) { // walls should all be visible
+                    c.traverse(cc => {
+                        if (cc instanceof Mesh && cc.material) {
+                            if (Array.isArray(cc.material)) {
+                                cc.material.forEach(m => {
+                                    m.opacity = 0;
+                                    m.transparent = false;
+                                    m.depthWrite = true;
+                                    m.depthTest = true;
+                                });
+                            }
+                            else {
+                                cc.material.opacity = 0;
+                                cc.material.transparent = false;
+                                cc.material.depthWrite = true;
+                                cc.material.depthTest = true;
+                            }
+                        }
+                    });
+                }
+            });
+            elementsToRemove.forEach(elementName => {
+                const selectedObject = scene.getObjectByName(elementName);
+                scene.remove(selectedObject);
+            });
+            scene.name = 'mrp_room_' + scene.uuid;
+            this._createGLBForAPI(scene, camera, standalone, renderParameters);
+        });
+    }
+    _createGLBForAPI(object, camera, standalone, renderParameters) {
+        const options = {
+            trs: false,
+            onlyVisible: true,
+            truncateDrawRange: true,
+            binary: true,
+            maxTextureSize: Infinity
+        };
+        this._gltfExporter.parse(object, (result) => {
+            // const file = new Blob([result], {type: 'application/octet-stream'});
+            const filename = `${object.name}.glb`;
+            const file = new File([result], filename, {
+                type: 'model/gltf-binary',
+            });
+            this._sendFileToApi(file, filename, camera, standalone, renderParameters);
+        }, () => {
+        }, options);
+    }
+    _sendFileToApi(file, filename, camera, standalone, renderParameters) {
+        const formData = new FormData();
+        formData.append('glb', file);
+        this.apiServiceModule.uploadToApiGLB(formData, filename, camera, standalone, renderParameters);
+    }
+    loadGlbSource(file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const obj = yield this.loadGlbModel(file, false, false);
+            obj.children = obj.children.filter(c => !(c instanceof Camera));
+            obj.children.sort((a, b) => a['name'] < b['name'] ? 1 : -1);
+            obj.children.forEach((c) => {
+                c.traverse((t) => {
+                    t.visible = !t.name.toLowerCase().startsWith('c_') && !t.name.toLowerCase().startsWith('p_');
+                });
+                c.visible = false;
+            });
+            if (obj.children.length === 1 && obj.children[0] instanceof Group) { // flatten children
+                const children = obj.children[0].children.slice();
+                const name = obj.children[0].name;
+                obj.children.length = 0;
+                const parent = new Object3D();
+                parent.name = name;
+                parent.children = children;
+                obj.add(parent);
+            }
+            return obj;
+        });
+    }
+    showExportDialog(object) {
+        const exportDialog = this._dialog.open(ExportDialogComponent, {
+            width: '400px'
+        });
+        exportDialog.afterClosed().subscribe((type) => __awaiter(this, void 0, void 0, function* () {
+            if (type) {
+                if (type === ExportType.GLB) {
+                    this._download3DModelAsGLB(object);
+                }
+                else if (type === ExportType.USDZ) {
+                    this._download3DModelAsUSDZ(object);
+                }
+                else if (type === ExportType.BOTH) {
+                    this._download3DModelAsUSDZ(object);
+                    this._download3DModelAsGLB(object);
+                }
+            }
+        }));
+    }
+    textureFromUrl(url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // url = this._includeBaseUrl(url);
+            return new Promise((resolve, reject) => {
+                const textureLoader = new TextureLoader();
+                // textureLoader.setBaseU(this._settingsService.settings.assetPath);
+                textureLoader.load(url, (texture) => {
+                    texture.wrapT = RepeatWrapping;
+                    texture.wrapS = RepeatWrapping;
+                    texture.repeat.set(1, 1);
+                    texture.needsUpdate = true;
+                    return resolve(texture);
+                }, null, reject);
+            });
+        });
+    }
+    forceChangeDetection(cd, component, propName) {
+        const value = component[propName];
+        component[propName] = null;
+        cd.detectChanges();
+        component[propName] = value;
+    }
+    getKTX2Loader() {
+        this._ktx2Loader.detectSupport(this._sceneService.renderer);
+        return this._ktx2Loader;
+    }
+    _download3DModelAsGLB(object) {
+        const options = {
+            trs: false,
+            onlyVisible: true,
+            truncateDrawRange: true,
+            binary: true,
+            maxTextureSize: Infinity
+        };
+        this._gltfExporter.parse(object, (result) => {
+            const file = new Blob([result], { type: 'application/octet-stream' });
+            this._downloadFile(`${object.name}.glb`, file);
+        }, () => {
+        }, options);
+    }
+    _download3DModelAsUSDZ(object) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // const arraybuffer: any =  await this._usdzExporter.parse(object);
+            // const blob: Blob = new Blob([arraybuffer], {type: 'application/octet-stream'});
+            const exporter = new USDZExporter();
+            const arraybuffer = yield exporter.parseAsync(object);
+            const blob = new Blob([arraybuffer], { type: 'application/octet-stream' });
+            this._downloadFile(`${object.name}.usdz`, blob);
+        });
+    }
+    _downloadFile(fileName, blob) {
+        const element = document.createElement('a');
+        element.style.display = 'none';
+        element.href = URL.createObjectURL(blob);
+        element.download = fileName;
+        document.body.appendChild(element);
+        element.click();
+        document.body.removeChild(element);
+    }
+    _loadGroup(node) {
+        const group = node.detail.loaderRootNode;
+        if (group.children.length > 1) {
+            group.children.forEach((mesh) => {
+                mesh.position.copy(this._absPosition(mesh));
+            });
+        }
+        return group;
+    }
+    _cleanedUpObjects(object, cleanUp = true) {
+        let obj = new Object3D();
+        // console.log(this.clips);
+        object.children.forEach((c) => {
+            if (!(c instanceof Camera)) {
+                if (cleanUp && c instanceof Group || (c.children.length === 1 && c.children[0] instanceof Group)) {
+                    this._addGroupChildrenToObject(c, obj);
+                }
+                else if ((cleanUp && !(c instanceof Mesh)) || (!(c instanceof Mesh) && !c.name && c.children.length > 0)) {
+                    c.children.forEach((child) => {
+                        child.translateY(c.position.y);
+                    });
+                    c.translateY(-c.position.y);
+                    if (obj.children.length > 0) {
+                        obj.add(c.clone());
+                    }
+                    else {
+                        obj = c.clone();
+                    }
+                }
+                else {
+                    // if (c.position.y > 0 || c.position.y < 0) {
+                    //   c.children.forEach((child) => {
+                    //     child.translateY(c.position.y);
+                    //   });
+                    //   c.translateY(-c.position.y);
+                    // }
+                    obj.add(c.clone());
+                }
+            }
+        });
+        const boundingBox = new Box3().setFromObject(obj);
+        const bbCenterPivot = new Vector3();
+        boundingBox.getCenter(bbCenterPivot);
+        const delta = new Vector3().add(bbCenterPivot).negate();
+        obj.children.forEach((cc) => {
+            cc.position.add(delta);
+        });
+        return obj;
+    }
+    _addGroupChildrenToObject(group, obj, cleanUp = true) {
+        group.children.forEach((gc) => {
+            if (cleanUp && gc instanceof Group) {
+                this._addGroupChildrenToObject(gc, obj);
+            }
+            else {
+                // gc.translateX(-group.position.x);
+                gc.translateY(group.position.y);
+                // gc.translateZ(-group.position.z);
+                obj.add(gc.clone());
+            }
+        });
+    }
+    _iterateChildren(children, callback) {
+        for (let i = 0; i < children.length; i++) {
+            const child = children[i];
+            if (child instanceof Mesh) {
+                callback(child);
+            }
+            else {
+                this._iterateChildren(child.children, callback);
+            }
+        }
+    }
+    _includeBaseUrl(url) {
+        if (url[0] === '.') {
+            url = url.replace('.', '');
+        }
+        if (url[0] === '/') {
+            url = url.replace('/', '');
+        }
+        return this._settingsService.settings.assetPath + url;
+    }
+    _clearCache() {
+        const objs = Array.from(this._objectCache.values());
+        objs.forEach(o => Utils.DisposeObject(o));
+        this._objectCache.clear();
+    }
+}
+UtilsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: UtilsService, deps: [{ token: i1.ApiServiceModule }, { token: i2.HomedecoratorSettingsService }, { token: i3.JsonUtilsService }, { token: i4.ProgressService }, { token: i5.ItemService }, { token: i6.SceneService }, { token: i7.MatDialog }, { token: i8.CameraService }], target: i0.ɵɵFactoryTarget.Injectable });
+UtilsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: UtilsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: UtilsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ApiServiceModule }, { type: i2.HomedecoratorSettingsService }, { type: i3.JsonUtilsService }, { type: i4.ProgressService }, { type: i5.ItemService }, { type: i6.SceneService }, { type: i7.MatDialog }, { type: i8.CameraService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.service.js","sourceRoot":"","sources":["../../../../../../src/client/app/core/service/utils.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {ChangeDetectorRef, Injectable, OnDestroy} from '@angular/core';\r\nimport {\r\n  Box3,\r\n  Camera,\r\n  Group,\r\n  Light,\r\n  Mesh,\r\n  Object3D,\r\n  ObjectLoader,\r\n  PerspectiveCamera,\r\n  RepeatWrapping,\r\n  SRGBColorSpace,\r\n  Texture,\r\n  TextureLoader,\r\n  Vector3\r\n} from 'three';\r\n// import OBJLoader from 'app/three-loaders/OBJLoader2';\r\n// import MTLLoader from 'app/three-loaders/MTLLoader';\r\nimport {OBJLoader} from 'three/examples/jsm/loaders/OBJLoader';\r\nimport {MTLLoader} from 'three/examples/jsm/loaders/MTLLoader';\r\nimport {GLTFLoader} from 'three/examples/jsm/loaders/GLTFLoader';\r\nimport {GLTFExporter} from 'three/examples/jsm/exporters/GLTFExporter';\r\nimport {Subscription} from 'rxjs';\r\nimport {DRACOLoader} from 'three/examples/jsm/loaders/DRACOLoader';\r\nimport {KTX2Loader} from 'three/examples/jsm/loaders/KTX2Loader';\r\n// import {MeshoptDecoder} from '../../../../../lib/meshopt_decoder.js';\r\nimport {USDZExporter} from 'three/examples/jsm/exporters/USDZExporter';\r\nimport {MatDialog} from '@angular/material/dialog';\r\nimport {Scene} from 'three/src/scenes/Scene';\r\nimport {HomedecoratorSettingsService} from './homedecorator-settings.service';\r\nimport {JsonUtilsService} from './json-utils.service';\r\nimport {ProgressService} from './progress.service';\r\nimport {ItemService} from '../../plugins/core3d/service/item.service';\r\nimport {SceneService} from '../../plugins/core3d/service/scene.service';\r\nimport {Utils} from '../../plugins/core3d/core/utils';\r\nimport {ExportDialogComponent} from '../../shared/export-dialog/export-dialog.component';\r\nimport {ExportType} from '../enum/export-type.enum';\r\nimport {ApiServiceModule} from './3dm-api';\r\nimport {CameraService} from '../../plugins/core3d/service/camera.service';\r\n\r\n// const mtlLoader = new MTLLoader();\r\n// mtlLoader.setMaterialOptions({invertTrProperty: true});\r\n// const noop = () => {\r\n// };\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class UtilsService implements OnDestroy {\r\n\r\n  public clips: any = [];\r\n\r\n  private _objectCache: Map<string, Object3D> = new Map();\r\n  private _subs: Subscription[] = [];\r\n  private _ktx2Loader = new KTX2Loader();\r\n  private _usdzExporter = new USDZExporter();\r\n  private _gltfExporter = new GLTFExporter();\r\n\r\n  constructor(\r\n    public apiServiceModule: ApiServiceModule,\r\n    private _settingsService: HomedecoratorSettingsService,\r\n    private _jsonUtilsService: JsonUtilsService,\r\n    private _progressService: ProgressService,\r\n    private _itemsService: ItemService,\r\n    private _sceneService: SceneService,\r\n    private _dialog: MatDialog,\r\n    private _cameraService: CameraService\r\n  ) {\r\n    this._subs.push(\r\n      this._itemsService.removeAllItems.subscribe(() => this._clearCache())\r\n    );\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this._subs.forEach(s => s.unsubscribe());\r\n    this._clearCache();\r\n  }\r\n\r\n  public readFileAsText(file: File): Promise<string> {\r\n    const fileReader = new FileReader();\r\n    return new Promise((resolve, reject) => {\r\n      fileReader.onload = (e: any) => resolve(e.target.result);\r\n      fileReader.onerror = error => reject(error);\r\n      fileReader.readAsText(file);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Returns a new function that is a throttled version of given function func. Enforces that there is a always minimum amount of time\r\n   * between two subsequent calls of the function. Tail calls are always executed. In-between calls are lost and not executed.\r\n   *\r\n   * @param func The function to return as a throttled version\r\n   * @param throttleMs Number of milliseconds for throttle: the minimum time between any two subsequent function calls of function\r\n   * @param [thisArg] Optionally supply the this context of the caller\r\n   * @returns The given function, with the above-mentioned time constraints\r\n   */\r\n  public getAsThrottledFunction(func: any, throttleMs: number = 250, thisArg?: any): any {\r\n    let lastCallTime: number;\r\n    let deferTimer: number;\r\n\r\n    return function (): any {\r\n      const context: any = thisArg || this;\r\n      const now: any = +new Date;\r\n      const args: any = arguments;\r\n      if (lastCallTime && now < lastCallTime + throttleMs) {\r\n        clearTimeout(deferTimer);\r\n        deferTimer = window.setTimeout(function (): any {\r\n          lastCallTime = now;\r\n          func.apply(context, args);\r\n        }, throttleMs);\r\n      } else {\r\n        lastCallTime = now;\r\n        func.apply(context, args);\r\n      }\r\n    };\r\n  }\r\n\r\n  public async loadJsonModel(filePath: string): Promise<any> {\r\n    if (this._objectCache.has(filePath)) {\r\n      return Promise.resolve(this._objectCache.get(filePath));\r\n    }\r\n    filePath = this._includeBaseUrl(filePath);\r\n    const json: string = await this._jsonUtilsService.readJsonFile(filePath, false);\r\n    const loader = new ObjectLoader();\r\n    loader.crossOrigin = 'Anonymous';\r\n    return new Promise((resolve, reject) => {\r\n      try {\r\n        const obj = loader.parse(json);\r\n        this._objectCache.set(filePath, obj);\r\n        resolve(obj);\r\n      } catch (e) {\r\n        reject(null);\r\n      }\r\n    });\r\n  }\r\n\r\n  public async loadJsonObjectModel(filePath: string): Promise<any> {\r\n    filePath = this._includeBaseUrl(filePath);\r\n    if (this._objectCache.has(filePath)) {\r\n      return Promise.resolve(this._objectCache.get(filePath));\r\n    }\r\n    const loader = new ObjectLoader();\r\n    loader.setCrossOrigin('Anonymous');\r\n    loader.setResourcePath('');\r\n    return new Promise((resolve, reject) => {\r\n      loader.load(filePath,\r\n        (object: any) => {\r\n          const obj: Object3D = (object.type === 'Scene' && object.children[0].type === 'Object3D') ? object.children[0] : object;\r\n          this._objectCache.set(filePath, obj);\r\n          resolve(obj as Object3D);\r\n        },\r\n        xhr => this._progressService.setLoaded(filePath, xhr.loaded),\r\n        error => reject(error)\r\n      );\r\n    });\r\n  }\r\n\r\n  // private loadMtl(mtlUrl: string): Promise<MTLLoader.MaterialCreator> {\r\n  //   // mtlUrl = this._includeBaseUrl(mtlUrl);\r\n  //   return new Promise((resolve, reject) => {\r\n  //\r\n  //     const mtlDirectory: string = mtlUrl.split('/').slice(0, -1).join('/') + '/';\r\n  //     // mtlLoader.setTexturePath(mtlDirectory);\r\n  //     // mtlLoader.setResouPath(this._settingsService.settings.assetPath);\r\n  //     mtlLoader.setCrossOrigin('Anonymous');\r\n  //     mtlLoader.setPath(this._settingsService.settings.assetPath);\r\n  //\r\n  //     return mtlLoader.load(mtlUrl, resolve, noop, reject);\r\n  //\r\n  //   });\r\n  // }\r\n\r\n  private _absPosition(bgMesh: Mesh): Vector3 {\r\n    bgMesh.geometry.computeBoundingBox();\r\n    const boundingBox = bgMesh.geometry.boundingBox;\r\n    const position = new Vector3();\r\n    position.subVectors(boundingBox.max, boundingBox.min);\r\n    position.multiplyScalar(0.5);\r\n    position.add(boundingBox.min);\r\n    position.applyMatrix4(bgMesh.matrixWorld);\r\n    return position;\r\n  }\r\n\r\n  public async loadObjModel(filePath: string, mtlUrl?: string): Promise<any> {\r\n    // filePath = this._includeBaseUrl(filePath);\r\n    // const objLoader = new OBJLoader();\r\n    // if (mtlUrl) {\r\n    //   const materialCreator = await this.loadMtl(mtlUrl);\r\n    //   materialCreator.preload();\r\n    //   objLoader.setMaterials(materialCreator.materials);\r\n    // }\r\n    // return new Promise((resolve, reject) => {\r\n    //   objLoader.load(\r\n    //     filePath,\r\n    //     (node: any) => {\r\n    //       resolve(this.loadGroup(node));\r\n    //     },\r\n    //     undefined, reject\r\n    //   );\r\n    // });\r\n    if (this._objectCache.has(filePath)) {\r\n      return Promise.resolve(this._objectCache.get(filePath));\r\n    }\r\n    return new Promise((resolve, reject) => {\r\n      new MTLLoader()\r\n        .setPath(this._settingsService.settings.assetPath)\r\n        .load(mtlUrl, (materials) => {\r\n            materials.preload();\r\n            new OBJLoader()\r\n              .setMaterials(materials)\r\n              .setPath(this._settingsService.settings.assetPath)\r\n              .load(filePath, (object) => {\r\n                const obj: Object3D = this._cleanedUpObjects(object);\r\n                obj.traverse((child: Object3D | Mesh) => {\r\n                  if (child instanceof Mesh && child.material) {\r\n                    const material: any[] = !Array.isArray(child.material) ? [child.material] : child.material;\r\n                    material.forEach(m => {\r\n                      if (m.map) {\r\n                        m.map.colorSpace = SRGBColorSpace;\r\n                      }\r\n                    });\r\n                  }\r\n                });\r\n                this._objectCache.set(filePath, obj);\r\n                resolve(obj);\r\n              });\r\n          },\r\n          xhr => this._progressService.setLoaded(filePath, xhr.loaded)\r\n        );\r\n    });\r\n  }\r\n\r\n  public loadGlbModel(file: string, relativePath: boolean = true, cleanUp: boolean = true): Promise<Object3D> {\r\n    if (relativePath) {\r\n      file = this._settingsService.settings.assetPath + file;\r\n    }\r\n    if (this._objectCache.has(file)) {\r\n      return Promise.resolve(this._objectCache.get(file));\r\n    }\r\n    return new Promise((resolve: Function, reject: Function) => {\r\n      const loader = new GLTFLoader();\r\n      loader.setDRACOLoader(new DRACOLoader());\r\n      loader.dracoLoader.setDecoderPath(this._settingsService.settings.dracoPath);\r\n      loader.dracoLoader.setDecoderConfig({type: 'js'});\r\n      loader.load(file,\r\n        async object => {\r\n          // const obj: Object3D = new Object3D();\r\n          // object.scene.children.forEach((c: Object3D) => {\r\n          /*\r\n                      if (c instanceof Group) {\r\n                        c.children.forEach(gc => obj.add(gc.clone()));\r\n                      } else {\r\n          */\r\n          // reset origin of children for groups\r\n          // if (c instanceof Group) {\r\n          //   const boundingBox = new Box3().setFromObject(c);\r\n          //   const bbCenterPivot = new Vector3();\r\n          //   boundingBox.getCenter(bbCenterPivot);\r\n          //   const delta: Vector3 = new Vector3().add(bbCenterPivot).sub(new Vector3(0, c.position.y, 0));\r\n          //   c.children.forEach((cc) => {\r\n          //     cc.position.add(new Vector3(0, c.position.y, 0));\r\n          //   });\r\n          //   c.position.set(0, 0, 0);\r\n          // }\r\n          // }\r\n          // });\r\n          this.clips = object.animations || [];\r\n          const obj: Object3D = this._cleanedUpObjects(object.scene, cleanUp);\r\n          this._objectCache.set(file, obj);\r\n          resolve(obj);\r\n        },\r\n        xhr => this._progressService.setLoaded(file, xhr.loaded),\r\n        error => {\r\n          console.log('Error! ', error);\r\n          reject(error);\r\n        }\r\n      );\r\n    });\r\n  }\r\n\r\n  public loadGlbFromFile(file: ArrayBuffer): Promise<Object3D> {\r\n    return new Promise((resolve: Function, reject: Function) => {\r\n      const loader = new GLTFLoader();\r\n      loader.parse(file, '',\r\n        async object => {\r\n          resolve(object);\r\n        },\r\n        error => {\r\n          reject(error);\r\n        }\r\n      );\r\n    });\r\n  }\r\n\r\n  public loadGlbRoom(file: string): Promise<Object3D> {\r\n    if (this._objectCache.has(file)) {\r\n      return Promise.resolve(this._objectCache.get(file));\r\n    }\r\n    return new Promise(async (resolve: Function, reject: Function) => {\r\n      await this._progressService.prepareDownloads([{model_url: file}]);\r\n      const loader = new GLTFLoader();\r\n      loader.load(file,\r\n        async object => {\r\n          const obj: Object3D = object.scene;\r\n          obj.traverse(c => {\r\n            if (c.name.toLowerCase().indexOf('glas') < 0 && ((c.parent && c.parent.name.toLowerCase().indexOf('glas') < 0) || !c.parent)) {\r\n              c.castShadow = true;\r\n              c.receiveShadow = true;\r\n            }\r\n          });\r\n          this._objectCache.set(file, obj);\r\n          this._progressService.finishDownloads();\r\n          resolve(obj);\r\n        },\r\n        xhr => this._progressService.setLoaded(file, xhr.loaded),\r\n        error => {\r\n          console.log('Error! ', error);\r\n          this._progressService.finishDownloads();\r\n          reject(error);\r\n        }\r\n      );\r\n    });\r\n  }\r\n\r\n  public async saveRoomAsGlb(): Promise<void> {\r\n    const elementsToRemove = ['ground-plane', 'hud-ring', 'hud-circle', 'rotationCircle'];\r\n    let scene: Scene;\r\n    scene = this._sceneService.scene.clone();\r\n    scene.children.forEach(c => {\r\n      if (c instanceof Light) {\r\n        scene.remove(c);\r\n      }\r\n    });\r\n    elementsToRemove.forEach(elementName => {\r\n      const selectedObject: Object3D = scene.getObjectByName(elementName);\r\n      scene.remove(selectedObject);\r\n    });\r\n    scene.name = 'mrp_room';\r\n    this._download3DModelAsGLB(scene);\r\n  }\r\n\r\n  public async prepRoomForRender(standalone: boolean = false, renderParameters: any): Promise<void> {\r\n    const camera: PerspectiveCamera = this._cameraService.camera;\r\n    const elementsToRemove = ['ground-plane', 'hud-ring', 'hud-circle', 'rotationCircle'];\r\n    if (standalone) {\r\n      elementsToRemove.push('floor-plane');\r\n    }\r\n    let scene: Scene;\r\n    scene = this._sceneService.scene.clone();\r\n    scene.children.forEach(c => {\r\n      if (c instanceof Light) {\r\n        scene.remove(c);\r\n      }\r\n      if (c.name && c.name.indexOf('edge') > -1) { // walls should all be visible\r\n        c.traverse(cc => {\r\n          if (cc instanceof Mesh && cc.material) {\r\n            if (Array.isArray(cc.material)) {\r\n              cc.material.forEach(m => {\r\n                m.opacity = 0;\r\n                m.transparent = false;\r\n                m.depthWrite = true;\r\n                m.depthTest = true;\r\n              });\r\n            } else {\r\n              cc.material.opacity = 0;\r\n              cc.material.transparent = false;\r\n              cc.material.depthWrite = true;\r\n              cc.material.depthTest = true;\r\n            }\r\n          }\r\n        });\r\n      }\r\n    });\r\n    elementsToRemove.forEach(elementName => {\r\n      const selectedObject: Object3D = scene.getObjectByName(elementName);\r\n      scene.remove(selectedObject);\r\n    });\r\n    scene.name = 'mrp_room_' + scene.uuid;\r\n    this._createGLBForAPI(scene, camera, standalone, renderParameters);\r\n  }\r\n\r\n  private _createGLBForAPI(object: Object3D, camera: PerspectiveCamera, standalone: boolean, renderParameters: any): void {\r\n    const options = {\r\n      trs: false,\r\n      onlyVisible: true,\r\n      truncateDrawRange: true,\r\n      binary: true,\r\n      maxTextureSize: Infinity\r\n    };\r\n\r\n    this._gltfExporter.parse(object, (result: ArrayBuffer) => {\r\n      // const file = new Blob([result], {type: 'application/octet-stream'});\r\n      const filename: string = `${object.name}.glb`;\r\n      const file = new File([result], filename, {\r\n        type: 'model/gltf-binary',\r\n      });\r\n      this._sendFileToApi(file, filename, camera, standalone, renderParameters);\r\n    }, () => {\r\n    }, options);\r\n  }\r\n\r\n  private _sendFileToApi(file: File, filename: string, camera: PerspectiveCamera, standalone: boolean, renderParameters: any) {\r\n    const formData: FormData = new FormData();\r\n    formData.append('glb', file);\r\n    this.apiServiceModule.uploadToApiGLB(formData, filename, camera, standalone, renderParameters);\r\n  }\r\n\r\n\r\n  public async loadGlbSource(file: string): Promise<Object3D> {\r\n    const obj = await this.loadGlbModel(file, false, false);\r\n    obj.children = obj.children.filter(c => !(c instanceof Camera));\r\n    obj.children.sort((a, b) => a['name'] < b['name'] ? 1 : -1);\r\n    obj.children.forEach((c: Object3D) => {\r\n      c.traverse((t: Object3D) => {\r\n        t.visible = !t.name.toLowerCase().startsWith('c_') && !t.name.toLowerCase().startsWith('p_');\r\n      });\r\n      c.visible = false;\r\n    });\r\n    if (obj.children.length === 1 && obj.children[0] instanceof Group) { // flatten children\r\n      const children: any = obj.children[0].children.slice();\r\n      const name: string = obj.children[0].name;\r\n      obj.children.length = 0;\r\n      const parent: Object3D = new Object3D();\r\n      parent.name = name;\r\n      parent.children = children;\r\n      obj.add(parent);\r\n    }\r\n    return obj;\r\n  }\r\n\r\n  public showExportDialog(object: Object3D): void {\r\n    const exportDialog = this._dialog.open(ExportDialogComponent, {\r\n      width: '400px'\r\n    });\r\n    exportDialog.afterClosed().subscribe(async (type: ExportType) => {\r\n      if (type) {\r\n        if (type === ExportType.GLB) {\r\n          this._download3DModelAsGLB(object);\r\n        } else if (type === ExportType.USDZ) {\r\n          this._download3DModelAsUSDZ(object);\r\n        } else if (type === ExportType.BOTH) {\r\n          this._download3DModelAsUSDZ(object);\r\n          this._download3DModelAsGLB(object);\r\n        }\r\n      }\r\n    });\r\n  }\r\n\r\n  public async textureFromUrl(url: string): Promise<any> {\r\n    // url = this._includeBaseUrl(url);\r\n    return new Promise((resolve, reject) => {\r\n      const textureLoader = new TextureLoader();\r\n      // textureLoader.setBaseU(this._settingsService.settings.assetPath);\r\n      textureLoader.load(url,\r\n        (texture: Texture) => {\r\n          texture.wrapT = RepeatWrapping;\r\n          texture.wrapS = RepeatWrapping;\r\n          texture.repeat.set(1, 1);\r\n          texture.needsUpdate = true;\r\n          return resolve(texture);\r\n        },\r\n        null,\r\n        reject\r\n      );\r\n    });\r\n  }\r\n\r\n  public forceChangeDetection(cd: ChangeDetectorRef, component: any, propName: string): void {\r\n    const value = component[propName];\r\n    component[propName] = null;\r\n    cd.detectChanges();\r\n    component[propName] = value;\r\n  }\r\n\r\n  public getKTX2Loader(): KTX2Loader {\r\n    this._ktx2Loader.detectSupport(this._sceneService.renderer);\r\n    return this._ktx2Loader;\r\n  }\r\n\r\n  private _download3DModelAsGLB(object: Object3D): void {\r\n    const options = {\r\n      trs: false,\r\n      onlyVisible: true,\r\n      truncateDrawRange: true,\r\n      binary: true,\r\n      maxTextureSize: Infinity\r\n    };\r\n\r\n    this._gltfExporter.parse(object, (result: ArrayBuffer) => {\r\n      const file = new Blob([result], {type: 'application/octet-stream'});\r\n      this._downloadFile(`${object.name}.glb`, file);\r\n    }, () => {\r\n    }, options);\r\n  }\r\n\r\n  private async _download3DModelAsUSDZ(object: Object3D): Promise<void> {\r\n    // const arraybuffer: any =  await this._usdzExporter.parse(object);\r\n    // const blob: Blob = new Blob([arraybuffer], {type: 'application/octet-stream'});\r\n\r\n    const exporter = new USDZExporter();\r\n    const arraybuffer = await exporter.parseAsync(object);\r\n    const blob = new Blob([arraybuffer], {type: 'application/octet-stream'});\r\n\r\n\r\n    this._downloadFile(`${object.name}.usdz`, blob);\r\n  }\r\n\r\n  private _downloadFile(fileName: string, blob: Blob): void {\r\n    const element: HTMLAnchorElement = document.createElement('a');\r\n    element.style.display = 'none';\r\n\r\n    element.href = URL.createObjectURL(blob);\r\n    element.download = fileName;\r\n    document.body.appendChild(element);\r\n    element.click();\r\n    document.body.removeChild(element);\r\n  }\r\n\r\n  private _loadGroup(node: any): Group {\r\n    const group: Group = node.detail.loaderRootNode;\r\n    if (group.children.length > 1) {\r\n      group.children.forEach((mesh: Mesh) => {\r\n        mesh.position.copy(this._absPosition(mesh));\r\n      });\r\n    }\r\n    return group;\r\n  }\r\n\r\n\r\n  private _cleanedUpObjects(object: Object3D, cleanUp: boolean = true): Object3D {\r\n    let obj: Object3D = new Object3D();\r\n    // console.log(this.clips);\r\n    object.children.forEach((c: Object3D) => {\r\n      if (!(c instanceof Camera)) {\r\n        if (cleanUp && c instanceof Group || (c.children.length === 1 && c.children[0] instanceof Group)) {\r\n          this._addGroupChildrenToObject(c, obj);\r\n        } else if ((cleanUp && !(c instanceof Mesh)) || (!(c instanceof Mesh) && !c.name && c.children.length > 0)) {\r\n          c.children.forEach((child) => {\r\n            child.translateY(c.position.y);\r\n          });\r\n          c.translateY(-c.position.y);\r\n          if (obj.children.length > 0) {\r\n            obj.add(c.clone());\r\n          } else {\r\n            obj = c.clone();\r\n          }\r\n        } else {\r\n          // if (c.position.y > 0 || c.position.y < 0) {\r\n          //   c.children.forEach((child) => {\r\n          //     child.translateY(c.position.y);\r\n          //   });\r\n          //   c.translateY(-c.position.y);\r\n          // }\r\n          obj.add(c.clone());\r\n        }\r\n      }\r\n    });\r\n    const boundingBox = new Box3().setFromObject(obj);\r\n    const bbCenterPivot = new Vector3();\r\n    boundingBox.getCenter(bbCenterPivot);\r\n    const delta: Vector3 = new Vector3().add(bbCenterPivot).negate();\r\n    obj.children.forEach((cc) => {\r\n      cc.position.add(delta);\r\n    });\r\n    return obj;\r\n  }\r\n\r\n  private _addGroupChildrenToObject(group: Object3D, obj: Object3D, cleanUp: boolean = true): void {\r\n    group.children.forEach((gc: Object3D) => {\r\n      if (cleanUp && gc instanceof Group) {\r\n        this._addGroupChildrenToObject(gc, obj);\r\n      } else {\r\n        // gc.translateX(-group.position.x);\r\n        gc.translateY(group.position.y);\r\n        // gc.translateZ(-group.position.z);\r\n        obj.add(gc.clone());\r\n      }\r\n    });\r\n  }\r\n\r\n  private _iterateChildren(children: Object3D[], callback: (child: Mesh) => {}): void {\r\n    for (let i = 0; i < children.length; i++) {\r\n      const child: Object3D = children[i];\r\n      if (child instanceof Mesh) {\r\n        callback(child);\r\n      } else {\r\n        this._iterateChildren(child.children, callback);\r\n      }\r\n    }\r\n  }\r\n\r\n  private _includeBaseUrl(url: string): string {\r\n    if (url[0] === '.') {\r\n      url = url.replace('.', '');\r\n    }\r\n    if (url[0] === '/') {\r\n      url = url.replace('/', '');\r\n    }\r\n    return this._settingsService.settings.assetPath + url;\r\n  }\r\n\r\n  private _clearCache(): void {\r\n    const objs: Object3D[] = Array.from(this._objectCache.values());\r\n    objs.forEach(o => Utils.DisposeObject(o));\r\n    this._objectCache.clear();\r\n  }\r\n\r\n}\r\n"]}