@colijnit/configurator 260.1.2 → 261.1.1

package/esm2015/lib/services/build-furniture-without-scene.service.js

@@ -0,0 +1,86 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import { BuildFurnitureBaseService } from './build-furniture-base.service';
+import { ResultType } from '../enum/result-type.enum';
+import { isNill } from '@colijnit/configuratorapi/build/utils/function/is-nill.function';
+import { ConfigurationResultObject } from '../model/configuration-result-object';
+import * as i0 from "@angular/core";
+export class BuildFurnitureWithoutSceneService extends BuildFurnitureBaseService {
+    build(result) {
+        return __awaiter(this, void 0, void 0, function* () {
+            result.object = this.currentCustomFloorGroup;
+            this.emptyAnswerSelected();
+            this.emptySelectionsSelected();
+            if (result.resultType === ResultType.NoSelections) {
+                result.resultType = ResultType.ConfigurationFixed;
+            }
+            else if (result.resultType !== ResultType.Obsolete && result.resultType !== ResultType.ConfigurationFixed) { // don't override these
+                result.resultType = ResultType.Loaded;
+            }
+            result.selections = this.cloneSelections();
+            result.decos = Array.from(this.configuratorConnectorService.decoNodes);
+            this.appEventService.buildFinished.next(result);
+            return result;
+        });
+    }
+    startToBuild(result, shouldCopyInstance = false, looseOriginalConfiguration = true, standAlone = false, firstBuild = false, fromPreset = false, loadFromProject = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (isNill(result)) {
+                result = new ConfigurationResultObject();
+            }
+            result = yield this.prepareInstanceForBuild(shouldCopyInstance, loadFromProject, looseOriginalConfiguration, result);
+            yield this.configuratorConnectorService.getQuestionAndAnswersAsync(); // see if there is user input needed
+            if (this.configuratorConnectorService.activeAnswers.length === 0) {
+                yield this.prepareSelectionsAndDecos(result)
+                    .catch((e) => Promise.reject(e));
+                return this.build(result);
+            }
+            else {
+                if (firstBuild) {
+                    yield this.prepareSelectionsAndDecos(result)
+                        .catch((e) => Promise.reject(e));
+                    if (this.configuratorConnectorService.selections.length < 1) {
+                        result.resultType = ResultType.NeedsUserInput;
+                    }
+                    else if (this.configuratorConnectorService.selections.length < 2) {
+                        result.resultType = ResultType.BuildFromScratch;
+                    }
+                    else if (this.configuratorConnectorService.selections.length > 1) {
+                        result.resultType = ResultType.NeedsUserInput;
+                    }
+                    return result;
+                }
+            }
+        });
+    }
+    startToBuildFromConfigurator(data) {
+        return this.startToBuild(data);
+    }
+    prepareSelectionsAndDecos(result) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.reset();
+            yield this.getSelectionsAndDecos();
+            return yield this.handlePrepareSelectionsDecos(result);
+        });
+    }
+    createSimple3DModel(result, standAlone) {
+        this.configuratorConnectorService.emptySelections();
+        this.appEventService.buildFinished.next(result);
+        return result;
+    }
+    createNonConfigurableFloor(result) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO Right now we do not need this, but we might need to render floors so we just prepared it like this.
+            return new ConfigurationResultObject();
+        });
+    }
+}
+BuildFurnitureWithoutSceneService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: BuildFurnitureWithoutSceneService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+BuildFurnitureWithoutSceneService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: BuildFurnitureWithoutSceneService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: BuildFurnitureWithoutSceneService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"build-furniture-without-scene.service.js","sourceRoot":"","sources":["../../../../../projects/configurator/src/lib/services/build-furniture-without-scene.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\r\nimport {BuildFurnitureBaseService} from './build-furniture-base.service';\r\nimport {ResultType} from '../enum/result-type.enum';\r\nimport {isNill} from '@colijnit/configuratorapi/build/utils/function/is-nill.function';\r\nimport {ConfigurationResultObject} from '../model/configuration-result-object';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class BuildFurnitureWithoutSceneService extends BuildFurnitureBaseService implements OnDestroy {\r\n\r\n  public async build(result: ConfigurationResultObject): Promise<ConfigurationResultObject> {\r\n    result.object = this.currentCustomFloorGroup;\r\n    this.emptyAnswerSelected();\r\n    this.emptySelectionsSelected();\r\n    if (result.resultType === ResultType.NoSelections) {\r\n      result.resultType = ResultType.ConfigurationFixed;\r\n    } else if (result.resultType !== ResultType.Obsolete && result.resultType !== ResultType.ConfigurationFixed) { // don't override these\r\n      result.resultType = ResultType.Loaded;\r\n    }\r\n\r\n    result.selections = this.cloneSelections();\r\n    result.decos = Array.from(this.configuratorConnectorService.decoNodes);\r\n\r\n    this.appEventService.buildFinished.next(result);\r\n    return result;\r\n  }\r\n\r\n  public async startToBuild(\r\n    result?: ConfigurationResultObject,\r\n    shouldCopyInstance: boolean = false,\r\n    looseOriginalConfiguration: boolean = true,\r\n    standAlone: boolean = false,\r\n    firstBuild: boolean = false,\r\n    fromPreset: boolean = false,\r\n    loadFromProject: boolean = false\r\n  ): Promise<ConfigurationResultObject> {\r\n    if (isNill(result)) {\r\n      result = new ConfigurationResultObject();\r\n    }\r\n\r\n    result = await this.prepareInstanceForBuild(shouldCopyInstance, loadFromProject, looseOriginalConfiguration, result);\r\n\r\n    await this.configuratorConnectorService.getQuestionAndAnswersAsync(); // see if there is user input needed\r\n    if (this.configuratorConnectorService.activeAnswers.length === 0) {\r\n      await this.prepareSelectionsAndDecos(result)\r\n        .catch((e) => Promise.reject(e));\r\n      return this.build(result);\r\n    } else {\r\n      if (firstBuild) {\r\n        await this.prepareSelectionsAndDecos(result)\r\n          .catch((e) => Promise.reject(e));\r\n        if (this.configuratorConnectorService.selections.length < 1) {\r\n          result.resultType = ResultType.NeedsUserInput;\r\n        } else if (this.configuratorConnectorService.selections.length < 2) {\r\n          result.resultType = ResultType.BuildFromScratch;\r\n        } else if (this.configuratorConnectorService.selections.length > 1) {\r\n          result.resultType = ResultType.NeedsUserInput;\r\n        }\r\n        return result;\r\n      }\r\n    }\r\n  }\r\n\r\n\r\n  public startToBuildFromConfigurator(data: ConfigurationResultObject): Promise<ConfigurationResultObject> {\r\n    return this.startToBuild(data);\r\n  }\r\n\r\n  public async prepareSelectionsAndDecos(\r\n    result: ConfigurationResultObject\r\n  ): Promise<ConfigurationResultObject> {\r\n    this.reset();\r\n    await this.getSelectionsAndDecos();\r\n    return await this.handlePrepareSelectionsDecos(result);\r\n  }\r\n\r\n  public createSimple3DModel(result: ConfigurationResultObject, standAlone?: boolean): ConfigurationResultObject {\r\n    this.configuratorConnectorService.emptySelections();\r\n    this.appEventService.buildFinished.next(result);\r\n    return result;\r\n  }\r\n\r\n  public async createNonConfigurableFloor(result: ConfigurationResultObject): Promise<ConfigurationResultObject> {\r\n    // TODO Right now we do not need this, but we might need to render floors so we just prepared it like this.\r\n    return new ConfigurationResultObject();\r\n  }\r\n}\r\n"]}

package/esm2015/lib/services/build-furniture.service.js

@@ -0,0 +1,169 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import { Vector3 } from 'three';
+import { NodeType } from '@colijnit/configuratorapi/build/enum/node-type.enum';
+import { BuildFurnitureBaseService } from './build-furniture-base.service';
+import { isNill } from '@colijnit/configuratorapi/build/utils/function/is-nill.function';
+import { ConfiguratorErrorMessage } from '../model/configurator-error-message';
+import { ResultType } from '../enum/result-type.enum';
+import { ConfigurationResultObject } from '../model/configuration-result-object';
+import { DebugUtils } from '../utils/debug.utils';
+import { Scene3DUtil } from '../utils/scene-3d.utils';
+import * as i0 from "@angular/core";
+export class BuildFurnitureService extends BuildFurnitureBaseService {
+    build(result) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.full3DObjectToUse) { // there's no 3d model so get out
+                return result;
+            }
+            // new build, clear errors
+            result.errorMessages = [];
+            const adjustables = this.getAdjustables();
+            if (adjustables && adjustables.length === 0 && this.selections && this.selections.length > 0) { // check if article has a gameObject
+                if (this.selections[0].nodeType === NodeType.Article && this.selections[0].gameObject) {
+                    adjustables.push(this.selections[0]);
+                }
+            }
+            const item = this.createConfigurableItem(result.articleName);
+            if (adjustables && adjustables.length > 0) {
+                let connected = false;
+                for (let i = 0, len = adjustables.length; i < len; i++) {
+                    const adjustable = this.createAdjustable(item, adjustables[i]);
+                    if (adjustable) {
+                        for (let ii = this.placedAdjustables.length - 1; ii >= 0; ii--) {
+                            if (this.isMoveableObject(adjustable)) { // vrije verplaatsing mogelijk, connecten aan opgeslagen connector
+                                const selection = adjustable.userData.selection;
+                                this.addElementOnConnector(item, adjustable, selection.decoConnection ? selection.decoConnection : this.activeConnector, this.baseElementNodeId);
+                                adjustable.visible = true;
+                                connected = true;
+                                break;
+                            }
+                            else {
+                                if (Scene3DUtil.TrySelectorConnection(this.scene, item, this.placedAdjustables[ii], adjustable, i === 1)) {
+                                    adjustable.visible = true;
+                                    connected = true;
+                                    break;
+                                }
+                            }
+                            connected = false;
+                        }
+                    }
+                    if (!connected && this.placedAdjustables.length > 1) {
+                        DebugUtils.log(`No connection found for: ${adjustable ? adjustable.name : adjustables[i].decoNode.gameObjectName}`);
+                        result.errorMessages.push(new ConfiguratorErrorMessage(`No connection found for: ${adjustable ? adjustable.name : adjustables[i].decoNode.gameObjectName}`));
+                    }
+                }
+                this.placeAddables(item);
+                Scene3DUtil.updatePivot(item);
+                yield this.loadVariations(item, result.instanceId);
+                yield this.updateBuildObject(item, result);
+                this.currentCustomFloorGroup = result.object;
+                this.arPlacementUpdate.next(true);
+                // this.handleIntegration(result.instanceId, this.currentCustomFloorGroup);
+                this.emptyAnswerSelected();
+                this.emptySelectionsSelected();
+                if (this.currentCustomFloorGroup.children.length === 0) {
+                    result.resultType = ResultType.GameobjectNameMismatchInSource;
+                    return Promise.reject(result);
+                }
+            }
+            else {
+                result.errorMessages.push(new ConfiguratorErrorMessage('NO_ADJUSTABLES', 'NO_ADJUSTABLES_INFO'));
+                result.resultType = ResultType.NoAdjustables;
+                return Promise.reject(result);
+            }
+            if (result.resultType === ResultType.NoSelections) {
+                result.resultType = ResultType.ConfigurationFixed;
+            }
+            else if (result.resultType !== ResultType.Obsolete && result.resultType !== ResultType.ConfigurationFixed) { // don't override these
+                result.resultType = ResultType.Loaded;
+            }
+            this.appEventService.buildFinished.next(result);
+            return result;
+        });
+    }
+    createNonConfigurableFloor(result) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const assetUrl = result.assetUrl;
+            const floorMaterial = yield this.variationService.loadVariationByAssetUrl(assetUrl);
+            result.material = floorMaterial;
+            this.appEventService.buildFinished.next(result);
+            return result;
+        });
+    }
+    startToBuild(result, shouldCopyInstance = false, looseOriginalConfiguration = true, standAlone = false, firstBuild = false, fromPreset = false, loadFromProject = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (isNill(result)) {
+                result = new ConfigurationResultObject();
+            }
+            result = yield this.prepareInstanceForBuild(shouldCopyInstance, loadFromProject, looseOriginalConfiguration, result);
+            this.startPosition = new Vector3();
+            if (loadFromProject) {
+                this.reset();
+                this.configuratorConnectorService.setSelections(result.selections);
+                this.configuratorConnectorService.setDecoNodes(Array.from(result.decos.values()));
+                this.preloadMaterials(result.schema);
+                this.prepareTheSelections(result.instanceId);
+                return this.build(result);
+            }
+            else {
+                yield this.configuratorConnectorService.getQuestionAndAnswersAsync(); // see if there is user input needed
+                if (this.configuratorConnectorService.activeAnswers.length === 0) {
+                    yield this.prepareSelectionsAndDecos(result)
+                        .catch((e) => Promise.reject(e));
+                    return this.build(result);
+                }
+                else {
+                    if (firstBuild) {
+                        yield this.prepareSelectionsAndDecos(result).catch((e) => Promise.reject(e));
+                        if (this.configuratorConnectorService.selections.length < 1) {
+                            result.resultType = ResultType.NeedsUserInput;
+                        }
+                        else if (this.configuratorConnectorService.selections.length < 2) {
+                            result.resultType = ResultType.BuildFromScratch;
+                        }
+                        else if (this.configuratorConnectorService.selections.length > 1) {
+                            result.resultType = ResultType.NeedsUserInput;
+                        }
+                        this.appEventService.buildFinished.next(result);
+                        return result;
+                    }
+                }
+            }
+        });
+    }
+    createSimple3DModel(result) {
+        if (!this.full3DObjectToUse) { // there's no 3d model so get out
+            return result;
+        }
+        this.configuratorConnectorService.emptySelections();
+        this.full3DObjectToUse.children.forEach(c => c.visible = true);
+        result.object = this.full3DObjectToUse;
+        Scene3DUtil.updatePivot(result.object);
+        if (result.default180) {
+            result.object.rotation.set(this.defaultRotation.x, this.defaultRotation.y, this.defaultRotation.z);
+        }
+        this.appEventService.buildFinished.next(result);
+        return result;
+    }
+    startToBuildFromConfigurator(data) {
+        return this.startToBuild(data);
+    }
+    prepareSelectionsAndDecos(result) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.reset();
+            yield this.getSelectionsAndDecos();
+            this.preloadMaterials(result.schema);
+            return yield this.handlePrepareSelectionsDecos(result);
+        });
+    }
+}
+BuildFurnitureService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: BuildFurnitureService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+BuildFurnitureService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: BuildFurnitureService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: BuildFurnitureService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"build-furniture.service.js","sourceRoot":"","sources":["../../../../../projects/configurator/src/lib/services/build-furniture.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Selection} from '@colijnit/configuratorapi/build/model/selection';\r\nimport {Injectable, OnDestroy} from '@angular/core';\r\nimport {Material, Object3D, Vector3} from 'three';\r\nimport {NodeType} from '@colijnit/configuratorapi/build/enum/node-type.enum';\r\nimport {BuildFurnitureBaseService} from './build-furniture-base.service';\r\nimport {isNill} from '@colijnit/configuratorapi/build/utils/function/is-nill.function';\r\nimport {ConfiguratorErrorMessage} from '../model/configurator-error-message';\r\nimport {ResultType} from '../enum/result-type.enum';\r\nimport {ConfigurationResultObject} from '../model/configuration-result-object';\r\nimport {DebugUtils} from '../utils/debug.utils';\r\nimport {Scene3DUtil} from '../utils/scene-3d.utils';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class BuildFurnitureService extends BuildFurnitureBaseService implements OnDestroy {\r\n\r\n  public async build(result: ConfigurationResultObject): Promise<ConfigurationResultObject> {\r\n    if (!this.full3DObjectToUse) { // there's no 3d model so get out\r\n      return result;\r\n    }\r\n\r\n    // new build, clear errors\r\n    result.errorMessages = [];\r\n\r\n    const adjustables: Selection[] = this.getAdjustables();\r\n    if (adjustables && adjustables.length === 0 && this.selections && this.selections.length > 0) { // check if article has a gameObject\r\n      if (this.selections[0].nodeType === NodeType.Article && this.selections[0].gameObject) {\r\n        adjustables.push(this.selections[0]);\r\n      }\r\n    }\r\n\r\n    const item: Object3D = this.createConfigurableItem(result.articleName);\r\n\r\n    if (adjustables && adjustables.length > 0) {\r\n      let connected: boolean = false;\r\n      for (let i: number = 0, len: number = adjustables.length; i < len; i++) {\r\n        const adjustable: Object3D = this.createAdjustable(item, adjustables[i]);\r\n        if (adjustable) {\r\n          for (let ii = this.placedAdjustables.length - 1; ii >= 0; ii--) {\r\n            if (this.isMoveableObject(adjustable)) { // vrije verplaatsing mogelijk, connecten aan opgeslagen connector\r\n              const selection: Selection = adjustable.userData.selection;\r\n              this.addElementOnConnector(\r\n                item,\r\n                adjustable,\r\n                selection.decoConnection ? selection.decoConnection : this.activeConnector,\r\n                this.baseElementNodeId\r\n              );\r\n              adjustable.visible = true;\r\n              connected = true;\r\n              break;\r\n            } else {\r\n              if (Scene3DUtil.TrySelectorConnection(\r\n                this.scene,\r\n                item, this.placedAdjustables[ii], adjustable, i === 1)) {\r\n                adjustable.visible = true;\r\n                connected = true;\r\n                break;\r\n              }\r\n            }\r\n            connected = false;\r\n          }\r\n        }\r\n\r\n        if (!connected && this.placedAdjustables.length > 1) {\r\n          DebugUtils.log(`No connection found for: ${adjustable ? adjustable.name : adjustables[i].decoNode.gameObjectName}`);\r\n          result.errorMessages.push(\r\n            new ConfiguratorErrorMessage(`No connection found for: ${adjustable ? adjustable.name : adjustables[i].decoNode.gameObjectName}`)\r\n          );\r\n        }\r\n      }\r\n      this.placeAddables(item);\r\n\r\n      Scene3DUtil.updatePivot(item);\r\n\r\n      await this.loadVariations(item, result.instanceId);\r\n      await this.updateBuildObject(item, result);\r\n\r\n      this.currentCustomFloorGroup = result.object;\r\n\r\n      this.arPlacementUpdate.next(true);\r\n      // this.handleIntegration(result.instanceId, this.currentCustomFloorGroup);\r\n      this.emptyAnswerSelected();\r\n      this.emptySelectionsSelected();\r\n\r\n      if (this.currentCustomFloorGroup.children.length === 0) {\r\n        result.resultType = ResultType.GameobjectNameMismatchInSource;\r\n        return Promise.reject(result);\r\n      }\r\n    } else {\r\n      result.errorMessages.push(new ConfiguratorErrorMessage('NO_ADJUSTABLES', 'NO_ADJUSTABLES_INFO'));\r\n      result.resultType = ResultType.NoAdjustables;\r\n      return Promise.reject(result);\r\n    }\r\n    if (result.resultType === ResultType.NoSelections) {\r\n      result.resultType = ResultType.ConfigurationFixed;\r\n    } else if (result.resultType !== ResultType.Obsolete && result.resultType !== ResultType.ConfigurationFixed) { // don't override these\r\n      result.resultType = ResultType.Loaded;\r\n    }\r\n\r\n    this.appEventService.buildFinished.next(result);\r\n    return result;\r\n  }\r\n\r\n  public async createNonConfigurableFloor(result: ConfigurationResultObject): Promise<ConfigurationResultObject> {\r\n    const assetUrl: string = result.assetUrl;\r\n    const floorMaterial: Material = await this.variationService.loadVariationByAssetUrl(assetUrl);\r\n    result.material = floorMaterial;\r\n    this.appEventService.buildFinished.next(result);\r\n    return result;\r\n  }\r\n\r\n  public async startToBuild(\r\n    result?: ConfigurationResultObject,\r\n    shouldCopyInstance: boolean = false,\r\n    looseOriginalConfiguration: boolean = true,\r\n    standAlone: boolean = false,\r\n    firstBuild: boolean = false,\r\n    fromPreset: boolean = false,\r\n    loadFromProject: boolean = false\r\n  ): Promise<ConfigurationResultObject> {\r\n\r\n    if (isNill(result)) {\r\n      result = new ConfigurationResultObject();\r\n    }\r\n\r\n    result = await this.prepareInstanceForBuild(shouldCopyInstance, loadFromProject, looseOriginalConfiguration, result);\r\n\r\n    this.startPosition = new Vector3();\r\n\r\n    if (loadFromProject) {\r\n      this.reset();\r\n      this.configuratorConnectorService.setSelections(result.selections);\r\n      this.configuratorConnectorService.setDecoNodes(Array.from(result.decos.values()));\r\n      this.preloadMaterials(result.schema);\r\n      this.prepareTheSelections(result.instanceId);\r\n      return this.build(result);\r\n    } else {\r\n      await this.configuratorConnectorService.getQuestionAndAnswersAsync(); // see if there is user input needed\r\n      if (this.configuratorConnectorService.activeAnswers.length === 0) {\r\n        await this.prepareSelectionsAndDecos(result)\r\n          .catch((e) => Promise.reject(e));\r\n        return this.build(result);\r\n      } else {\r\n        if (firstBuild) {\r\n          await this.prepareSelectionsAndDecos(result).catch((e) => Promise.reject(e));\r\n          if (this.configuratorConnectorService.selections.length < 1) {\r\n            result.resultType = ResultType.NeedsUserInput;\r\n          } else if (this.configuratorConnectorService.selections.length < 2) {\r\n            result.resultType = ResultType.BuildFromScratch;\r\n          } else if (this.configuratorConnectorService.selections.length > 1) {\r\n            result.resultType = ResultType.NeedsUserInput;\r\n          }\r\n          this.appEventService.buildFinished.next(result);\r\n          return result;\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  public createSimple3DModel(result: ConfigurationResultObject): ConfigurationResultObject {\r\n\r\n    if (!this.full3DObjectToUse) { // there's no 3d model so get out\r\n      return result;\r\n    }\r\n    this.configuratorConnectorService.emptySelections();\r\n    this.full3DObjectToUse.children.forEach(c => c.visible = true);\r\n    result.object = this.full3DObjectToUse;\r\n\r\n    Scene3DUtil.updatePivot(result.object);\r\n\r\n    if (result.default180) {\r\n      result.object.rotation.set(this.defaultRotation.x, this.defaultRotation.y, this.defaultRotation.z);\r\n    }\r\n    this.appEventService.buildFinished.next(result);\r\n    return result;\r\n  }\r\n\r\n  public startToBuildFromConfigurator(data: ConfigurationResultObject): Promise<ConfigurationResultObject> {\r\n    return this.startToBuild(data);\r\n  }\r\n\r\n  public async prepareSelectionsAndDecos(\r\n    result: ConfigurationResultObject\r\n  ): Promise<ConfigurationResultObject> {\r\n    this.reset();\r\n    await this.getSelectionsAndDecos();\r\n    this.preloadMaterials(result.schema);\r\n    return await this.handlePrepareSelectionsDecos(result);\r\n  }\r\n}\r\n"]}

package/esm2015/lib/services/bundle-initialzer.service.js

@@ -0,0 +1,113 @@
+import { __awaiter } from "tslib";
+import { Texture } from '../model/texture';
+import { LightPreset } from '../model/light-preset';
+import { BehaviorSubject } from 'rxjs';
+import { Injectable } from '@angular/core';
+import { MaterialUtils } from '../utils/material.utils';
+import { DebugUtils } from '../utils/debug.utils';
+import { Setting } from '../model/settings';
+import * as i0 from "@angular/core";
+import * as i1 from "./json-utils.service";
+import * as i2 from "./settings.service";
+import * as i3 from "./configurator-connector.service";
+import * as i4 from "./app-initializer.service";
+import * as i5 from "./configuration.service";
+import * as i6 from "./scene.service";
+import * as i7 from "./scene-options.service";
+export class BundleInitializerService {
+    constructor(_jsonUtilsService, _settingsService, _ioneControllerService, _appInitializerService, _configurationService, _sceneService, _sceneOptionsService) {
+        this._jsonUtilsService = _jsonUtilsService;
+        this._settingsService = _settingsService;
+        this._ioneControllerService = _ioneControllerService;
+        this._appInitializerService = _appInitializerService;
+        this._configurationService = _configurationService;
+        this._sceneService = _sceneService;
+        this._sceneOptionsService = _sceneOptionsService;
+        this.settings = [];
+        this.floorTexturesLoaded = new BehaviorSubject(undefined);
+        this.lightPresetsLoaded = new BehaviorSubject(undefined);
+        this.settingsLoaded = new BehaviorSubject(undefined);
+        this.allLoaded = new BehaviorSubject(undefined);
+        this._connectionSet = false;
+        this._subs = [];
+        this._jsonFile = 'index.json';
+        this._lightPresetsJsonFile = 'light-presets.json';
+        this._appInitializerService.appInitialized.subscribe((loaded) => __awaiter(this, void 0, void 0, function* () {
+            if (loaded && !this._connectionSet) {
+                this._assetPath = this._settingsService.settings.assetPath;
+                if (this._settingsService.settings.assetIndex) {
+                    this._jsonFile = this._settingsService.settings.assetIndex;
+                }
+                if (this._settingsService.settings.lightPresetsIndex) {
+                    this._lightPresetsJsonFile = this._settingsService.settings.lightPresetsIndex;
+                }
+                MaterialUtils.SetAssetPath(this._assetPath);
+                yield this._initialize();
+                this._connectionSet = true;
+                this.allLoaded.next(true);
+            }
+        }));
+    }
+    ngOnDestroy() {
+        this.floorTextures = [];
+        this.lightPresets = [];
+        this._subs.forEach(s => s.unsubscribe());
+    }
+    getFloorTextures() {
+        return this.floorTextures ? this.floorTextures.filter(f => f.show && f.useStandalone) : [];
+    }
+    getFloorTexture() {
+        return this.floorTextures ? this.floorTextures.find(f => f.show && f.useStandalone && f.defaultStandalone) : undefined;
+    }
+    getLightPreset() {
+        return this.lightPresets ? this.lightPresets.filter(l => l.default && l.standalone) : [];
+    }
+    _initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const indexFile = yield this._jsonUtilsService.readJsonFile(this._assetPath + 'assets/' + this._jsonFile, false);
+                const lightPresets = yield this._jsonUtilsService.readJsonFile(this._assetPath + 'assets/' + this._lightPresetsJsonFile, false);
+                if (indexFile.hasOwnProperty('floors')) {
+                    this.floorTextures = indexFile['floors'].map((floorTextureDef) => this._createTexture(floorTextureDef));
+                    this.floorTexturesLoaded.next(this.floorTextures);
+                }
+                else {
+                    DebugUtils.log('No floor textures available');
+                }
+                if (lightPresets.hasOwnProperty('lightpresets')) {
+                    this.lightPresets = lightPresets['lightpresets'].map((lightPresetDef) => this._createLightPreset(lightPresetDef));
+                    this.lightPresetsLoaded.next(this.lightPresets);
+                }
+                else {
+                    this.lightPresetsLoaded.next([]);
+                }
+                if (lightPresets.hasOwnProperty('settings')) {
+                    this.settings = lightPresets['settings'].map((settingsDef) => this._createSettings(settingsDef));
+                    this.settingsLoaded.next(this.settings);
+                }
+                else {
+                    this.settingsLoaded.next(undefined);
+                }
+            }
+            catch (e) {
+                console.error(e);
+            }
+        });
+    }
+    _createTexture(texture) {
+        return Texture.CreateModelFromInterface(texture);
+    }
+    _createLightPreset(lightPreset) {
+        return LightPreset.CreateModelFromInterface(lightPreset);
+    }
+    _createSettings(setting) {
+        return Setting.CreateModelFromInterface(setting);
+    }
+}
+BundleInitializerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: BundleInitializerService, deps: [{ token: i1.JsonUtilsService }, { token: i2.SettingsService }, { token: i3.ConfiguratorConnectorService }, { token: i4.AppInitializerService }, { token: i5.ConfigurationService }, { token: i6.SceneService }, { token: i7.SceneOptionsService }], target: i0.ɵɵFactoryTarget.Injectable });
+BundleInitializerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: BundleInitializerService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: BundleInitializerService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.JsonUtilsService }, { type: i2.SettingsService }, { type: i3.ConfiguratorConnectorService }, { type: i4.AppInitializerService }, { type: i5.ConfigurationService }, { type: i6.SceneService }, { type: i7.SceneOptionsService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bundle-initialzer.service.js","sourceRoot":"","sources":["../../../../../projects/configurator/src/lib/services/bundle-initialzer.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Texture} from '../model/texture';\r\nimport {LightPreset} from '../model/light-preset';\r\nimport {BehaviorSubject, Subscription} from 'rxjs';\r\nimport {JsonUtilsService} from './json-utils.service';\r\nimport {SettingsService} from './settings.service';\r\nimport {ConfiguratorConnectorService} from './configurator-connector.service';\r\nimport {ConfigurationService} from './configuration.service';\r\nimport {Injectable, OnDestroy} from '@angular/core';\r\nimport {MaterialUtils} from '../utils/material.utils';\r\nimport {TextureInterface} from '../interfaces/texture.interface';\r\nimport {LightPresetInterface} from '../interfaces/light-preset.interface';\r\nimport {SceneService} from './scene.service';\r\nimport {SceneOptionsService} from './scene-options.service';\r\nimport {AppInitializerService} from './app-initializer.service';\r\nimport {DebugUtils} from '../utils/debug.utils';\r\nimport {Setting} from '../model/settings';\r\nimport {SettingInterface} from '../interfaces/setting.interface';\r\n\r\n@Injectable({providedIn: 'root'})\r\n\r\nexport class BundleInitializerService implements OnDestroy {\r\n\r\n  public floorTextures: Texture[];\r\n  public lightPresets: LightPreset[];\r\n  public settings: Setting[] = [];\r\n\r\n  public floorTexturesLoaded: BehaviorSubject<Texture[]> = new BehaviorSubject<Texture[]>(undefined);\r\n  public lightPresetsLoaded: BehaviorSubject<LightPreset[]> = new BehaviorSubject<LightPreset[]>(undefined);\r\n  public settingsLoaded: BehaviorSubject<Setting[]> = new BehaviorSubject<Setting[]>(undefined);\r\n  public allLoaded: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(undefined);\r\n\r\n  private _assetPath: string;\r\n  private _connectionSet: boolean = false;\r\n  private _subs: Subscription[] = [];\r\n  private _jsonFile: string = 'index.json';\r\n  private _lightPresetsJsonFile: string = 'light-presets.json';\r\n\r\n  constructor(\r\n    private _jsonUtilsService: JsonUtilsService,\r\n    private _settingsService: SettingsService,\r\n    private _ioneControllerService: ConfiguratorConnectorService,\r\n    private _appInitializerService: AppInitializerService,\r\n    private _configurationService: ConfigurationService,\r\n    private _sceneService: SceneService,\r\n    private _sceneOptionsService: SceneOptionsService\r\n  ) {\r\n    this._appInitializerService.appInitialized.subscribe(async (loaded: boolean) => {\r\n      if (loaded && !this._connectionSet) {\r\n        this._assetPath = this._settingsService.settings.assetPath;\r\n        if (this._settingsService.settings.assetIndex) {\r\n          this._jsonFile = this._settingsService.settings.assetIndex;\r\n        }\r\n        if (this._settingsService.settings.lightPresetsIndex) {\r\n          this._lightPresetsJsonFile = this._settingsService.settings.lightPresetsIndex;\r\n        }\r\n        MaterialUtils.SetAssetPath(this._assetPath);\r\n        await this._initialize();\r\n        this._connectionSet = true;\r\n        this.allLoaded.next(true);\r\n      }\r\n    });\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.floorTextures = [];\r\n    this.lightPresets = [];\r\n    this._subs.forEach(s => s.unsubscribe());\r\n  }\r\n\r\n  public getFloorTextures(): Texture[] {\r\n    return this.floorTextures ? this.floorTextures.filter(f => f.show && f.useStandalone) : [];\r\n  }\r\n\r\n  public getFloorTexture(): Texture {\r\n    return this.floorTextures ? this.floorTextures.find(f => f.show && f.useStandalone && f.defaultStandalone) : undefined;\r\n  }\r\n\r\n  public getLightPreset(): LightPreset[] {\r\n    return this.lightPresets ? this.lightPresets.filter(l => l.default && l.standalone) : [];\r\n  }\r\n\r\n  private async _initialize(): Promise<void> {\r\n    try {\r\n      const indexFile: any = await this._jsonUtilsService.readJsonFile(this._assetPath + 'assets/' + this._jsonFile, false);\r\n      const lightPresets: any = await this._jsonUtilsService.readJsonFile(this._assetPath + 'assets/' + this._lightPresetsJsonFile, false);\r\n\r\n      if (indexFile.hasOwnProperty('floors')) {\r\n        this.floorTextures = indexFile['floors'].map((floorTextureDef: TextureInterface) => this._createTexture(floorTextureDef));\r\n        this.floorTexturesLoaded.next(this.floorTextures);\r\n      } else {\r\n        DebugUtils.log('No floor textures available');\r\n      }\r\n\r\n      if (lightPresets.hasOwnProperty('lightpresets')) {\r\n        this.lightPresets = lightPresets['lightpresets'].map((lightPresetDef: LightPresetInterface) => this._createLightPreset(lightPresetDef));\r\n        this.lightPresetsLoaded.next(this.lightPresets);\r\n      } else {\r\n        this.lightPresetsLoaded.next([]);\r\n      }\r\n\r\n      if (lightPresets.hasOwnProperty('settings')) {\r\n        this.settings = lightPresets['settings'].map((settingsDef: SettingInterface) => this._createSettings(settingsDef));\r\n        this.settingsLoaded.next(this.settings);\r\n      } else {\r\n        this.settingsLoaded.next(undefined);\r\n      }\r\n    } catch (e) {\r\n      console.error(e);\r\n    }\r\n  }\r\n\r\n  private _createTexture(texture: TextureInterface): Texture {\r\n    return Texture.CreateModelFromInterface(texture);\r\n  }\r\n\r\n  private _createLightPreset(lightPreset: LightPresetInterface): LightPreset {\r\n    return LightPreset.CreateModelFromInterface(lightPreset);\r\n  }\r\n\r\n  private _createSettings(setting: SettingInterface): Setting {\r\n    return Setting.CreateModelFromInterface(setting);\r\n  }\r\n\r\n}\r\n"]}

package/esm2015/lib/services/camera.service.js

@@ -0,0 +1,123 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import { Box3, PerspectiveCamera, Vector3 } from 'three';
+import { Subject } from 'rxjs';
+import { Controls } from './controls';
+import * as i0 from "@angular/core";
+import * as i1 from "./settings.service";
+const DEFAULT_CAMERA_ASPECT_RATIO = 1;
+const DEFAULT_CAMERA_FOV = 45;
+const DEFAULT_CAMERA_FOCUS = 10;
+export class CameraService {
+    constructor(_settingsService) {
+        this._settingsService = _settingsService;
+        this.panSpeed = 30;
+        this.rotateBy = Math.PI / 32;
+        this.moveBy = 25;
+        this.cameraDefaultHeight = 1.7;
+        this.targetDefaultOffset = 1;
+        this.exploreDistanceFromCorner = 0.8;
+        this.cameraMovementChanged = new Subject();
+        this._cameraLocked = false;
+        this._realAspectRatio = DEFAULT_CAMERA_ASPECT_RATIO;
+        this._aspectRatio = window.innerWidth / window.innerHeight;
+        this._subs = [];
+    }
+    get cameraLocked() {
+        return this._cameraLocked;
+    }
+    set realAspectRatio(value) {
+        this._realAspectRatio = value;
+    }
+    ngOnDestroy() {
+        this._subs.forEach(s => s.unsubscribe());
+        this.controls.removeEventListener('change', () => this._controlsUpdate());
+        this.controls.removeEventListener('contextmenu');
+        this.controls.removeEventListener('mousedown');
+        this.controls.removeEventListener('wheel');
+        this.controls.removeEventListener('touchstart');
+        this.controls.removeEventListener('touchend');
+        this.controls.removeEventListener('touchmove');
+        window.removeEventListener('deviceorientation', this.controls.onDeviceMove(), false);
+        window.removeEventListener('keydown', this.controls.onKeyDown(), false);
+        this._element = undefined;
+    }
+    init(element) {
+        this._element = element;
+        this.camera = new PerspectiveCamera(45, 1, 0.01, 100);
+        this.camera.position.set(0, 3, 1.5);
+        this.camera.aspect = window.innerWidth / window.innerHeight;
+        this.camera.updateProjectionMatrix();
+        this.controls = new Controls(this.camera, this._element);
+        this.controls.addEventListener('change', () => this._controlsUpdate());
+        this.controls.update();
+    }
+    cameraZoomIn() {
+        this.controls.dollyIn(1.1);
+        this.controls.update();
+    }
+    cameraZoomOut() {
+        this.controls.dollyOut(1.1);
+        this.controls.update();
+    }
+    lockCamera() {
+        this._cameraLocked = true;
+    }
+    unlockCamera() {
+        this._cameraLocked = false;
+    }
+    disableRotate() {
+        this.controls.noRotate = true;
+    }
+    disableRotateHorizontal() {
+        this.controls.noRotateHorizontal = true;
+    }
+    disablePan() {
+        this.controls.noPan = true;
+    }
+    disableZoom() {
+        this.controls.noZoom = true;
+    }
+    moveCameraToFitObject(object, offset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!object) {
+                return;
+            }
+            offset = offset || 1.15;
+            // get bounding box of object - this will be used to setup controls and camera
+            const boundingBox = new Box3();
+            boundingBox.setFromObject(object);
+            const center = new Vector3();
+            boundingBox.getCenter(center);
+            const size = new Vector3();
+            boundingBox.getSize(size);
+            // get the max side of the bounding box (fits to width OR height as needed )
+            const maxDim = Math.max(size.x, size.y, size.z);
+            const fov = this.camera.fov * (Math.PI / 180);
+            // let cameraZ = Math.abs(maxDim / 4 * Math.tan(fov * 200));
+            let cameraZ = Math.abs((maxDim / 2) / Math.tan(fov / 2));
+            cameraZ *= offset; // zoom out a little so that objects don't fill the screen
+            const newPosition = new Vector3(0, size.y * 1.25, cameraZ);
+            if (this._settingsService.settings.options.useAnimations) {
+                const tween = yield this.controls.animateCameraMovement(newPosition, center, 2000);
+            }
+            else {
+                yield this.controls.fixedCameraMovement(newPosition, center);
+            }
+        });
+    }
+    _getCameraOffset(target, distance) {
+        const targetDistance = distance * 1.5;
+        return target.clone().add(new Vector3(0, targetDistance, targetDistance));
+    }
+    _controlsUpdate() {
+        this.cameraMovementChanged.next();
+    }
+}
+CameraService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CameraService, deps: [{ token: i1.SettingsService }], target: i0.ɵɵFactoryTarget.Injectable });
+CameraService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CameraService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CameraService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.SettingsService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"camera.service.js","sourceRoot":"","sources":["../../../../../projects/configurator/src/lib/services/camera.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\r\nimport {Box3, Euler, Object3D, PerspectiveCamera, Quaternion, Vector2, Vector3} from 'three';\r\nimport {Subject, Subscription} from 'rxjs';\r\nimport * as TWEEN from '@tweenjs/tween.js';\r\nimport { ViewMode } from '../enum/view-mode.enum';\r\nimport {ConfiguratorSettings} from '../model/configurator-settings';\r\nimport {SettingsService} from './settings.service';\r\nimport {Controls} from './controls';\r\nimport * as THREE from 'three';\r\n\r\n\r\nconst DEFAULT_CAMERA_ASPECT_RATIO: number = 1;\r\nconst DEFAULT_CAMERA_FOV: number = 45;\r\nconst DEFAULT_CAMERA_FOCUS: number = 10;\r\n\r\n@Injectable({providedIn: 'root'})\r\n\r\nexport class CameraService implements OnDestroy {\r\n\r\n  public readonly panSpeed: number = 30;\r\n  public readonly rotateBy: number = Math.PI / 32;\r\n  public readonly moveBy: number = 25;\r\n  public readonly cameraDefaultHeight: number = 1.7;\r\n  public readonly targetDefaultOffset: number = 1;\r\n  public readonly exploreDistanceFromCorner: number = 0.8;\r\n\r\n  public camera: PerspectiveCamera;\r\n  public controls: any;\r\n  public cameraMovementChanged: Subject<void> = new Subject();\r\n\r\n  private _cameraLocked: boolean = false;\r\n  private _element: HTMLElement;\r\n  private _viewSize: Vector3;\r\n  private _viewCenter: Vector3;\r\n  private _exploreTargetDistance: number;\r\n  private _realAspectRatio: number = DEFAULT_CAMERA_ASPECT_RATIO;\r\n  private _aspectRatio: number = window.innerWidth / window.innerHeight;\r\n  private _viewMode: ViewMode;\r\n  private _subs: Subscription[] = [];\r\n\r\n  get cameraLocked(): boolean {\r\n    return this._cameraLocked;\r\n  }\r\n\r\n  set realAspectRatio(value: number) {\r\n    this._realAspectRatio = value;\r\n  }\r\n\r\n  constructor(\r\n    private _settingsService: SettingsService\r\n  ) {\r\n\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this._subs.forEach(s => s.unsubscribe());\r\n    this.controls.removeEventListener('change', () => this._controlsUpdate());\r\n    this.controls.removeEventListener('contextmenu');\r\n    this.controls.removeEventListener('mousedown');\r\n    this.controls.removeEventListener('wheel');\r\n    this.controls.removeEventListener('touchstart');\r\n    this.controls.removeEventListener('touchend');\r\n    this.controls.removeEventListener('touchmove');\r\n\r\n    window.removeEventListener('deviceorientation', this.controls.onDeviceMove(), false);\r\n    window.removeEventListener('keydown', this.controls.onKeyDown(), false);\r\n    this._element = undefined;\r\n  }\r\n\r\n  public init(element: HTMLElement): void {\r\n    this._element = element;\r\n    this.camera = new PerspectiveCamera(45, 1, 0.01, 100);\r\n    this.camera.position.set(0, 3, 1.5);\r\n    this.camera.aspect = window.innerWidth / window.innerHeight;\r\n    this.camera.updateProjectionMatrix();\r\n    this.controls = new Controls(this.camera, this._element);\r\n    this.controls.addEventListener('change', () => this._controlsUpdate());\r\n    this.controls.update();\r\n  }\r\n\r\n  public cameraZoomIn(): void {\r\n    this.controls.dollyIn(1.1);\r\n    this.controls.update();\r\n  }\r\n\r\n  public cameraZoomOut(): void {\r\n    this.controls.dollyOut(1.1);\r\n    this.controls.update();\r\n  }\r\n\r\n  public lockCamera(): void {\r\n    this._cameraLocked = true;\r\n  }\r\n\r\n  public unlockCamera(): void {\r\n    this._cameraLocked = false;\r\n  }\r\n\r\n  public disableRotate(): void {\r\n    this.controls.noRotate = true;\r\n  }\r\n\r\n  public disableRotateHorizontal(): void {\r\n    this.controls.noRotateHorizontal = true;\r\n  }\r\n\r\n\r\n  public disablePan(): void {\r\n    this.controls.noPan = true;\r\n  }\r\n\r\n  public disableZoom(): void {\r\n    this.controls.noZoom = true;\r\n  }\r\n\r\n  public async moveCameraToFitObject(object: any, offset?: number): Promise<void> {\r\n    if (!object) {\r\n      return;\r\n    }\r\n    offset = offset || 1.15;\r\n\r\n    // get bounding box of object - this will be used to setup controls and camera\r\n    const boundingBox: Box3 = new Box3();\r\n    boundingBox.setFromObject(object);\r\n    const center: Vector3 = new Vector3();\r\n    boundingBox.getCenter(center);\r\n    const size: Vector3 = new Vector3();\r\n    boundingBox.getSize(size);\r\n\r\n    // get the max side of the bounding box (fits to width OR height as needed )\r\n    const maxDim: number = Math.max(size.x, size.y, size.z);\r\n\r\n    const fov: number = this.camera.fov * (Math.PI / 180);\r\n    // let cameraZ = Math.abs(maxDim / 4 * Math.tan(fov * 200));\r\n    let cameraZ: number = Math.abs((maxDim / 2) / Math.tan(fov / 2));\r\n    cameraZ *= offset; // zoom out a little so that objects don't fill the screen\r\n\r\n    const newPosition: Vector3 = new Vector3(0, size.y * 1.25, cameraZ);\r\n    if (this._settingsService.settings.options.useAnimations) {\r\n      const tween = await this.controls.animateCameraMovement(newPosition, center, 2000);\r\n    } else {\r\n      await this.controls.fixedCameraMovement(newPosition, center);\r\n    }\r\n  }\r\n\r\n  private _getCameraOffset(target: Vector3, distance: number): Vector3 {\r\n    const targetDistance: number = distance * 1.5;\r\n    return target.clone().add(\r\n      new Vector3(0, targetDistance, targetDistance));\r\n  }\r\n\r\n  private _controlsUpdate(): void {\r\n    this.cameraMovementChanged.next();\r\n  }\r\n}\r\n"]}