@colijnit/homedecorator 255.1.1

package/esm2015/app/plugins/model-uploader/model-previewer/model-preview.component.js

@@ -0,0 +1,470 @@
+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 { Component, Inject, ViewChild } from '@angular/core';
+import { MAT_DIALOG_DATA } from '@angular/material/dialog';
+import * as THREE from 'three';
+import { AmbientLight, BoxGeometry, DirectionalLight, Light, LinearSRGBColorSpace, Mesh, MeshBasicMaterial, PCFSoftShadowMap, PerspectiveCamera, PlaneGeometry, PMREMGenerator, PointLight, Scene, Vector3, WebGLRenderer } from 'three';
+import { FloatType, LinearToneMapping } from 'three/src/constants';
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader';
+import { RGBELoader } from 'three/examples/jsm/loaders/RGBELoader';
+import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls';
+import { GLTFExporter } from 'three/examples/jsm/exporters/GLTFExporter';
+import { FBXLoader } from 'three/examples/jsm/loaders/FBXLoader';
+import { OBJLoader } from 'three/examples/jsm/loaders/OBJLoader';
+import { TDSLoader } from 'three/examples/jsm/loaders/TDSLoader';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../core/service/homedecorator-settings.service";
+import * as i2 from "@angular/material/dialog";
+import * as i3 from "../../threedselector/threedselector/service/third-party-model.service";
+import * as i4 from "../../../core/service/message-bus.service";
+import * as i5 from "../../../core/service/homedecorator-connector-adapter.service";
+import * as i6 from "@angular/material/radio";
+import * as i7 from "@angular/common";
+export class ModelPreviewComponent {
+    constructor(data, settingsService, _dialogRef, _thirdPartyModelService, _messageService, _dialog, _adapterService) {
+        this.data = data;
+        this.settingsService = settingsService;
+        this._dialogRef = _dialogRef;
+        this._thirdPartyModelService = _thirdPartyModelService;
+        this._messageService = _messageService;
+        this._dialog = _dialog;
+        this._adapterService = _adapterService;
+        this.unitsOfMeasurement = 'cm';
+        this.mathPi = Math.PI;
+    }
+    ngOnInit() {
+        this.initScene();
+        this.loadModel(this.data);
+    }
+    ngOnDestroy() {
+    }
+    initScene() {
+        // init scene
+        this.scenePreview = new Scene();
+        // init renderer
+        const canvReference = document.getElementById('canvasContainer');
+        const canvasElement = document.createElement('canvas');
+        const context = canvasElement.getContext('webgl2', { antialias: true });
+        this.rendererPreview = new WebGLRenderer({
+            canvas: canvasElement,
+            context: context,
+            alpha: true,
+            antialias: true,
+            preserveDrawingBuffer: true,
+            logarithmicDepthBuffer: true
+        });
+        this.rendererPreview.setPixelRatio(window.devicePixelRatio);
+        this.rendererPreview.setClearColor(0xfafafa);
+        this.rendererPreview.autoClear = false;
+        this.rendererPreview.toneMapping = LinearToneMapping;
+        this.rendererPreview.shadowMap.enabled = true;
+        this.rendererPreview.shadowMap.type = PCFSoftShadowMap;
+        this.rendererPreview.outputColorSpace = LinearSRGBColorSpace;
+        canvReference.appendChild(this.rendererPreview.domElement);
+        this.rendererPreview.domElement.setAttribute('id', 'threed');
+        this.rendererPreview.setSize(window.innerWidth / 2, window.innerHeight / 2, true);
+        // init camera
+        this.cameraPreview = new PerspectiveCamera(45, 1, 0.01, 10000);
+        this.cameraPreview.position.set(0, 2, 10);
+        this.cameraPreview.aspect = window.innerWidth / window.innerHeight;
+        this.cameraPreview.updateProjectionMatrix();
+        this.controls = new OrbitControls(this.cameraPreview, this.rendererPreview.domElement);
+        this.controls.update();
+        const box1geo = new BoxGeometry(1, 1, 1);
+        const box1 = new Mesh(box1geo, new MeshBasicMaterial({ color: 0x0000ff }));
+        box1.position.set(3, 0.5, 3);
+        box1.castShadow = true;
+        box1.receiveShadow = true;
+        box1.name = 'Reference_model';
+        this.scenePreview.add(box1);
+        const planeGeometry = new PlaneGeometry(10, 10);
+        const planeMaterial = new MeshBasicMaterial({ color: 0xFAF9F6, side: THREE.DoubleSide });
+        const plane = new Mesh(planeGeometry, planeMaterial);
+        plane.rotation.x = -Math.PI / 2;
+        plane.position.y = 0;
+        plane.name = 'floor_plane';
+        this.scenePreview.add(plane);
+        // Add some basic lights for when models contains MeshLambertMaterial
+        const ambientLight = new AmbientLight(0x404040);
+        this.scenePreview.add(ambientLight);
+        const directionalLight = new DirectionalLight(0xffffff, 8);
+        directionalLight.position.set(0, 10, 0);
+        directionalLight.castShadow = true;
+        this.scenePreview.add(directionalLight);
+        const pointLight = new PointLight(0xffffff, 1, 100);
+        pointLight.position.set(0, 5, 5);
+        this.scenePreview.add(pointLight);
+        // basic hdri lighting
+        const hdriPath = '/assets/hdri/std_env_v2_A.hdr';
+        this.loadHDRI(hdriPath).then(() => {
+            // console.log('HDRI loaded successfully.');
+        }).catch((error) => {
+            // console.error('Error loading HDRI:', error);
+        });
+        this._animate();
+    }
+    loadModel(input) {
+        this.modelName = this._setModelName(input.file.file.name);
+        const fileType = input.file.fileType.toLowerCase();
+        if (fileType === 'glb' || fileType === 'gltf') {
+            this._glbLoader(input);
+        }
+        else if (fileType === 'fbx') {
+            this._fbxLoader(input);
+        }
+        else if (fileType === 'obj') {
+            this._objLoader(input);
+        }
+        else if (fileType === '3ds') {
+            this._tdsLoader(input);
+        }
+    }
+    loadHDRI(path) {
+        return new Promise((resolve, reject) => {
+            new RGBELoader().setDataType(FloatType).load(path, (hdrTexture) => {
+                const pmremGenerator = new PMREMGenerator(this.rendererPreview);
+                pmremGenerator.compileEquirectangularShader();
+                const hdrCubeRenderTarget = pmremGenerator.fromEquirectangular(hdrTexture);
+                hdrTexture.dispose();
+                this.scenePreview.environment = hdrCubeRenderTarget.texture;
+                // this.scenePreview.background = hdrCubeRenderTarget.texture;
+                pmremGenerator.dispose();
+                resolve();
+            }, undefined, reject);
+        });
+    }
+    exportSceneAsGLB(returnType) {
+        // add timestamp
+        const timestamp = new Date().getTime();
+        const exportFileName = this._setModelName(this.glbExportName.nativeElement.value) + '_' + timestamp;
+        const elementsToRemove = ['Reference_model', 'floor_plane'];
+        const gltfExporter = new GLTFExporter();
+        let scene;
+        scene = this.scenePreview.clone();
+        scene.environment.dispose();
+        scene.children.forEach(c => {
+            if (c instanceof Light) {
+                scene.remove(c);
+            }
+        });
+        elementsToRemove.forEach(elementName => {
+            const selectedObject = scene.getObjectByName(elementName);
+            scene.remove(selectedObject);
+        });
+        const options = {
+            trs: false,
+            onlyVisible: true,
+            truncateDrawRange: true,
+            binary: true,
+            maxTextureSize: Infinity
+        };
+        gltfExporter.parse(scene, (result) => {
+            const file = new Blob([result], { type: 'application/octet-stream' });
+            if (returnType === 'upload') {
+                this._sendModelToCDN(`${exportFileName}.glb`, file);
+            }
+            else {
+                this._downloadModel(`${exportFileName}.glb`, file);
+            }
+        }, () => {
+        }, options);
+    }
+    scaleArticle() {
+        const inputHeight = this.heightArticle.nativeElement.value;
+        let heightInMeter;
+        if (this.unitsOfMeasurement === 'cm') {
+            heightInMeter = inputHeight / 100;
+        }
+        else if (this.unitsOfMeasurement === 'inches') {
+            heightInMeter = (inputHeight * 2.54) / 100;
+        }
+        // scale = this.bounding / heightInMeter and use Y as up/ height
+        const scale = this.boundingBoxSize.y / heightInMeter;
+        this.scenePreview.getObjectByName(this.modelName).scale.set(this.scenePreview.children[0].scale.x / scale, this.scenePreview.children[0].scale.y / scale, this.scenePreview.children[0].scale.z / scale);
+    }
+    rotateModel(axis, degrees) {
+        const model = this.scenePreview.getObjectByName(this.modelName);
+        if (axis === 'x') {
+            model.rotation.x += degrees;
+        }
+        else if (axis === 'y') {
+            model.rotation.y += degrees;
+        }
+        else if (axis === 'z') {
+            model.rotation.z += degrees;
+        }
+        this._getBoundingBox(model);
+    }
+    setUnit(event) {
+        this.unitsOfMeasurement = event.value;
+    }
+    _animate() {
+        setTimeout(() => {
+            this.rendererPreview.setAnimationLoop((timestamp, frame) => this._render(timestamp, frame));
+        }, 200);
+    }
+    _render(t, frame) {
+        this.rendererPreview.render(this.scenePreview, this.cameraPreview);
+    }
+    _downloadModel(fileName, blob) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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);
+        });
+    }
+    _sendModelToCDN(fileName, blob) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._blobToArrayBuffer(blob).then(file => {
+                this._adapterService.store3DModelCDN(fileName, file).then(filePath => {
+                    console.log(filePath);
+                });
+            });
+            // const hash: string = fileName;
+            // const modelUrl: string = ''; // Set url from the CDN
+            // const configurationData: any = {};
+            // const priceData: any = {};
+            // // const metaData: Metadata = new Metadata();
+            // // We also can set the metadata here and pas it as the last argument for parseModelToGLB.
+            //
+            // await this._thirdPartyModelService.parseModelToGLB(file, hash, modelUrl, configurationData, priceData);
+            // this._dialog.closeAll();
+            // this._messageService.emit(MessageType.HideProductCatalog);
+        });
+    }
+    _setModelName(name) {
+        const removeExtension = name.replace('.glb', ''); // remove .glb as file extension
+        return removeExtension.replace('.', '-'); // replace all dots for periods
+    }
+    _glbLoader(input) {
+        const loader = new GLTFLoader();
+        loader.parse(input.file.fileContents, '', (object) => __awaiter(this, void 0, void 0, function* () {
+            object.scene.name = this.modelName;
+            object.scene.position.set(0, 0, 0);
+            object.scene.scale.set(1, 1, 1);
+            this.scenePreview.add(object.scene);
+            this.loadedModel = object.scene;
+            this._getBoundingBox(object.scene);
+        }), error => {
+            console.log('Parsing error');
+        });
+    }
+    _fbxLoader(input) {
+        const fbxLoader = new FBXLoader();
+        const object = fbxLoader.parse(input.file.fileContents, '');
+        object.name = this.modelName;
+        object.position.set(0, 0, 0);
+        object.scale.set(1, 1, 1);
+        this.scenePreview.add(object);
+        this.loadedModel = object;
+        this._getBoundingBox(object);
+    }
+    _objLoader(input) {
+        const objLoader = new OBJLoader();
+        // for ojb files: convert the ArrayBuffer to a string
+        const buf = input.file.fileContents;
+        const decoder = new TextDecoder();
+        const str = decoder.decode(buf);
+        const object = objLoader.parse(str);
+        object.name = this.modelName;
+        object.position.set(0, 0, 0);
+        object.scale.set(1, 1, 1);
+        this.scenePreview.add(object);
+        this.loadedModel = object;
+        this._getBoundingBox(object);
+    }
+    _tdsLoader(input) {
+        const tdsLoader = new TDSLoader();
+        const object = tdsLoader.parse(input.file.fileContents, '');
+        object.name = this.modelName;
+        object.position.set(0, 0, 0);
+        object.scale.set(1, 1, 1);
+        this.scenePreview.add(object);
+        this.loadedModel = object;
+        this._getBoundingBox(object);
+    }
+    _getBoundingBox(object) {
+        const boundingBox = new THREE.Box3().setFromObject(object);
+        this.boundingBoxSize = boundingBox.getSize(new Vector3());
+    }
+    _blobToArrayBuffer(blob) {
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onload = () => {
+                if (reader.result) {
+                    resolve(reader.result);
+                }
+                else {
+                    reject(new Error('Error reading blob as ArrayBuffer'));
+                }
+            };
+            reader.onerror = () => {
+                reject(new Error('Failed to read blob as ArrayBuffer'));
+            };
+            reader.readAsArrayBuffer(blob);
+        });
+    }
+}
+ModelPreviewComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ModelPreviewComponent, deps: [{ token: MAT_DIALOG_DATA }, { token: i1.HomedecoratorSettingsService }, { token: i2.MatDialogRef }, { token: i3.ThirdPartyModelService }, { token: i4.MessageBusService }, { token: i2.MatDialog }, { token: i5.HomedecoratorConnectorAdapterService }], target: i0.ɵɵFactoryTarget.Component });
+ModelPreviewComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: ModelPreviewComponent, selector: "rp-model-preview", viewQueries: [{ propertyName: "glbExportName", first: true, predicate: ["fileName"], descendants: true }, { propertyName: "heightArticle", first: true, predicate: ["heightArticle"], descendants: true }], ngImport: i0, template: `
+    <div class="model-preview">
+      <div class="model-preview-container" id="canvasContainer">
+      </div>
+      <div class="model-preview-actions">
+        <div class="input-height-container">
+          <p>Centimeters of inches</p>
+          <div class="mat-radio-wrapper">
+            <mat-radio-group aria-label="Select an unit" (change)="setUnit($event)">
+              <mat-radio-button [checked]="true" value="cm">Height in cm</mat-radio-button>
+              <mat-radio-button value="inches">Height in inches</mat-radio-button>
+            </mat-radio-group>
+          </div>
+          <div>
+            <input type="text" id="heightArticle" #heightArticle>
+            <button (click)="scaleArticle()">scale</button>
+          </div>
+        </div>
+
+        <div class="rotation-button-container">
+          <p>Rotation</p>
+          <div class="rotation-x-buttons">
+            <button (click)="rotateModel('x', mathPi / 2)">x-as + 90 graden</button>
+            <button (click)="rotateModel('x', -mathPi / 2)">x-as - 90 graden</button>
+          </div>
+          <div class="rotation-y-buttons">
+            <button (click)="rotateModel('y', mathPi / 2)">y-as + 90 graden</button>
+            <button (click)="rotateModel('y', -mathPi / 2)">y-as - 90 graden</button>
+          </div>
+          <div class="rotation-z-buttons">
+            <button (click)="rotateModel('z', mathPi / 2)">z-as + 90 graden</button>
+            <button (click)="rotateModel('z', -mathPi / 2)">z-as - 90 graden</button>
+          </div>
+        </div>
+
+        <div class="model-preview-info" *ngIf="this.data">
+          <div class="model-preview-info-container">
+            <div class="model-preview-info-left">
+              <label>Name</label>
+            </div>
+            <div class="model-preview-info-right">
+              <input type="text" id="fileName" #fileName value="{{ this.data.file.file.name }}">
+            </div>
+          </div>
+          <div class="model-preview-info-container">
+            <div class="model-preview-info-left">
+              <label>Size</label>
+            </div>
+            <div class="model-preview-info-right">
+              <label>{{ this.data.file.file.size }}</label>
+            </div>
+          </div>
+          <div class="model-preview-info-container">
+            <div class="model-preview-info-left">
+              <label>Extension</label>
+            </div>
+            <div class="model-preview-info-right">
+              <label>{{ this.data.file.fileType }}</label>
+            </div>
+          </div>
+          <button class="exportButton" (click)="exportSceneAsGLB('upload')">Add to scene</button>
+          <p></p>
+          <button class="exportButton" (click)="exportSceneAsGLB('download')">Download</button>
+        </div>
+      </div>
+    </div>
+  `, isInline: true, styles: [".model-preview{display:flex;flex-direction:row}.model-preview .model-preview-actions{min-width:240px;box-sizing:border-box;padding:10px 20px;border-left:1px solid #5b6875}.model-preview .model-preview-actions .model-preview-info-container{margin-bottom:10px}.model-preview .model-preview-actions .model-preview-info-container .model-preview-info-left{font-weight:bolder}.model-preview .exportButton{cursor:pointer;color:#fff;background:#dda73f;border:1px solid #dda73f;border-radius:3px;box-sizing:border-box;padding:5px;display:flex;align-items:center}.model-preview .exportButton:hover{background:#dda73f;color:#fff}input{border:1px solid #5b6875;box-sizing:border-box;padding:3px 10px;border-radius:3px}.mat-radio-wrapper{margin:10px 0}mat-radio-group mat-radio-button{display:block}.rotation-button-container div{display:flex;justify-content:space-between;margin-bottom:10px}.rotation-button-container div button{cursor:pointer;color:#fff;background:#dda73f;border:1px solid #dda73f;border-radius:3px;box-sizing:border-box;padding:5px}.rotation-button-container div button:hover{background:#dda73f;color:#fff}\n"], components: [{ type: i6.MatRadioButton, selector: "mat-radio-button", inputs: ["disableRipple", "tabIndex"], exportAs: ["matRadioButton"] }], directives: [{ type: i6.MatRadioGroup, selector: "mat-radio-group", exportAs: ["matRadioGroup"] }, { type: i7.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ModelPreviewComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'rp-model-preview',
+                    template: `
+    <div class="model-preview">
+      <div class="model-preview-container" id="canvasContainer">
+      </div>
+      <div class="model-preview-actions">
+        <div class="input-height-container">
+          <p>Centimeters of inches</p>
+          <div class="mat-radio-wrapper">
+            <mat-radio-group aria-label="Select an unit" (change)="setUnit($event)">
+              <mat-radio-button [checked]="true" value="cm">Height in cm</mat-radio-button>
+              <mat-radio-button value="inches">Height in inches</mat-radio-button>
+            </mat-radio-group>
+          </div>
+          <div>
+            <input type="text" id="heightArticle" #heightArticle>
+            <button (click)="scaleArticle()">scale</button>
+          </div>
+        </div>
+
+        <div class="rotation-button-container">
+          <p>Rotation</p>
+          <div class="rotation-x-buttons">
+            <button (click)="rotateModel('x', mathPi / 2)">x-as + 90 graden</button>
+            <button (click)="rotateModel('x', -mathPi / 2)">x-as - 90 graden</button>
+          </div>
+          <div class="rotation-y-buttons">
+            <button (click)="rotateModel('y', mathPi / 2)">y-as + 90 graden</button>
+            <button (click)="rotateModel('y', -mathPi / 2)">y-as - 90 graden</button>
+          </div>
+          <div class="rotation-z-buttons">
+            <button (click)="rotateModel('z', mathPi / 2)">z-as + 90 graden</button>
+            <button (click)="rotateModel('z', -mathPi / 2)">z-as - 90 graden</button>
+          </div>
+        </div>
+
+        <div class="model-preview-info" *ngIf="this.data">
+          <div class="model-preview-info-container">
+            <div class="model-preview-info-left">
+              <label>Name</label>
+            </div>
+            <div class="model-preview-info-right">
+              <input type="text" id="fileName" #fileName value="{{ this.data.file.file.name }}">
+            </div>
+          </div>
+          <div class="model-preview-info-container">
+            <div class="model-preview-info-left">
+              <label>Size</label>
+            </div>
+            <div class="model-preview-info-right">
+              <label>{{ this.data.file.file.size }}</label>
+            </div>
+          </div>
+          <div class="model-preview-info-container">
+            <div class="model-preview-info-left">
+              <label>Extension</label>
+            </div>
+            <div class="model-preview-info-right">
+              <label>{{ this.data.file.fileType }}</label>
+            </div>
+          </div>
+          <button class="exportButton" (click)="exportSceneAsGLB('upload')">Add to scene</button>
+          <p></p>
+          <button class="exportButton" (click)="exportSceneAsGLB('download')">Download</button>
+        </div>
+      </div>
+    </div>
+  `,
+                    styleUrls: ['./model-preview.component.scss']
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MAT_DIALOG_DATA]
+                }] }, { type: i1.HomedecoratorSettingsService }, { type: i2.MatDialogRef }, { type: i3.ThirdPartyModelService }, { type: i4.MessageBusService }, { type: i2.MatDialog }, { type: i5.HomedecoratorConnectorAdapterService }]; }, propDecorators: { glbExportName: [{
+                type: ViewChild,
+                args: ['fileName']
+            }], heightArticle: [{
+                type: ViewChild,
+                args: ['heightArticle']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model-preview.component.js","sourceRoot":"","sources":["../../../../../../../src/client/app/plugins/model-uploader/model-previewer/model-preview.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, ElementRef, Inject, OnDestroy, OnInit, ViewChild} from '@angular/core';\r\nimport {HomedecoratorSettingsService} from '../../../core/service/homedecorator-settings.service';\r\nimport {MAT_DIALOG_DATA, MatDialog, MatDialogRef} from '@angular/material/dialog';\r\n\r\nimport * as THREE from 'three';\r\nimport {\r\n  AmbientLight,\r\n  BoxGeometry,\r\n  DirectionalLight,\r\n  Light,\r\n  LinearSRGBColorSpace,\r\n  Mesh,\r\n  MeshBasicMaterial,\r\n  Object3D,\r\n  PCFSoftShadowMap,\r\n  PerspectiveCamera,\r\n  PlaneGeometry,\r\n  PMREMGenerator,\r\n  PointLight,\r\n  Scene,\r\n  Vector3,\r\n  WebGLRenderer\r\n} from 'three';\r\nimport {FloatType, LinearToneMapping} from 'three/src/constants';\r\nimport {GLTFLoader} from 'three/examples/jsm/loaders/GLTFLoader';\r\nimport {RGBELoader} from 'three/examples/jsm/loaders/RGBELoader';\r\nimport {OrbitControls} from 'three/examples/jsm/controls/OrbitControls';\r\nimport {GLTFExporter} from 'three/examples/jsm/exporters/GLTFExporter';\r\nimport {FBXLoader} from 'three/examples/jsm/loaders/FBXLoader';\r\nimport {OBJLoader} from 'three/examples/jsm/loaders/OBJLoader';\r\nimport {ThirdPartyModelService} from '../../threedselector/threedselector/service/third-party-model.service';\r\nimport {MessageBusService} from '../../../core/service/message-bus.service';\r\nimport {TDSLoader} from 'three/examples/jsm/loaders/TDSLoader';\r\nimport {HomedecoratorConnectorAdapterService} from '../../../core/service/homedecorator-connector-adapter.service';\r\n\r\n\r\n@Component({\r\n  selector: 'rp-model-preview',\r\n  template: `\r\n    <div class=\"model-preview\">\r\n      <div class=\"model-preview-container\" id=\"canvasContainer\">\r\n      </div>\r\n      <div class=\"model-preview-actions\">\r\n        <div class=\"input-height-container\">\r\n          <p>Centimeters of inches</p>\r\n          <div class=\"mat-radio-wrapper\">\r\n            <mat-radio-group aria-label=\"Select an unit\" (change)=\"setUnit($event)\">\r\n              <mat-radio-button [checked]=\"true\" value=\"cm\">Height in cm</mat-radio-button>\r\n              <mat-radio-button value=\"inches\">Height in inches</mat-radio-button>\r\n            </mat-radio-group>\r\n          </div>\r\n          <div>\r\n            <input type=\"text\" id=\"heightArticle\" #heightArticle>\r\n            <button (click)=\"scaleArticle()\">scale</button>\r\n          </div>\r\n        </div>\r\n\r\n        <div class=\"rotation-button-container\">\r\n          <p>Rotation</p>\r\n          <div class=\"rotation-x-buttons\">\r\n            <button (click)=\"rotateModel('x', mathPi / 2)\">x-as + 90 graden</button>\r\n            <button (click)=\"rotateModel('x', -mathPi / 2)\">x-as - 90 graden</button>\r\n          </div>\r\n          <div class=\"rotation-y-buttons\">\r\n            <button (click)=\"rotateModel('y', mathPi / 2)\">y-as + 90 graden</button>\r\n            <button (click)=\"rotateModel('y', -mathPi / 2)\">y-as - 90 graden</button>\r\n          </div>\r\n          <div class=\"rotation-z-buttons\">\r\n            <button (click)=\"rotateModel('z', mathPi / 2)\">z-as + 90 graden</button>\r\n            <button (click)=\"rotateModel('z', -mathPi / 2)\">z-as - 90 graden</button>\r\n          </div>\r\n        </div>\r\n\r\n        <div class=\"model-preview-info\" *ngIf=\"this.data\">\r\n          <div class=\"model-preview-info-container\">\r\n            <div class=\"model-preview-info-left\">\r\n              <label>Name</label>\r\n            </div>\r\n            <div class=\"model-preview-info-right\">\r\n              <input type=\"text\" id=\"fileName\" #fileName value=\"{{ this.data.file.file.name }}\">\r\n            </div>\r\n          </div>\r\n          <div class=\"model-preview-info-container\">\r\n            <div class=\"model-preview-info-left\">\r\n              <label>Size</label>\r\n            </div>\r\n            <div class=\"model-preview-info-right\">\r\n              <label>{{ this.data.file.file.size }}</label>\r\n            </div>\r\n          </div>\r\n          <div class=\"model-preview-info-container\">\r\n            <div class=\"model-preview-info-left\">\r\n              <label>Extension</label>\r\n            </div>\r\n            <div class=\"model-preview-info-right\">\r\n              <label>{{ this.data.file.fileType }}</label>\r\n            </div>\r\n          </div>\r\n          <button class=\"exportButton\" (click)=\"exportSceneAsGLB('upload')\">Add to scene</button>\r\n          <p></p>\r\n          <button class=\"exportButton\" (click)=\"exportSceneAsGLB('download')\">Download</button>\r\n        </div>\r\n      </div>\r\n    </div>\r\n  `,\r\n  styleUrls: ['./model-preview.component.scss']\r\n})\r\nexport class ModelPreviewComponent implements OnInit, OnDestroy {\r\n  public scenePreview: THREE.Scene;\r\n  public cameraPreview: THREE.PerspectiveCamera;\r\n  public rendererPreview: THREE.WebGLRenderer;\r\n  public controls: OrbitControls;\r\n  public boundingBoxSize: Vector3;\r\n  public loadedModel: any;\r\n  public unitsOfMeasurement: string = 'cm';\r\n  public modelName: string;\r\n  public mathPi: number = Math.PI;\r\n\r\n  @ViewChild('fileName') public glbExportName: ElementRef;\r\n  @ViewChild('heightArticle') public heightArticle: ElementRef;\r\n\r\n  constructor(\r\n    @Inject(MAT_DIALOG_DATA) public data: { file: any },\r\n    public settingsService: HomedecoratorSettingsService,\r\n    private _dialogRef: MatDialogRef<ModelPreviewComponent>,\r\n    private _thirdPartyModelService: ThirdPartyModelService,\r\n    private _messageService: MessageBusService,\r\n    private _dialog: MatDialog,\r\n    private _adapterService: HomedecoratorConnectorAdapterService,\r\n  ) {\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this.initScene();\r\n    this.loadModel(this.data);\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n\r\n  }\r\n\r\n  public initScene(): void {\r\n    // init scene\r\n    this.scenePreview = new Scene();\r\n    // init renderer\r\n    const canvReference: HTMLElement = document.getElementById('canvasContainer');\r\n    const canvasElement: HTMLCanvasElement = document.createElement('canvas');\r\n    const context: any = canvasElement.getContext('webgl2', {antialias: true});\r\n    this.rendererPreview = new WebGLRenderer({\r\n      canvas: canvasElement,\r\n      context: context,\r\n      alpha: true,\r\n      antialias: true,\r\n      preserveDrawingBuffer: true,\r\n      logarithmicDepthBuffer: true\r\n    });\r\n    this.rendererPreview.setPixelRatio(window.devicePixelRatio);\r\n    this.rendererPreview.setClearColor(0xfafafa);\r\n    this.rendererPreview.autoClear = false;\r\n    this.rendererPreview.toneMapping = LinearToneMapping;\r\n    this.rendererPreview.shadowMap.enabled = true;\r\n    this.rendererPreview.shadowMap.type = PCFSoftShadowMap;\r\n    this.rendererPreview.outputColorSpace = LinearSRGBColorSpace;\r\n    canvReference.appendChild(this.rendererPreview.domElement);\r\n    this.rendererPreview.domElement.setAttribute('id', 'threed');\r\n    this.rendererPreview.setSize(window.innerWidth / 2, window.innerHeight / 2, true);\r\n\r\n    // init camera\r\n    this.cameraPreview = new PerspectiveCamera(45, 1, 0.01, 10000);\r\n    this.cameraPreview.position.set(0, 2, 10);\r\n    this.cameraPreview.aspect = window.innerWidth / window.innerHeight;\r\n    this.cameraPreview.updateProjectionMatrix();\r\n\r\n    this.controls = new OrbitControls(this.cameraPreview, this.rendererPreview.domElement);\r\n    this.controls.update();\r\n\r\n    const box1geo = new BoxGeometry(1, 1, 1);\r\n    const box1 = new Mesh(box1geo, new MeshBasicMaterial({color: 0x0000ff}));\r\n    box1.position.set(3, 0.5, 3);\r\n    box1.castShadow = true;\r\n    box1.receiveShadow = true;\r\n    box1.name = 'Reference_model';\r\n    this.scenePreview.add(box1);\r\n\r\n    const planeGeometry: PlaneGeometry = new PlaneGeometry(10, 10);\r\n    const planeMaterial: MeshBasicMaterial = new MeshBasicMaterial({color: 0xFAF9F6, side: THREE.DoubleSide});\r\n    const plane = new Mesh(planeGeometry, planeMaterial);\r\n    plane.rotation.x = -Math.PI / 2;\r\n    plane.position.y = 0;\r\n    plane.name = 'floor_plane';\r\n    this.scenePreview.add(plane);\r\n\r\n    // Add some basic lights for when models contains MeshLambertMaterial\r\n    const ambientLight = new AmbientLight(0x404040);\r\n    this.scenePreview.add(ambientLight);\r\n\r\n    const directionalLight = new DirectionalLight(0xffffff, 8);\r\n    directionalLight.position.set(0, 10, 0);\r\n    directionalLight.castShadow = true;\r\n    this.scenePreview.add(directionalLight);\r\n\r\n    const pointLight = new PointLight(0xffffff, 1, 100);\r\n    pointLight.position.set(0, 5, 5);\r\n    this.scenePreview.add(pointLight);\r\n\r\n    // basic hdri lighting\r\n    const hdriPath: string = '/assets/hdri/std_env_v2_A.hdr';\r\n    this.loadHDRI(hdriPath).then((): void => {\r\n      // console.log('HDRI loaded successfully.');\r\n    }).catch((error) => {\r\n      // console.error('Error loading HDRI:', error);\r\n    });\r\n    this._animate();\r\n  }\r\n\r\n  public loadModel(input: any): void {\r\n    this.modelName = this._setModelName(input.file.file.name);\r\n    const fileType = input.file.fileType.toLowerCase();\r\n    if (fileType === 'glb' || fileType === 'gltf') {\r\n      this._glbLoader(input);\r\n    } else if (fileType === 'fbx') {\r\n      this._fbxLoader(input);\r\n    } else if (fileType === 'obj') {\r\n      this._objLoader(input);\r\n    } else if (fileType === '3ds') {\r\n      this._tdsLoader(input);\r\n    }\r\n  }\r\n\r\n  public loadHDRI(path: string): Promise<void> {\r\n    return new Promise<void>((resolve, reject) => {\r\n      new RGBELoader().setDataType(FloatType).load(path, (hdrTexture) => {\r\n        const pmremGenerator: PMREMGenerator = new PMREMGenerator(this.rendererPreview);\r\n        pmremGenerator.compileEquirectangularShader();\r\n        const hdrCubeRenderTarget = pmremGenerator.fromEquirectangular(hdrTexture);\r\n        hdrTexture.dispose();\r\n        this.scenePreview.environment = hdrCubeRenderTarget.texture;\r\n        // this.scenePreview.background = hdrCubeRenderTarget.texture;\r\n        pmremGenerator.dispose();\r\n        resolve();\r\n      }, undefined, reject);\r\n    });\r\n  }\r\n\r\n\r\n  public exportSceneAsGLB(returnType: string): void {\r\n    // add timestamp\r\n    const timestamp: number = new Date().getTime();\r\n    const exportFileName: string = this._setModelName(this.glbExportName.nativeElement.value) + '_' + timestamp;\r\n    const elementsToRemove: string[] = ['Reference_model', 'floor_plane'];\r\n    const gltfExporter: GLTFExporter = new GLTFExporter();\r\n    let scene: Scene;\r\n    scene = this.scenePreview.clone();\r\n    scene.environment.dispose();\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    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    gltfExporter.parse(scene, (result: ArrayBuffer) => {\r\n      const file: Blob = new Blob([result], {type: 'application/octet-stream'});\r\n      if (returnType === 'upload') {\r\n        this._sendModelToCDN(`${exportFileName}.glb`, file);\r\n      } else {\r\n        this._downloadModel(`${exportFileName}.glb`, file);\r\n      }\r\n\r\n    }, () => {\r\n    }, options);\r\n  }\r\n\r\n  public scaleArticle(): void {\r\n    const inputHeight = this.heightArticle.nativeElement.value;\r\n    let heightInMeter: number;\r\n    if (this.unitsOfMeasurement === 'cm') {\r\n      heightInMeter = inputHeight / 100;\r\n    } else if (this.unitsOfMeasurement === 'inches') {\r\n      heightInMeter = (inputHeight * 2.54) / 100;\r\n    }\r\n    // scale = this.bounding / heightInMeter and use Y as up/ height\r\n    const scale: number = this.boundingBoxSize.y / heightInMeter;\r\n    this.scenePreview.getObjectByName(this.modelName).scale.set(\r\n      this.scenePreview.children[0].scale.x / scale,\r\n      this.scenePreview.children[0].scale.y / scale,\r\n      this.scenePreview.children[0].scale.z / scale);\r\n  }\r\n\r\n  public rotateModel(axis: string, degrees: number): void {\r\n    const model = this.scenePreview.getObjectByName(this.modelName);\r\n    if (axis === 'x') {\r\n      model.rotation.x += degrees;\r\n    } else if (axis === 'y') {\r\n      model.rotation.y += degrees;\r\n    } else if (axis === 'z') {\r\n      model.rotation.z += degrees;\r\n    }\r\n    this._getBoundingBox(model);\r\n  }\r\n\r\n  public setUnit(event: any): void {\r\n    this.unitsOfMeasurement = event.value;\r\n  }\r\n\r\n  private _animate(): void {\r\n    setTimeout(() => {\r\n      this.rendererPreview.setAnimationLoop((timestamp, frame) => this._render(timestamp, frame));\r\n    }, 200);\r\n  }\r\n\r\n  private _render(t, frame) {\r\n    this.rendererPreview.render(this.scenePreview, this.cameraPreview);\r\n  }\r\n\r\n  private async _downloadModel(fileName: string, blob: Blob): Promise<void> {\r\n    const element: HTMLAnchorElement = document.createElement('a');\r\n    element.style.display = 'none';\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 async _sendModelToCDN(fileName: string, blob: Blob): Promise<void> {\r\n\r\n    this._blobToArrayBuffer(blob).then(file => {\r\n      this._adapterService.store3DModelCDN(fileName, file).then(filePath => {\r\n        console.log(filePath);\r\n      });\r\n    });\r\n\r\n\r\n    // const hash: string = fileName;\r\n    // const modelUrl: string = ''; // Set url from the CDN\r\n    // const configurationData: any = {};\r\n    // const priceData: any = {};\r\n    // // const metaData: Metadata = new Metadata();\r\n    // // We also can set the metadata here and pas it as the last argument for parseModelToGLB.\r\n    //\r\n    // await this._thirdPartyModelService.parseModelToGLB(file, hash, modelUrl, configurationData, priceData);\r\n    // this._dialog.closeAll();\r\n    // this._messageService.emit(MessageType.HideProductCatalog);\r\n  }\r\n\r\n  private _setModelName(name: string): string {\r\n    const removeExtension: string = name.replace('.glb', ''); // remove .glb as file extension\r\n    return removeExtension.replace('.', '-'); // replace all dots for periods\r\n  }\r\n\r\n  private _glbLoader(input: any): void {\r\n    const loader: GLTFLoader = new GLTFLoader();\r\n    loader.parse(input.file.fileContents, '',\r\n      async object => {\r\n        object.scene.name = this.modelName;\r\n        object.scene.position.set(0, 0, 0);\r\n        object.scene.scale.set(1, 1, 1);\r\n        this.scenePreview.add(object.scene);\r\n        this.loadedModel = object.scene;\r\n        this._getBoundingBox(object.scene);\r\n      },\r\n      error => {\r\n        console.log('Parsing error');\r\n      }\r\n    );\r\n  }\r\n\r\n  private _fbxLoader(input: any): void {\r\n    const fbxLoader: FBXLoader = new FBXLoader();\r\n    const object = fbxLoader.parse(input.file.fileContents, '');\r\n    object.name = this.modelName;\r\n    object.position.set(0, 0, 0);\r\n    object.scale.set(1, 1, 1);\r\n    this.scenePreview.add(object);\r\n    this.loadedModel = object;\r\n    this._getBoundingBox(object);\r\n  }\r\n\r\n  private _objLoader(input: any): void {\r\n    const objLoader: OBJLoader = new OBJLoader();\r\n    // for ojb files: convert the ArrayBuffer to a string\r\n    const buf = input.file.fileContents;\r\n    const decoder: TextDecoder = new TextDecoder();\r\n    const str: string = decoder.decode(buf);\r\n    const object = objLoader.parse(str);\r\n    object.name = this.modelName;\r\n    object.position.set(0, 0, 0);\r\n    object.scale.set(1, 1, 1);\r\n    this.scenePreview.add(object);\r\n    this.loadedModel = object;\r\n    this._getBoundingBox(object);\r\n  }\r\n\r\n  private _tdsLoader(input: any): void {\r\n    const tdsLoader: TDSLoader = new TDSLoader();\r\n    const object = tdsLoader.parse(input.file.fileContents, '');\r\n    object.name = this.modelName;\r\n    object.position.set(0, 0, 0);\r\n    object.scale.set(1, 1, 1);\r\n    this.scenePreview.add(object);\r\n    this.loadedModel = object;\r\n    this._getBoundingBox(object);\r\n  }\r\n\r\n  private _getBoundingBox(object) {\r\n    const boundingBox = new THREE.Box3().setFromObject(object);\r\n    this.boundingBoxSize = boundingBox.getSize(new Vector3());\r\n  }\r\n\r\n\r\n  private _blobToArrayBuffer(blob: Blob): Promise<ArrayBuffer> {\r\n    return new Promise((resolve, reject) => {\r\n      const reader = new FileReader();\r\n      reader.onload = () => {\r\n        if (reader.result) {\r\n          resolve(reader.result as ArrayBuffer);\r\n        } else {\r\n          reject(new Error('Error reading blob as ArrayBuffer'));\r\n        }\r\n      };\r\n      reader.onerror = () => {\r\n        reject(new Error('Failed to read blob as ArrayBuffer'));\r\n      };\r\n      reader.readAsArrayBuffer(blob);\r\n    });\r\n  }\r\n}\r\n\r\n"]}