@colijnit/homedecorator 255.1.1

package/esm2015/app/core/service/3dm-api.js

@@ -0,0 +1,246 @@
+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 { Euler, MathUtils, Quaternion, Vector3 } from 'three';
+import { MessageType } from '../enum/message-type.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "./homedecorator-connector.service";
+import * as i2 from "./message-bus.service";
+import * as i3 from "@angular/common/http";
+import * as i4 from "./homedecorator-settings.service";
+import * as i5 from "@angular/material/dialog";
+export class OutputSettings {
+}
+export class Camera {
+}
+export class CameraDOF {
+}
+var OutputType;
+(function (OutputType) {
+    OutputType[OutputType["Jpeg"] = 0] = "Jpeg";
+    OutputType[OutputType["Png"] = 1] = "Png";
+    OutputType[OutputType["Glb"] = 2] = "Glb";
+    OutputType[OutputType["Video"] = 3] = "Video";
+})(OutputType || (OutputType = {}));
+var RenderType;
+(function (RenderType) {
+    RenderType[RenderType["Realtime"] = 0] = "Realtime";
+    RenderType[RenderType["Raytrace"] = 1] = "Raytrace";
+})(RenderType || (RenderType = {}));
+export class ApiServiceModule {
+    constructor(iOneControllerService, messageService, _http, _settingsService, _dialog) {
+        this.iOneControllerService = iOneControllerService;
+        this.messageService = messageService;
+        this._http = _http;
+        this._settingsService = _settingsService;
+        this._dialog = _dialog;
+    }
+    uploadToApiGLB(formData, filename, camera, standalone, renderParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const apiUrl = this._settingsService.settings.uploadEndpoint;
+            const options = {};
+            this._sendRequest(apiUrl, formData, options).then(result => {
+                this.messageService.emit(MessageType.HideLoadingIndicator);
+                this.messageService.emit(MessageType.ShowLoadingIndicator, { title: 'Rendering...' });
+                this.requestRender(filename, camera, standalone, renderParameters);
+            }).catch(error => {
+                console.log(error);
+            });
+        });
+    }
+    requestRender(filename, camera, standalone, renderParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const apiUrl = this._settingsService.settings.renderEndpoint;
+            const options = this._setOptions();
+            let request;
+            if (standalone) {
+                request = this._createProductRenderRequestBody(filename, camera, renderParameters);
+            }
+            else {
+                request = this._createRenderRequestBody(filename, camera, renderParameters);
+            }
+            yield this._sendRequest(apiUrl, request, options).then(result => {
+                if (!standalone) {
+                    const downloadFilename = filename.replace('.glb', '.jpg');
+                    const element = document.createElement('a');
+                    element.style.display = 'none';
+                    element.href = URL.createObjectURL(result);
+                    element.download = downloadFilename;
+                    document.body.appendChild(element);
+                    element.click();
+                    document.body.removeChild(element);
+                    this.messageService.emit(MessageType.HideLoadingIndicator);
+                    this._dialog.closeAll();
+                }
+                else {
+                    const reader = new FileReader();
+                    reader.readAsDataURL(result);
+                    reader.onload = () => {
+                        const dataURL = reader.result;
+                        this.messageService.emit(MessageType.HideLoadingIndicator);
+                        this.messageService.emit(MessageType.BlenderRenderFileReady, dataURL);
+                        return dataURL;
+                    };
+                }
+            }).catch(err => {
+                console.log(err);
+            });
+        });
+    }
+    _sendRequest(url, body, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._http.post(`${url}`, body, options).toPromise();
+        });
+    }
+    _setOptions() {
+        const headers = {
+            'Content-Type': 'application/json',
+            'Access-Control-Request-Method': 'POST'
+        };
+        return { headers, responseType: 'blob', reportProgress: true };
+    }
+    _createRenderRequestBody(filename, camera, renderParameters) {
+        const postBody = {
+            clientId: this._settingsService.settings.renderApiClientId,
+            sceneSettings: {
+                sceneAssetId: renderParameters.sceneAssetId,
+                activeCameraId: 1
+            },
+            outputSettings: this._setOutputSettings(renderParameters),
+            content: {
+                materials: [],
+                cameras: [
+                    this._cameraSettings(camera)
+                ],
+                lights: [],
+                groups: [],
+                prefabs: [
+                    {
+                        id: 7,
+                        assetId: filename
+                    }
+                ]
+            }
+        };
+        return postBody;
+    }
+    _createProductRenderRequestBody(filename, camera, renderParameters) {
+        const postBody = {
+            clientId: this._settingsService.settings.renderApiClientId,
+            sceneSettings: {
+                sceneAssetId: renderParameters.sceneAssetId,
+                activeCameraId: 1
+            },
+            outputSettings: this._setProductOutputSettings(renderParameters),
+            content: {
+                materials: [],
+                cameras: [
+                    this._cameraProductSettings(camera)
+                ],
+                lights: [],
+                groups: [],
+                prefabs: [
+                    {
+                        id: 7,
+                        assetId: filename
+                    }
+                ]
+            }
+        };
+        return postBody;
+    }
+    _setOutputSettings(renderParameters) {
+        const outputSettings = new OutputSettings();
+        outputSettings.width = renderParameters.width;
+        outputSettings.height = renderParameters.height;
+        outputSettings.outputType = OutputType.Jpeg;
+        outputSettings.renderType = RenderType.Raytrace;
+        return outputSettings;
+    }
+    _setProductOutputSettings(renderParameters) {
+        const outputSettings = new OutputSettings();
+        outputSettings.width = renderParameters.width;
+        outputSettings.height = renderParameters.height;
+        outputSettings.outputType = OutputType.Jpeg;
+        outputSettings.renderType = RenderType.Realtime;
+        return outputSettings;
+    }
+    _calculateCameraPositionRotation(camera) {
+        const pos = new Vector3().copy(camera.position);
+        const quaternion = camera.quaternion;
+        const blenderQuat = new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), MathUtils.degToRad(90));
+        const euler = new Euler().setFromQuaternion(blenderQuat.multiply(quaternion), 'ZYX');
+        pos.applyAxisAngle(new Vector3(1, 0, 0), MathUtils.degToRad(90));
+        const rot = new Vector3(MathUtils.radToDeg(euler.x), MathUtils.radToDeg(euler.y), MathUtils.radToDeg(euler.z));
+        return {
+            'position': pos,
+            'rotation': rot
+        };
+    }
+    _setCameraRotation(cameraInfo) {
+        return {
+            position: {
+                set: {
+                    x: this._shortenValue(cameraInfo.position.x),
+                    y: this._shortenValue(cameraInfo.position.y),
+                    z: this._shortenValue(cameraInfo.position.z)
+                }
+            },
+            rotation: {
+                set: {
+                    x: this._shortenValue(cameraInfo.rotation.x),
+                    y: this._shortenValue(cameraInfo.rotation.y),
+                    z: this._shortenValue(cameraInfo.rotation.z)
+                }
+            }
+        };
+    }
+    _cameraSettings(camera) {
+        const cameraInfo = this._calculateCameraPositionRotation(camera);
+        const renderCamera = new Camera();
+        renderCamera.id = 1;
+        renderCamera.assetId = 'camera_colijn';
+        renderCamera.transform = this._setCameraRotation(cameraInfo);
+        return renderCamera;
+    }
+    _cameraProductSettings(camera) {
+        const cameraInfo = this._calculateCameraPositionRotation(camera);
+        const renderCamera = new Camera();
+        renderCamera.id = 1;
+        renderCamera.assetId = 'camera_colijn';
+        renderCamera.transform = this._setCameraRotation(cameraInfo);
+        renderCamera.fov = 90;
+        return renderCamera;
+    }
+    _getSceneBasedLights(sceneAssetId) {
+        if (sceneAssetId.includes('eevee')) {
+            return [{
+                    'id': 7,
+                    'assetId': 'lights_eevee'
+                }];
+        }
+        else {
+            return [];
+        }
+    }
+    _shortenValue(value) {
+        const factor = Math.pow(10, 5);
+        return Math.floor(value * factor) / factor;
+    }
+}
+ApiServiceModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ApiServiceModule, deps: [{ token: i1.HomedecoratorConnectorService }, { token: i2.MessageBusService }, { token: i3.HttpClient }, { token: i4.HomedecoratorSettingsService }, { token: i5.MatDialog }], target: i0.ɵɵFactoryTarget.Injectable });
+ApiServiceModule.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ApiServiceModule, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ApiServiceModule, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HomedecoratorConnectorService }, { type: i2.MessageBusService }, { type: i3.HttpClient }, { type: i4.HomedecoratorSettingsService }, { type: i5.MatDialog }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"3dm-api.js","sourceRoot":"","sources":["../../../../../../src/client/app/core/service/3dm-api.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from '@angular/core';\r\nimport {HttpClient} from '@angular/common/http';\r\nimport {Euler, MathUtils, PerspectiveCamera, Quaternion, Vector3} from 'three';\r\nimport {HomedecoratorSettingsService} from './homedecorator-settings.service';\r\nimport {MessageBusService} from './message-bus.service';\r\nimport {MessageType} from '../enum/message-type.enum';\r\nimport {MatDialog} from '@angular/material/dialog';\r\nimport {HomedecoratorConnectorService} from './homedecorator-connector.service';\r\n\r\nexport class OutputSettings {\r\n  public width: number;\r\n  public height: number;\r\n  public outputType: OutputType;\r\n  public transparency: boolean;\r\n  public quality: number;\r\n  public renderType: RenderType;\r\n  public duration: number;\r\n  public bounces: number;\r\n}\r\n\r\nexport class Camera {\r\n  id: number;\r\n  assetId: string; // for pre-created camera\r\n  fov: number; // or maybe lens in mm?\r\n  transform: any;\r\n  dof: CameraDOF;\r\n}\r\n\r\nexport class CameraDOF {\r\n  focalLength: number;\r\n  fStop: number;\r\n  blades: number;\r\n  rotation: number;\r\n}\r\n\r\nenum OutputType {\r\n  Jpeg = 0,\r\n  Png = 1,\r\n  Glb = 2,\r\n  Video = 3\r\n}\r\n\r\nenum RenderType {\r\n  Realtime = 0,\r\n  Raytrace = 1\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\n\r\nexport class ApiServiceModule {\r\n  constructor(\r\n    public iOneControllerService: HomedecoratorConnectorService,\r\n    public messageService: MessageBusService,\r\n    private _http: HttpClient,\r\n    private _settingsService: HomedecoratorSettingsService,\r\n    private _dialog: MatDialog,\r\n  ) {\r\n  }\r\n\r\n  public async uploadToApiGLB(formData: FormData, filename: string, camera: PerspectiveCamera, standalone: boolean, renderParameters: any): Promise<void> {\r\n    const apiUrl: string = this._settingsService.settings.uploadEndpoint;\r\n    const options: Object = {};\r\n    this._sendRequest(apiUrl, formData, options).then(result => {\r\n      this.messageService.emit(MessageType.HideLoadingIndicator);\r\n      this.messageService.emit(MessageType.ShowLoadingIndicator, {title: 'Rendering...'});\r\n      this.requestRender(filename, camera, standalone, renderParameters);\r\n    }).catch(error => {\r\n      console.log(error);\r\n    });\r\n  }\r\n\r\n  public async requestRender(filename: string, camera: PerspectiveCamera, standalone: boolean, renderParameters: any): Promise<any> {\r\n    const apiUrl: string = this._settingsService.settings.renderEndpoint;\r\n    const options: Object = this._setOptions();\r\n    let request: Object;\r\n\r\n    if (standalone) {\r\n      request = this._createProductRenderRequestBody(filename, camera, renderParameters);\r\n    } else {\r\n      request = this._createRenderRequestBody(filename, camera, renderParameters);\r\n    }\r\n    await this._sendRequest(apiUrl, request, options).then(result => {\r\n      if (!standalone) {\r\n        const downloadFilename: string = filename.replace('.glb', '.jpg');\r\n        const element: HTMLAnchorElement = document.createElement('a');\r\n        element.style.display = 'none';\r\n        element.href = URL.createObjectURL(result);\r\n        element.download = downloadFilename;\r\n        document.body.appendChild(element);\r\n        element.click();\r\n        document.body.removeChild(element);\r\n        this.messageService.emit(MessageType.HideLoadingIndicator);\r\n        this._dialog.closeAll();\r\n      } else {\r\n        const reader = new FileReader();\r\n        reader.readAsDataURL(<Blob>result);\r\n        reader.onload = () => {\r\n          const dataURL: string = reader.result as string;\r\n          this.messageService.emit(MessageType.HideLoadingIndicator);\r\n          this.messageService.emit(MessageType.BlenderRenderFileReady, dataURL);\r\n          return dataURL;\r\n        };\r\n      }\r\n    }).catch(err => {\r\n      console.log(err);\r\n    });\r\n  }\r\n\r\n  private async _sendRequest(url: string, body: any, options?: any): Promise<Object> {\r\n    return await this._http.post(`${url}`, body, options).toPromise();\r\n  }\r\n\r\n  private _setOptions(): Object {\r\n    const headers: Object = {\r\n      'Content-Type': 'application/json',\r\n      'Access-Control-Request-Method': 'POST'\r\n    };\r\n    return {headers, responseType: 'blob', reportProgress: true};\r\n  }\r\n\r\n  private _createRenderRequestBody(filename: string, camera: PerspectiveCamera, renderParameters: any): Object {\r\n    const postBody: any = {\r\n      clientId: this._settingsService.settings.renderApiClientId,\r\n      sceneSettings: {\r\n        sceneAssetId: renderParameters.sceneAssetId,\r\n        activeCameraId: 1\r\n      },\r\n      outputSettings: this._setOutputSettings(renderParameters),\r\n      content: {\r\n        materials: [],\r\n        cameras: [\r\n          this._cameraSettings(camera)\r\n        ],\r\n        lights: [],\r\n        groups: [],\r\n        prefabs: [\r\n          {\r\n            id: 7,\r\n            assetId: filename\r\n          }\r\n        ]\r\n      }\r\n    };\r\n    return postBody;\r\n  }\r\n\r\n  private _createProductRenderRequestBody(filename: string, camera: PerspectiveCamera, renderParameters: any): Object {\r\n    const postBody: any = {\r\n      clientId: this._settingsService.settings.renderApiClientId,\r\n      sceneSettings: {\r\n        sceneAssetId: renderParameters.sceneAssetId,\r\n        activeCameraId: 1\r\n      },\r\n      outputSettings: this._setProductOutputSettings(renderParameters),\r\n      content: {\r\n        materials: [],\r\n        cameras: [\r\n          this._cameraProductSettings(camera)\r\n        ],\r\n        lights: [],\r\n        groups: [],\r\n        prefabs: [\r\n          {\r\n            id: 7,\r\n            assetId: filename\r\n          }\r\n        ]\r\n      }\r\n    };\r\n    return postBody;\r\n  }\r\n\r\n  private _setOutputSettings(renderParameters): OutputSettings {\r\n    const outputSettings: OutputSettings = new OutputSettings();\r\n    outputSettings.width = renderParameters.width;\r\n    outputSettings.height = renderParameters.height;\r\n    outputSettings.outputType = OutputType.Jpeg;\r\n    outputSettings.renderType = RenderType.Raytrace;\r\n    return outputSettings;\r\n  }\r\n\r\n  private _setProductOutputSettings(renderParameters): OutputSettings {\r\n    const outputSettings: OutputSettings = new OutputSettings();\r\n    outputSettings.width = renderParameters.width;\r\n    outputSettings.height = renderParameters.height;\r\n    outputSettings.outputType = OutputType.Jpeg;\r\n    outputSettings.renderType = RenderType.Realtime;\r\n    return outputSettings;\r\n  }\r\n\r\n  private _calculateCameraPositionRotation(camera: PerspectiveCamera): any {\r\n    const pos: Vector3 = new Vector3().copy(camera.position);\r\n    const quaternion: Quaternion = camera.quaternion;\r\n    const blenderQuat: Quaternion = new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), MathUtils.degToRad(90));\r\n    const euler: Euler = new Euler().setFromQuaternion(\r\n      blenderQuat.multiply(quaternion),\r\n      'ZYX'\r\n    );\r\n    pos.applyAxisAngle(new Vector3(1, 0, 0), MathUtils.degToRad(90));\r\n    const rot: Vector3 = new Vector3(\r\n      MathUtils.radToDeg(euler.x),\r\n      MathUtils.radToDeg(euler.y),\r\n      MathUtils.radToDeg(euler.z)\r\n    );\r\n    return {\r\n      'position': pos,\r\n      'rotation': rot\r\n    };\r\n  }\r\n\r\n  private _setCameraRotation(cameraInfo: any): any {\r\n    return {\r\n      position: {\r\n        set: {\r\n          x: this._shortenValue(cameraInfo.position.x),\r\n          y: this._shortenValue(cameraInfo.position.y),\r\n          z: this._shortenValue(cameraInfo.position.z)\r\n        }\r\n      },\r\n      rotation: {\r\n        set: {\r\n          x: this._shortenValue(cameraInfo.rotation.x),\r\n          y: this._shortenValue(cameraInfo.rotation.y),\r\n          z: this._shortenValue(cameraInfo.rotation.z)\r\n        }\r\n      }\r\n    };\r\n  }\r\n\r\n  private _cameraSettings(camera: PerspectiveCamera): Camera {\r\n    const cameraInfo = this._calculateCameraPositionRotation(camera);\r\n    const renderCamera: Camera = new Camera();\r\n    renderCamera.id = 1;\r\n    renderCamera.assetId = 'camera_colijn';\r\n    renderCamera.transform = this._setCameraRotation(cameraInfo);\r\n    return renderCamera;\r\n  }\r\n\r\n  private _cameraProductSettings(camera: PerspectiveCamera): any {\r\n    const cameraInfo = this._calculateCameraPositionRotation(camera);\r\n    const renderCamera: Camera = new Camera();\r\n    renderCamera.id = 1;\r\n    renderCamera.assetId = 'camera_colijn';\r\n    renderCamera.transform = this._setCameraRotation(cameraInfo);\r\n    renderCamera.fov = 90;\r\n    return renderCamera;\r\n  }\r\n\r\n  private _getSceneBasedLights(sceneAssetId: string): any {\r\n    if (sceneAssetId.includes('eevee')) {\r\n      return [{\r\n        'id': 7,\r\n        'assetId': 'lights_eevee'\r\n      }];\r\n    } else {\r\n      return [];\r\n    }\r\n  }\r\n\r\n  private _shortenValue(value): number {\r\n    const factor: number = Math.pow(10, 5);\r\n    return Math.floor(value * factor) / factor;\r\n  }\r\n}\r\n"]}

package/esm2015/app/core/service/app-state.service.js

@@ -0,0 +1,128 @@
+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 * as applyPatch from 'textdiff-patch';
+import { Injectable } from '@angular/core';
+import { MessageType } from '../enum/message-type.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "./message-bus.service";
+const maxStates = 10;
+export class AppStateService {
+    constructor(messageBusService) {
+        this.messageBusService = messageBusService;
+        this.undoDisabled = false;
+        this.redoDisabled = false;
+        this._subs = [];
+        this._subs.push(this.messageBusService.subscribe(MessageType.Undo, () => this.undo()), this.messageBusService.subscribe(MessageType.Redo, () => this.redo()), this.messageBusService.subscribe(MessageType.ClearState, (value) => this.clearHistory(value)), this.messageBusService.subscribe(MessageType.ReplaceState, ({ data, title, url }) => this.replaceState(data, title, url)), this.messageBusService.subscribe(MessageType.SaveState, ({ action, patch }) => this.saveState(action, patch)));
+    }
+    ngOnDestroy() {
+        this._subs.forEach(s => s.unsubscribe());
+    }
+    init(stateApi, initialState) {
+        this.createStateFn = stateApi.createState;
+        this.applyStateFn = stateApi.applyState;
+        this.clearHistory(initialState);
+    }
+    canRedo() {
+        return !this.redoDisabled && this.applyStateFn && this.currentStateIndex < this.states.length - 1;
+    }
+    canUndo() {
+        return !this.undoDisabled && this.applyStateFn && this.currentStateIndex > 0;
+    }
+    clearHistory(initialState) {
+        this.states = [{ action: 'initial', value: initialState }];
+        this.currentStateIndex = 0;
+    }
+    replaceState(data, title, url) {
+        window.history.replaceState(data, title, url);
+    }
+    undo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.currentStateIndex -= 1;
+            yield this.applyStateFn(this.getValue(this.currentStateIndex));
+        });
+    }
+    redo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.currentStateIndex += 1;
+            yield this.applyStateFn(this.getValue(this.currentStateIndex));
+        });
+    }
+    // get value for `index`, apply patches if necessary
+    getValue(index) {
+        if (this.isValueState(this.states[index])) {
+            return this.states[index].value;
+        }
+        else {
+            return this.getPatched(index);
+        }
+    }
+    isValueState(state) {
+        return !!state.value;
+    }
+    findBaseStateIndex(index) {
+        for (let i = index - 1; i >= 0; --i) {
+            if (this.isValueState(this.states[i])) {
+                return i;
+            }
+        }
+    }
+    getPatched(index) {
+        if (this.isValueState(this.states[index])) {
+            return this.states[index].value;
+        }
+        const baseStateIndex = this.findBaseStateIndex(index);
+        const baseState = this.states[baseStateIndex];
+        const patches = this.states.slice(baseStateIndex + 1, index + 1);
+        return patches.reduce((value, patch) => applyPatch(value, patch.diff), baseState.value);
+    }
+    saveState(action, patch = true) {
+        if (this.createStateFn) {
+            const value = this.createStateFn();
+            if (this.currentStateIndex !== this.states.length - 1) {
+                this.states.splice(this.currentStateIndex + 1);
+            }
+            this.pushState(action, value, patch);
+            if (this.states.length > maxStates) {
+                this.shiftStates();
+            }
+            else {
+                this.currentStateIndex += 1;
+            }
+        }
+    }
+    // remove first state, make sure the new first state has a value
+    shiftStates() {
+        const oldBase = this.states.shift();
+        const newBase = this.states[0];
+        if (this.isValueState(newBase)) {
+            return;
+        }
+        const diff = newBase.diff;
+        newBase.value = applyPatch(oldBase.value, diff);
+        newBase.diff = null;
+    }
+    // add state - add a diff if possible
+    pushState(action, value, patch) {
+        if (!patch || this.states.length === 0) {
+            this.states.push({ action, value });
+            return;
+        }
+        this.states.push({ action, value });
+    }
+}
+AppStateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: AppStateService, deps: [{ token: i1.MessageBusService }], target: i0.ɵɵFactoryTarget.Injectable });
+AppStateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: AppStateService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: AppStateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MessageBusService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app-state.service.js","sourceRoot":"","sources":["../../../../../../src/client/app/core/service/app-state.service.ts"],"names":[],"mappings":"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","sourcesContent":["import * as applyPatch from 'textdiff-patch';\r\nimport {Injectable, OnDestroy} from '@angular/core';\r\nimport {Subscription} from 'rxjs';\r\nimport {MessageBusService} from './message-bus.service';\r\nimport {MessageType} from '../enum/message-type.enum';\r\n\r\nconst maxStates = 10;\r\n\r\nexport type StateValue = string;\r\ntype Action = string;\r\n\r\ntype CreateStateInterface = () => StateValue;\r\n\r\ntype ApplyStateInterface = (StateValue) => void;\r\n\r\ninterface StateApi {\r\n  createState: CreateStateInterface;\r\n  applyState: ApplyStateInterface;\r\n}\r\n\r\ninterface DiffState {\r\n  action: Action;\r\n  diff: any;\r\n}\r\n\r\ninterface ValueState {\r\n  action: Action;\r\n  value: StateValue;\r\n}\r\n\r\ntype State = DiffState | ValueState;\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class AppStateService implements OnDestroy {\r\n  createStateFn: CreateStateInterface;\r\n  applyStateFn: ApplyStateInterface;\r\n  states: State[];\r\n  currentStateIndex: number;\r\n\r\n  public undoDisabled: boolean = false;\r\n  public redoDisabled: boolean = false;\r\n\r\n  private _subs: Subscription[] = [];\r\n\r\n  constructor(private messageBusService: MessageBusService) {\r\n    this._subs.push(\r\n      this.messageBusService.subscribe(MessageType.Undo, () => this.undo()),\r\n      this.messageBusService.subscribe(MessageType.Redo, () => this.redo()),\r\n      this.messageBusService.subscribe(\r\n        MessageType.ClearState,\r\n        (value: StateValue) => this.clearHistory(value)\r\n      ),\r\n      this.messageBusService.subscribe(\r\n        MessageType.ReplaceState,\r\n        ({data, title, url}: { data: any, title: string, url?: string }) =>\r\n          this.replaceState(data, title, url)\r\n      ),\r\n      this.messageBusService.subscribe(\r\n        MessageType.SaveState,\r\n        ({action, patch}: { action: string, patch?: boolean }) => this.saveState(action, patch)\r\n      )\r\n    );\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this._subs.forEach(s => s.unsubscribe());\r\n  }\r\n\r\n  public init(stateApi: StateApi, initialState: StateValue) {\r\n    this.createStateFn = stateApi.createState;\r\n    this.applyStateFn = stateApi.applyState;\r\n    this.clearHistory(initialState);\r\n  }\r\n\r\n  public canRedo(): boolean {\r\n    return !this.redoDisabled && this.applyStateFn && this.currentStateIndex < this.states.length - 1;\r\n  }\r\n\r\n  public canUndo(): boolean {\r\n    return !this.undoDisabled && this.applyStateFn && this.currentStateIndex > 0;\r\n  }\r\n\r\n  private clearHistory(initialState: StateValue) {\r\n    this.states = [{action: 'initial', value: initialState}];\r\n    this.currentStateIndex = 0;\r\n  }\r\n\r\n  private replaceState(data: any, title: string, url?: string): void {\r\n    window.history.replaceState(data, title, url);\r\n  }\r\n\r\n  private async undo() {\r\n    this.currentStateIndex -= 1;\r\n    await this.applyStateFn(this.getValue(this.currentStateIndex));\r\n  }\r\n\r\n  private async redo() {\r\n    this.currentStateIndex += 1;\r\n    await this.applyStateFn(this.getValue(this.currentStateIndex));\r\n  }\r\n\r\n  // get value for `index`, apply patches if necessary\r\n  private getValue(index: number): StateValue {\r\n    if (this.isValueState(this.states[index])) {\r\n      return (this.states[index] as ValueState).value;\r\n    } else {\r\n      return this.getPatched(index);\r\n    }\r\n  }\r\n\r\n  private isValueState(state: State): boolean {\r\n    return !!(state as ValueState).value;\r\n  }\r\n\r\n  private findBaseStateIndex(index: number): number {\r\n    for (let i = index - 1; i >= 0; --i) {\r\n      if (this.isValueState(this.states[i])) {\r\n        return i;\r\n      }\r\n    }\r\n  }\r\n\r\n  private getPatched(index: number): StateValue {\r\n    if (this.isValueState(this.states[index])) {\r\n      return (this.states[index] as ValueState).value;\r\n    }\r\n    const baseStateIndex = this.findBaseStateIndex(index);\r\n    const baseState = this.states[baseStateIndex] as ValueState;\r\n    const patches = this.states.slice(baseStateIndex + 1, index + 1) as DiffState[];\r\n    return patches.reduce((value: StateValue, patch: DiffState) =>\r\n        applyPatch(value, patch.diff)\r\n      , baseState.value);\r\n  }\r\n\r\n  private saveState(action: Action, patch: boolean = true) {\r\n    if (this.createStateFn) {\r\n      const value = this.createStateFn();\r\n      if (this.currentStateIndex !== this.states.length - 1) {\r\n        this.states.splice(this.currentStateIndex + 1);\r\n      }\r\n      this.pushState(action, value, patch);\r\n      if (this.states.length > maxStates) {\r\n        this.shiftStates();\r\n      } else {\r\n        this.currentStateIndex += 1;\r\n      }\r\n    }\r\n  }\r\n\r\n  // remove first state, make sure the new first state has a value\r\n  private shiftStates() {\r\n    const oldBase = this.states.shift() as ValueState;\r\n    const newBase = this.states[0];\r\n    if (this.isValueState(newBase)) {\r\n      return;\r\n    }\r\n    const diff = (newBase as DiffState).diff;\r\n    (newBase as ValueState).value = applyPatch(oldBase.value, diff);\r\n    (newBase as DiffState).diff = null;\r\n  }\r\n\r\n  // add state - add a diff if possible\r\n  private pushState(action: Action, value: StateValue, patch: boolean) {\r\n    if (!patch || this.states.length === 0) {\r\n      this.states.push({action, value});\r\n      return;\r\n    }\r\n    this.states.push({action, value});\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,72 @@
+import { BehaviorSubject } from 'rxjs';
+import { Injectable } from '@angular/core';
+import { ConfigurationKey } from '../enum/configuration-key.enum';
+import { angleDegree, dimCentiMeter, dimSqMeter } from '../const/dimensioning';
+import * as i0 from "@angular/core";
+export class ConfigurationService {
+    constructor() {
+        this._data = {
+            [ConfigurationKey.DimensioningUnit]: dimCentiMeter,
+            [ConfigurationKey.DimensioningSquareUnit]: dimSqMeter,
+            [ConfigurationKey.AngleUnit]: angleDegree,
+            [ConfigurationKey.CmStep]: 1,
+            [ConfigurationKey.MStep]: .001,
+            [ConfigurationKey.MmStep]: 1,
+            [ConfigurationKey.AngleLabelDistanceInCm]: 50,
+            [ConfigurationKey.WallHeight]: 260,
+            [ConfigurationKey.WallThickness]: 10,
+            [ConfigurationKey.MaxWallHeight]: 300000,
+            [ConfigurationKey.MaxWallThickness]: 100,
+            [ConfigurationKey.MaxWallLength]: 300000,
+            [ConfigurationKey.MinWallLength]: 15,
+            [ConfigurationKey.WallSnapping]: true,
+            [ConfigurationKey.CornerSnapping]: true,
+            [ConfigurationKey.ShowObjectDistances]: false,
+            [ConfigurationKey.ShowObjectMeasurements]: false,
+            [ConfigurationKey.ShowDetailedWallMeasurements]: false,
+            [ConfigurationKey.ShowWallItemMeasurements]: true,
+            [ConfigurationKey.RotationSnappingEnabled]: true,
+            [ConfigurationKey.DisplayCustomShapeNames]: false,
+            [ConfigurationKey.ShowWalkThroughCameraControls]: false,
+            [ConfigurationKey.ShowLightingControls]: false,
+            [ConfigurationKey.ShowInteriorLights]: false,
+            [ConfigurationKey.InteriorLightIntensity]: 10,
+            [ConfigurationKey.ShowLightplansDialog]: false,
+            [ConfigurationKey.WalkThroughCameraFoV]: 70,
+            [ConfigurationKey.WalkThroughCameraAspectRatio]: 2,
+            [ConfigurationKey.WalkThroughCameraFocus]: 10,
+            [ConfigurationKey.ShowWalls]: true,
+            [ConfigurationKey.ShowCeiling]: true,
+            [ConfigurationKey.IsLimited]: false,
+            [ConfigurationKey.EnableTouch]: true
+        };
+        this.onChange = new BehaviorSubject({});
+    }
+    setValue(key, value) {
+        this._data[key] = value;
+        this.onChange.next({ [key]: value });
+    }
+    getValue(key) {
+        return this._data[key];
+    }
+    get() {
+        return Object.assign({}, this._data);
+    }
+    set(data) {
+        this._data = Object.assign(Object.assign({}, this._data), data);
+        this.onChange.next(data);
+    }
+    getDistanceStep() {
+        const dim = this.getValue(ConfigurationKey.DimensioningUnit);
+        return this._data[`${dim}Step`];
+    }
+}
+ConfigurationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ConfigurationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ConfigurationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ConfigurationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ConfigurationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,45 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DebugService {
+    constructor() {
+        this.debugMessages = [];
+        this.averageRenderTime = 0;
+        this.lastTimestamp = Date.now();
+        this.measurements = [];
+        this.runTest = false;
+    }
+    addMessage(message) {
+        this.debugMessages.push(message);
+    }
+    measureRenderTime() {
+        if (this.runTest) {
+            this.measurements.push(Date.now() - this.lastTimestamp);
+            this.averageRenderTime = Math.floor(this.measurements.reduce((a, b) => a + b, 0) / this.measurements.length);
+            this.lastTimestamp = Date.now();
+        }
+    }
+    resetMeasurements() {
+        this.measurements = [];
+        this.averageRenderTime = 0;
+        this.runTest = false;
+    }
+    startToggle() {
+        this.runTest = !this.runTest;
+        this.lastTimestamp = Date.now();
+    }
+    getAverageRenderTime() {
+        return this.averageRenderTime;
+    }
+    getFramesMeasuredAmount() {
+        return this.measurements.length;
+    }
+}
+DebugService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DebugService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+DebugService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DebugService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DebugService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,45 @@
+import { Injectable } from '@angular/core';
+import { ConfigurationKey } from '../enum/configuration-key.enum';
+import { Dimensioning } from '../../plugins/core3d/core/dimensioning';
+import * as i0 from "@angular/core";
+import * as i1 from "./configuration.service";
+export class DimensioningService {
+    constructor(_configurationService) {
+        this._configurationService = _configurationService;
+    }
+    cmToMeasure(cm) {
+        const dimUnit = this._configurationService.getValue(ConfigurationKey.DimensioningUnit);
+        const distanceStep = this._configurationService.getDistanceStep();
+        return Dimensioning.cmToMeasure(cm, dimUnit, distanceStep);
+    }
+    mToMeasure(m) {
+        const dimUnit = this._configurationService.getValue(ConfigurationKey.DimensioningUnit);
+        const distanceStep = this._configurationService.getDistanceStep();
+        return Dimensioning.mToMeasure(m, dimUnit, distanceStep);
+    }
+    cmToUnit(cm) {
+        const distanceStep = this._configurationService.getDistanceStep();
+        return Dimensioning.cmToUnit(cm, distanceStep);
+    }
+    unitToCm(unit) {
+        const distanceStep = this._configurationService.getDistanceStep();
+        return Dimensioning.unitToCm(unit, distanceStep);
+    }
+    scmToMeasure(scm) {
+        const dimSquUnit = this._configurationService.getValue(ConfigurationKey.DimensioningSquareUnit);
+        return Dimensioning.scmToMeasure(scm, dimSquUnit);
+    }
+    smToMeasure(sm) {
+        const dimSquUnit = this._configurationService.getValue(ConfigurationKey.DimensioningSquareUnit);
+        return Dimensioning.smToMeasure(sm, dimSquUnit);
+    }
+}
+DimensioningService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DimensioningService, deps: [{ token: i1.ConfigurationService }], target: i0.ɵɵFactoryTarget.Injectable });
+DimensioningService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DimensioningService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DimensioningService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ConfigurationService }]; } });
+//# sourceMappingURL=data:application/json;base64,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