@colijnit/configurator 260.1.2 → 261.1.1

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

@@ -0,0 +1,43 @@
+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/lib/services/dictionary.service.js

@@ -0,0 +1,65 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import { StringUtils } from '@colijnit/ioneconnector/build/utils/string-utils';
+import * as i0 from "@angular/core";
+import * as i1 from "./json-utils.service";
+export class DictionaryService {
+    constructor(_jsonUtilsService) {
+        this._jsonUtilsService = _jsonUtilsService;
+        // Some dictionary values have one or more '|~' texts in them, meant to be replaced with client-side given texts.
+        this._placeholder = '|~';
+        this._client = 'homedecorator';
+        this._language = 'NL';
+    }
+    get(key, upperCaseFirst = true, ...replacementTexts) {
+        let text = this._dictionary && this._dictionary.hasOwnProperty(key.toUpperCase()) ? this._dictionary[key.toUpperCase()] : key;
+        if (upperCaseFirst) {
+            text = text.charAt(0).toUpperCase() + text.slice(1);
+        }
+        else {
+            text = text.charAt(0).toLowerCase() + text.slice(1);
+        }
+        if (replacementTexts.length > 0) {
+            text = StringUtils.ReplaceOccurrencesIn(text, this._placeholder, ...replacementTexts);
+        }
+        return text ? text : key;
+    }
+    setDictionary(path, client, languageCode, additionalTranslationFile) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._language = languageCode ? languageCode : this._language;
+            let dictionaryData;
+            if (additionalTranslationFile) {
+                dictionaryData = yield this._getDictionaryData(additionalTranslationFile);
+            }
+            if (!dictionaryData && client) {
+                const fileName = `${client}_${this._language.toLowerCase()}_${this._language.toUpperCase()}.json`;
+                dictionaryData = yield this._getDictionaryData(path + 'assets/' + fileName);
+            }
+            if (!client || !dictionaryData) {
+                const fileName = `${this._client}_${this._language.toLowerCase()}_${this._language.toUpperCase()}.json`;
+                dictionaryData = yield this._getDictionaryData(path + 'assets/' + fileName);
+            }
+            else {
+                this._client = client;
+            }
+            this._dictionary = dictionaryData ? dictionaryData : this._dictionary;
+        });
+    }
+    _getDictionaryData(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._jsonUtilsService.readJsonFile(path, false)
+                .catch(() => {
+                return null;
+            });
+        });
+    }
+}
+DictionaryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DictionaryService, deps: [{ token: i1.JsonUtilsService }], target: i0.ɵɵFactoryTarget.Injectable });
+DictionaryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DictionaryService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DictionaryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.JsonUtilsService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,96 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import { FileUtils } from '../utils/file.utils';
+import { DebugUtils } from '../utils/debug.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "./camera.service";
+import * as i2 from "./scene.service";
+import * as i3 from "./settings.service";
+import * as i4 from "./configurator-connector.service";
+export class DynamicCameraService {
+    constructor(_cameraService, _sceneService, _settingsService, _configuratorConnectorService) {
+        this._cameraService = _cameraService;
+        this._sceneService = _sceneService;
+        this._settingsService = _settingsService;
+        this._configuratorConnectorService = _configuratorConnectorService;
+    }
+    initCameraSettings() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.currentCameraSettings && this._settingsService.settings.cameraConfig) {
+                const fullPath = this._settingsService.settings.assetPath + 'assets/' + this._settingsService.settings.cameraConfig;
+                const cameraConfig = yield FileUtils.FileExists(fullPath, this._settingsService.settings.assetPath);
+                if (cameraConfig) {
+                    const configFile = yield fetch(fullPath);
+                    this.currentCameraSettings = yield configFile.json();
+                }
+                else {
+                    DebugUtils.log('Camera configuration file could not be found at ' + this._settingsService.settings.cameraConfig);
+                }
+            }
+        });
+    }
+    getCameraSettings() {
+        const settingsForCurrentSKU = this.currentCameraSettings
+            .find((settings) => settings.sku && settings.sku === this._configuratorConnectorService.sku);
+        const defaultCameraSettings = this.currentCameraSettings
+            .find((settings) => settings.sku === undefined);
+        return settingsForCurrentSKU ? settingsForCurrentSKU : defaultCameraSettings;
+    }
+    loadCustomCameraSettings() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.initCameraSettings();
+            if (this.currentCameraSettings) {
+                const settings = this.getCameraSettings();
+                if (settings) {
+                    this._cameraService.camera.position.set(settings.position.x, settings.position.y, settings.position.z);
+                    this._cameraService.camera.rotation.set(settings.rotation.x, settings.rotation.y, settings.rotation.z);
+                    this._cameraService.controls.maxAzimuthAngle = settings.maxHorizontalOrbit;
+                    this._cameraService.controls.minAzimuthAngle = settings.minHorizontalOrbit;
+                    this._cameraService.controls.maxPolarAngle = settings.maxVerticalOrbit;
+                    this._cameraService.controls.minPolarAngle = settings.minVerticalOrbit;
+                    this._cameraService.controls.maxDistance = settings.maxZoomDistance;
+                    this._cameraService.controls.minDistance = settings.minZoomDistance;
+                    this._cameraService.camera.updateProjectionMatrix();
+                    this._cameraService.controls.update();
+                    this._sceneService.needsRender = true;
+                }
+            }
+        });
+    }
+    exportCameraSettings() {
+        FileUtils.DownloadFile('camera_settings.json', JSON.stringify(this.currentCameraSettings));
+    }
+    saveSettingsToCurrentSettings(cameraSettings, asDefault) {
+        if (!this.currentCameraSettings) {
+            this.currentCameraSettings = [];
+        }
+        if (asDefault) {
+            const defaultCameraSettings = this.currentCameraSettings
+                .find((settings) => settings.sku === undefined);
+            if (defaultCameraSettings) {
+                this.currentCameraSettings.splice(this.currentCameraSettings.indexOf(defaultCameraSettings), 1, cameraSettings);
+            }
+            else {
+                this.currentCameraSettings.push(cameraSettings);
+            }
+        }
+        else {
+            const settingsForCurrentSKU = this.currentCameraSettings
+                .find((settings) => settings.sku && settings.sku === this._configuratorConnectorService.sku);
+            cameraSettings.sku = this._configuratorConnectorService.sku;
+            if (settingsForCurrentSKU) {
+                this.currentCameraSettings.splice(this.currentCameraSettings.indexOf(settingsForCurrentSKU), 1, cameraSettings);
+            }
+            else {
+                this.currentCameraSettings.push(cameraSettings);
+            }
+        }
+    }
+}
+DynamicCameraService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DynamicCameraService, deps: [{ token: i1.CameraService }, { token: i2.SceneService }, { token: i3.SettingsService }, { token: i4.ConfiguratorConnectorService }], target: i0.ɵɵFactoryTarget.Injectable });
+DynamicCameraService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DynamicCameraService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DynamicCameraService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.CameraService }, { type: i2.SceneService }, { type: i3.SettingsService }, { type: i4.ConfiguratorConnectorService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-camera.service.js","sourceRoot":"","sources":["../../../../../projects/configurator/src/lib/services/dynamic-camera.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from '@angular/core';\r\nimport {CameraSettings} from '../model/camera-settings';\r\nimport {CameraService} from './camera.service';\r\nimport {SceneService} from './scene.service';\r\nimport {SettingsService} from './settings.service';\r\nimport {FileUtils} from '../utils/file.utils';\r\nimport {ConfiguratorConnectorService} from './configurator-connector.service';\r\nimport {DebugUtils} from '../utils/debug.utils';\r\n\r\n@Injectable({providedIn: 'root'})\r\nexport class DynamicCameraService {\r\n\r\n  public currentCameraSettings: CameraSettings[];\r\n\r\n  constructor(\r\n    private _cameraService: CameraService,\r\n    private _sceneService: SceneService,\r\n    private _settingsService: SettingsService,\r\n    private _configuratorConnectorService: ConfiguratorConnectorService\r\n  ) {\r\n  }\r\n\r\n  public async initCameraSettings(): Promise<void> {\r\n    if (!this.currentCameraSettings && this._settingsService.settings.cameraConfig) {\r\n      const fullPath: string = this._settingsService.settings.assetPath + 'assets/' + this._settingsService.settings.cameraConfig;\r\n      const cameraConfig: boolean = await FileUtils.FileExists(fullPath, this._settingsService.settings.assetPath);\r\n      if (cameraConfig) {\r\n        const configFile: Response = await fetch(fullPath);\r\n        this.currentCameraSettings = await configFile.json();\r\n      } else {\r\n        DebugUtils.log('Camera configuration file could not be found at ' + this._settingsService.settings.cameraConfig);\r\n      }\r\n    }\r\n  }\r\n\r\n  public getCameraSettings(): CameraSettings {\r\n    const settingsForCurrentSKU: CameraSettings = this.currentCameraSettings\r\n      .find((settings) => settings.sku && settings.sku === this._configuratorConnectorService.sku);\r\n    const defaultCameraSettings: CameraSettings = this.currentCameraSettings\r\n      .find((settings) => settings.sku === undefined);\r\n    return settingsForCurrentSKU ? settingsForCurrentSKU : defaultCameraSettings;\r\n  }\r\n\r\n  public async loadCustomCameraSettings(): Promise<void> {\r\n    await this.initCameraSettings();\r\n\r\n    if (this.currentCameraSettings) {\r\n      const settings: CameraSettings = this.getCameraSettings();\r\n      if (settings) {\r\n        this._cameraService.camera.position.set(settings.position.x, settings.position.y, settings.position.z);\r\n        this._cameraService.camera.rotation.set(settings.rotation.x, settings.rotation.y, settings.rotation.z);\r\n        this._cameraService.controls.maxAzimuthAngle = settings.maxHorizontalOrbit;\r\n        this._cameraService.controls.minAzimuthAngle = settings.minHorizontalOrbit;\r\n        this._cameraService.controls.maxPolarAngle = settings.maxVerticalOrbit;\r\n        this._cameraService.controls.minPolarAngle = settings.minVerticalOrbit;\r\n        this._cameraService.controls.maxDistance = settings.maxZoomDistance;\r\n        this._cameraService.controls.minDistance = settings.minZoomDistance;\r\n        this._cameraService.camera.updateProjectionMatrix();\r\n        this._cameraService.controls.update();\r\n        this._sceneService.needsRender = true;\r\n      }\r\n    }\r\n  }\r\n\r\n  public exportCameraSettings(): any {\r\n    FileUtils.DownloadFile('camera_settings.json', JSON.stringify(this.currentCameraSettings));\r\n  }\r\n\r\n  public saveSettingsToCurrentSettings(cameraSettings: CameraSettings, asDefault: boolean): void {\r\n    if (!this.currentCameraSettings) {\r\n      this.currentCameraSettings = [];\r\n    }\r\n    if (asDefault) {\r\n      const defaultCameraSettings: CameraSettings = this.currentCameraSettings\r\n        .find((settings) => settings.sku === undefined);\r\n\r\n      if (defaultCameraSettings) {\r\n        this.currentCameraSettings.splice(this.currentCameraSettings.indexOf(defaultCameraSettings), 1, cameraSettings);\r\n      } else {\r\n        this.currentCameraSettings.push(cameraSettings);\r\n      }\r\n    } else {\r\n      const settingsForCurrentSKU: CameraSettings = this.currentCameraSettings\r\n        .find((settings) => settings.sku && settings.sku === this._configuratorConnectorService.sku);\r\n      cameraSettings.sku = this._configuratorConnectorService.sku;\r\n\r\n      if (settingsForCurrentSKU) {\r\n        this.currentCameraSettings.splice(this.currentCameraSettings.indexOf(settingsForCurrentSKU), 1, cameraSettings);\r\n      } else {\r\n        this.currentCameraSettings.push(cameraSettings);\r\n      }\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2015/lib/services/floor-plane.service.js

@@ -0,0 +1,252 @@
+import { __awaiter } from "tslib";
+import { Box3, Color, DoubleSide, Mesh, MeshStandardMaterial, PlaneGeometry, ShadowMaterial, Vector3 } from 'three';
+import { MaterialUtils } from '../utils/material.utils';
+import { isNill } from '@colijnit/configuratorapi/build/utils/function/is-nill.function';
+import { floorFadeShader } from '../core/shader/floor-fade.shader';
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { ObjectUtils } from '../utils/object.utils';
+import { TextureType } from '../enum/texture-type';
+import * as i0 from "@angular/core";
+import * as i1 from "./settings.service";
+import * as i2 from "./scene.service";
+import * as i3 from "./scene-options.service";
+import * as i4 from "./bundle-initialzer.service";
+export class FloorPlaneService {
+    constructor(_settingsService, _sceneService, _sceneOptionsService, _bundleInitializerService) {
+        this._settingsService = _settingsService;
+        this._sceneService = _sceneService;
+        this._sceneOptionsService = _sceneOptionsService;
+        this._bundleInitializerService = _bundleInitializerService;
+        this.floorPlaneCreated = new BehaviorSubject(false);
+        this._subs = [];
+        this._sceneReady = false;
+        this._texturesReady = false;
+        this._subs.push(this._sceneService.sceneInitialized.subscribe((loaded) => __awaiter(this, void 0, void 0, function* () {
+            if (loaded) {
+                this._sceneReady = true;
+                yield this.createFloorPlane();
+            }
+        })), this._bundleInitializerService.floorTexturesLoaded.subscribe((loaded) => __awaiter(this, void 0, void 0, function* () {
+            if (loaded) {
+                this._texturesReady = true;
+                yield this.createFloorPlane();
+            }
+        })));
+    }
+    get floorPlane() {
+        return this._floorPlane;
+    }
+    ngOnDestroy() {
+        this._subs.forEach(s => s.unsubscribe());
+    }
+    // Function for loading floorplane
+    createFloorPlane() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._sceneReady && this._texturesReady) {
+                this._standaloneFloors = this._bundleInitializerService.getFloorTextures();
+                const defaultFloor = this._bundleInitializerService.getFloorTexture();
+                const size = this._getStandaloneFloorSize();
+                const floorGeometry = new PlaneGeometry(size, size);
+                yield this._generateFloorPlane('white', defaultFloor, floorGeometry);
+                this._sceneService.scene.background = new Color(`#${this._settingsService.settings.standaloneSceneBackgroundColor}`);
+                this._sceneService.needsRender = true;
+                if (this._standaloneFloors && this._standaloneFloors.length > 1) {
+                    this._upsertFloorButtons(defaultFloor);
+                }
+                this.floorPlaneCreated.next(true);
+            }
+        });
+    }
+    // Function for getting center floorplane
+    getCenterFloorPlane() {
+        if (this._floorPlane) {
+            const box = new Box3().setFromObject(this._floorPlane);
+            return box.getCenter(new Vector3());
+        }
+        else {
+            return new Vector3(0, 0, 0);
+        }
+    }
+    getDimensions(scale = 1) {
+        const box = new Box3().setFromObject(this._floorPlane);
+        return {
+            x: {
+                min: box.min.x * scale,
+                max: box.max.x * scale
+            },
+            y: {
+                min: box.min.y * scale,
+                max: box.max.y * scale
+            }
+        };
+    }
+    getPlaneSize() {
+        const dim = this.getDimensions();
+        return new Vector3(dim.x.max - dim.x.min, 0, dim.y.max - dim.y.min);
+    }
+    _getStandaloneFloorSize() {
+        var _a, _b;
+        const defaultSize = 6;
+        const opts = (_b = (_a = this._settingsService) === null || _a === void 0 ? void 0 : _a.settings) === null || _b === void 0 ? void 0 : _b.options;
+        if (opts === null || opts === void 0 ? void 0 : opts.useCustomFloorSize) {
+            const s = Number(opts.customFloorSize);
+            return Number.isFinite(s) && s > 0 ? s : defaultSize;
+        }
+        return defaultSize;
+    }
+    _generateFloorPlane(color, texture, floorGeometry) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const geometry = floorGeometry;
+            this._sceneService.needsRender = true;
+            geometry.rotateX(Math.PI / 2);
+            const floorMaterial = yield this._createFloorMaterial(color, texture);
+            const floorMesh = new Mesh(geometry, floorMaterial);
+            const floorPlane = floorMesh;
+            floorPlane.name = 'floor-plane';
+            floorPlane.receiveShadow = true;
+            floorPlane.castShadow = false;
+            const floorCenter = new Vector3(0, 0, 0);
+            floorPlane.position.set(floorCenter.x, 0.0001, floorCenter.z);
+            this._sceneService.addObject(floorPlane, false);
+            this._floorPlane = floorPlane;
+            this._sceneService.needsRender = true;
+            return floorPlane;
+        });
+    }
+    _createFloorMaterial(color, texture) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = {
+                side: DoubleSide
+            };
+            if (color) {
+                options.color = color;
+            }
+            let floorMaterial;
+            if (texture && texture.type && texture.type === TextureType.SHADOW) {
+                floorMaterial = new ShadowMaterial(options);
+                if (texture.color) {
+                    floorMaterial.color = new Color(parseInt(texture.color, 0));
+                }
+                if (texture.opacity !== null && texture.opacity !== undefined) {
+                    floorMaterial.opacity = texture.opacity;
+                }
+                if (texture.transparent) {
+                    floorMaterial.transparent = true;
+                }
+                if (texture.depthWrite) {
+                    floorMaterial.depthWrite = true;
+                }
+                if (texture.depthTest) {
+                    floorMaterial.depthTest = true;
+                }
+                if (texture.toneMapped) {
+                    floorMaterial.toneMapped = true;
+                }
+            }
+            else {
+                floorMaterial = new MeshStandardMaterial(options);
+                floorMaterial.polygonOffset = true;
+                floorMaterial.polygonOffsetFactor = 0.5;
+                floorMaterial.name = 'default_floormaterial';
+                if (texture) {
+                    yield MaterialUtils.GetMaterialMaps(floorMaterial, texture);
+                    // Roughness value is set to 0.8 if no value is defined, this prevents highly reflective floors
+                    if (texture.color) {
+                        floorMaterial.color = new Color(parseInt(texture.color, 0));
+                    }
+                    if (texture.emissive) {
+                        floorMaterial.emissive = new Color(parseInt(texture.emissive, 0));
+                    }
+                    floorMaterial.roughness = !isNill(texture.roughness) ? texture.roughness : 0.8;
+                    floorMaterial.metalness = !isNill(texture.metalness) ? texture.metalness : 0;
+                    floorMaterial.bumpScale = !isNill(texture.bumpScale) ? texture.bumpScale : 1;
+                    if (texture.mirror) {
+                        floorMaterial.transparent = true;
+                        floorMaterial.opacity = 1;
+                    }
+                    floorMaterial.needsUpdate = true;
+                }
+                floorMaterial.onBeforeCompile = floorFadeShader;
+                floorMaterial.needsUpdate = true;
+            }
+            return floorMaterial;
+        });
+    }
+    _upsertFloorButtons(activeFloor) {
+        const floorButtons = [];
+        let newFloorButton;
+        this._standaloneFloors.forEach((f, index) => {
+            if (f !== activeFloor) {
+                newFloorButton = {
+                    id: index,
+                    elementId: `standalone_floor_${f.name}`,
+                    tooltip: f.name,
+                    class: 'circle',
+                    show: false,
+                    object: f,
+                    image: this._settingsService.settings.assetPath + f.url,
+                    click: (floor) => this._changeStandaloneFloor(floor)
+                };
+                floorButtons.push(newFloorButton);
+            }
+        });
+        const activeFloorButton = {
+            id: 10,
+            elementId: 'standalone_change_floor',
+            tooltip: 'CHANGE_FLOOR',
+            order: 8,
+            class: 'circle',
+            object: activeFloor,
+            children: floorButtons,
+            show: true,
+            image: activeFloor ? this._settingsService.settings.assetPath + activeFloor.url : ''
+        };
+        this._sceneOptionsService.updateSceneOptionButton(activeFloorButton);
+    }
+    _changeStandaloneFloor(floor) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO floor changes texture, but the repeat is not correct
+            yield this._setFloorTexture(floor);
+            this._upsertFloorButtons(floor);
+            this._sceneService.updatePathTracer();
+            this._sceneService.needsRender = true;
+        });
+    }
+    _setFloorTexture(texture) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const floorMaterial = yield this._createFloorMaterial(null, texture);
+            this._updateFloorMaterial(floorMaterial);
+        });
+    }
+    _updateFloorMaterial(floorMaterial) {
+        ObjectUtils.DisposeMaterial(this._getMaterials());
+        this._setUpdatedMaterial(floorMaterial);
+        this._sceneService.needsRender = true;
+        this._sceneService.updatePathTracer();
+    }
+    _setUpdatedMaterial(material) {
+        this._floorPlane.traverse((child) => {
+            if (child instanceof Mesh) {
+                child.material = material;
+                child.material.needsUpdate = true;
+            }
+        });
+    }
+    _getMaterials() {
+        const materials = [];
+        this._floorPlane.traverse((child) => {
+            if (child instanceof Mesh && child.material) {
+                materials.push(child.material);
+            }
+        });
+        return materials;
+    }
+}
+FloorPlaneService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FloorPlaneService, deps: [{ token: i1.SettingsService }, { token: i2.SceneService }, { token: i3.SceneOptionsService }, { token: i4.BundleInitializerService }], target: i0.ɵɵFactoryTarget.Injectable });
+FloorPlaneService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FloorPlaneService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FloorPlaneService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.SettingsService }, { type: i2.SceneService }, { type: i3.SceneOptionsService }, { type: i4.BundleInitializerService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"floor-plane.service.js","sourceRoot":"","sources":["../../../../../projects/configurator/src/lib/services/floor-plane.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Texture} from '../model/texture';\r\nimport {Box3, BufferGeometry, Color, DoubleSide, Material, Mesh, MeshStandardMaterial, Object3D, PlaneGeometry, ShadowMaterial, Vector3} from 'three';\r\nimport {SettingOptions} from '../model/setting-options';\r\nimport {MaterialUtils} from '../utils/material.utils';\r\nimport {isNill} from '@colijnit/configuratorapi/build/utils/function/is-nill.function';\r\nimport {floorFadeShader} from '../core/shader/floor-fade.shader';\r\nimport {SceneOptionButtonInterface} from '../interfaces/scene-option-button.interface';\r\nimport {SettingsService} from './settings.service';\r\nimport {SceneService} from './scene.service';\r\nimport {SceneOptionsService} from './scene-options.service';\r\nimport {BundleInitializerService} from './bundle-initialzer.service';\r\nimport {Injectable, OnDestroy} from '@angular/core';\r\nimport {BehaviorSubject, Subscription} from 'rxjs';\r\nimport {ObjectUtils} from '../utils/object.utils';\r\nimport {TextureType} from '../enum/texture-type';\r\n\r\n@Injectable({providedIn: 'root'})\r\nexport class FloorPlaneService implements OnDestroy {\r\n\r\n  public get floorPlane(): Object3D {\r\n    return this._floorPlane;\r\n  }\r\n\r\n  public floorPlaneCreated: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);\r\n\r\n  private _standaloneFloors: Texture[];\r\n  private _floorPlane: Object3D;\r\n  private _subs: Subscription[] = [];\r\n\r\n  private _sceneReady: boolean = false;\r\n  private _texturesReady: boolean = false;\r\n\r\n  constructor(\r\n    private _settingsService: SettingsService,\r\n    private _sceneService: SceneService,\r\n    private _sceneOptionsService: SceneOptionsService,\r\n    private _bundleInitializerService: BundleInitializerService\r\n  ) {\r\n\r\n    this._subs.push(\r\n      this._sceneService.sceneInitialized.subscribe(async (loaded) => {\r\n        if (loaded) {\r\n          this._sceneReady = true;\r\n          await this.createFloorPlane();\r\n        }\r\n      }),\r\n      this._bundleInitializerService.floorTexturesLoaded.subscribe(async (loaded) => {\r\n        if (loaded) {\r\n          this._texturesReady = true;\r\n          await this.createFloorPlane();\r\n        }\r\n      })\r\n    );\r\n  }\r\n\r\n  public ngOnDestroy(): void {\r\n    this._subs.forEach(s => s.unsubscribe());\r\n  }\r\n\r\n  // Function for loading floorplane\r\n  public async createFloorPlane(): Promise<void> {\r\n\r\n    if (this._sceneReady && this._texturesReady) {\r\n      this._standaloneFloors = this._bundleInitializerService.getFloorTextures();\r\n      const defaultFloor: Texture = this._bundleInitializerService.getFloorTexture();\r\n\r\n      const size: number = this._getStandaloneFloorSize();\r\n      const floorGeometry: PlaneGeometry = new PlaneGeometry(size, size);\r\n      await this._generateFloorPlane('white', defaultFloor, floorGeometry);\r\n\r\n      this._sceneService.scene.background = new Color(`#${this._settingsService.settings.standaloneSceneBackgroundColor}`);\r\n      this._sceneService.needsRender = true;\r\n      if (this._standaloneFloors && this._standaloneFloors.length > 1) {\r\n        this._upsertFloorButtons(defaultFloor);\r\n      }\r\n      this.floorPlaneCreated.next(true);\r\n    }\r\n  }\r\n\r\n  // Function for getting center floorplane\r\n  public getCenterFloorPlane(): Vector3 {\r\n    if (this._floorPlane) {\r\n      const box: Box3 = new Box3().setFromObject(this._floorPlane);\r\n      return box.getCenter(new Vector3());\r\n    } else {\r\n      return new Vector3(0, 0, 0);\r\n    }\r\n  }\r\n\r\n  public getDimensions(scale: number = 1) {\r\n    const box: Box3 = new Box3().setFromObject(this._floorPlane);\r\n    return {\r\n      x: {\r\n        min: box.min.x * scale,\r\n        max: box.max.x * scale\r\n      },\r\n      y: {\r\n        min: box.min.y * scale,\r\n        max: box.max.y * scale\r\n      }\r\n    };\r\n  }\r\n\r\n  public getPlaneSize(): Vector3 {\r\n    const dim = this.getDimensions();\r\n    return new Vector3(\r\n      dim.x.max - dim.x.min,\r\n      0,\r\n      dim.y.max - dim.y.min\r\n    );\r\n  }\r\n\r\n  private _getStandaloneFloorSize(): number {\r\n    const defaultSize: number = 6;\r\n    const opts: SettingOptions = this._settingsService?.settings?.options;\r\n\r\n    if (opts?.useCustomFloorSize) {\r\n      const s = Number(opts.customFloorSize);\r\n      return Number.isFinite(s) && s > 0 ? s : defaultSize;\r\n    }\r\n    return defaultSize;\r\n  }\r\n\r\n  private async _generateFloorPlane(\r\n    color: Color | string | number,\r\n    texture?: Texture,\r\n    floorGeometry?: BufferGeometry\r\n  ): Promise<Object3D> {\r\n\r\n    const geometry: BufferGeometry = floorGeometry;\r\n    this._sceneService.needsRender = true;\r\n    geometry.rotateX(Math.PI / 2);\r\n\r\n\r\n\r\n    const floorMaterial: MeshStandardMaterial | ShadowMaterial = await this._createFloorMaterial(color, texture);\r\n    const floorMesh: Mesh = new Mesh(geometry, floorMaterial);\r\n    const floorPlane: Object3D = floorMesh;\r\n    floorPlane.name = 'floor-plane';\r\n    floorPlane.receiveShadow = true;\r\n    floorPlane.castShadow = false;\r\n\r\n    const floorCenter: Vector3 = new Vector3(0, 0, 0);\r\n    floorPlane.position.set(floorCenter.x, 0.0001, floorCenter.z);\r\n    this._sceneService.addObject(floorPlane, false);\r\n    this._floorPlane = floorPlane;\r\n    this._sceneService.needsRender = true;\r\n    return floorPlane;\r\n  }\r\n\r\n  private async _createFloorMaterial(color: Color | string | number, texture?: Texture): Promise<MeshStandardMaterial | ShadowMaterial> {\r\n    const options: any = {\r\n      side: DoubleSide\r\n    };\r\n    if (color) {\r\n      options.color = color;\r\n    }\r\n\r\n\r\n    let floorMaterial: MeshStandardMaterial | ShadowMaterial;\r\n    if (texture && texture.type && texture.type === TextureType.SHADOW) {\r\n      floorMaterial = new ShadowMaterial(options);\r\n      if (texture.color) {\r\n        floorMaterial.color = new Color(parseInt(texture.color, 0));\r\n      }\r\n      if (texture.opacity !== null && texture.opacity !== undefined) {\r\n        floorMaterial.opacity = texture.opacity;\r\n      }\r\n      if (texture.transparent) {\r\n        floorMaterial.transparent = true;\r\n      }\r\n      if (texture.depthWrite) {\r\n        floorMaterial.depthWrite = true;\r\n      }\r\n      if (texture.depthTest) {\r\n        floorMaterial.depthTest = true;\r\n      }\r\n      if (texture.toneMapped) {\r\n        floorMaterial.toneMapped = true;\r\n      }\r\n    } else {\r\n      floorMaterial = new MeshStandardMaterial(options);\r\n      floorMaterial.polygonOffset = true;\r\n      floorMaterial.polygonOffsetFactor = 0.5;\r\n      floorMaterial.name = 'default_floormaterial';\r\n      if (texture) {\r\n        await MaterialUtils.GetMaterialMaps(floorMaterial, texture);\r\n        // Roughness value is set to 0.8 if no value is defined, this prevents highly reflective floors\r\n        if (texture.color) {\r\n          floorMaterial.color = new Color(parseInt(texture.color, 0));\r\n        }\r\n        if (texture.emissive) {\r\n          floorMaterial.emissive = new Color(parseInt(texture.emissive, 0));\r\n        }\r\n        floorMaterial.roughness = !isNill(texture.roughness) ? texture.roughness : 0.8;\r\n        floorMaterial.metalness = !isNill(texture.metalness) ? texture.metalness : 0;\r\n        floorMaterial.bumpScale = !isNill(texture.bumpScale) ? texture.bumpScale : 1;\r\n\r\n        if (texture.mirror) {\r\n          floorMaterial.transparent = true;\r\n          floorMaterial.opacity = 1;\r\n        }\r\n        floorMaterial.needsUpdate = true;\r\n      }\r\n      floorMaterial.onBeforeCompile = floorFadeShader;\r\n      floorMaterial.needsUpdate = true;\r\n    }\r\n    return floorMaterial;\r\n  }\r\n\r\n  private _upsertFloorButtons(activeFloor: Texture): void {\r\n    const floorButtons: SceneOptionButtonInterface[] = [];\r\n    let newFloorButton: SceneOptionButtonInterface;\r\n    this._standaloneFloors.forEach((f, index) => {\r\n      if (f !== activeFloor) {\r\n        newFloorButton = {\r\n          id: index,\r\n          elementId: `standalone_floor_${f.name}`,\r\n          tooltip: f.name,\r\n          class: 'circle',\r\n          show: false,\r\n          object: f,\r\n          image: this._settingsService.settings.assetPath + f.url,\r\n          click: (floor) => this._changeStandaloneFloor(floor)\r\n        };\r\n        floorButtons.push(newFloorButton);\r\n      }\r\n    });\r\n    const activeFloorButton: SceneOptionButtonInterface = {\r\n      id: 10,\r\n      elementId: 'standalone_change_floor',\r\n      tooltip: 'CHANGE_FLOOR',\r\n      order: 8,\r\n      class: 'circle',\r\n      object: activeFloor,\r\n      children: floorButtons,\r\n      show: true,\r\n      image: activeFloor ? this._settingsService.settings.assetPath + activeFloor.url : ''\r\n    };\r\n    this._sceneOptionsService.updateSceneOptionButton(activeFloorButton);\r\n  }\r\n\r\n  private async _changeStandaloneFloor(floor: Texture): Promise<void> {\r\n    // TODO floor changes texture, but the repeat is not correct\r\n    await this._setFloorTexture(floor);\r\n    this._upsertFloorButtons(floor);\r\n    this._sceneService.updatePathTracer();\r\n    this._sceneService.needsRender = true;\r\n  }\r\n\r\n  private async _setFloorTexture(texture: Texture): Promise<void> {\r\n    const floorMaterial: MeshStandardMaterial | ShadowMaterial = await this._createFloorMaterial(null, texture);\r\n    this._updateFloorMaterial(floorMaterial);\r\n  }\r\n\r\n  private _updateFloorMaterial(floorMaterial: Material): void {\r\n    ObjectUtils.DisposeMaterial(this._getMaterials());\r\n    this._setUpdatedMaterial(floorMaterial);\r\n    this._sceneService.needsRender = true;\r\n    this._sceneService.updatePathTracer();\r\n  }\r\n\r\n  private _setUpdatedMaterial(material: Material): void {\r\n    this._floorPlane.traverse((child: Object3D) => {\r\n      if (child instanceof Mesh) {\r\n        child.material = material;\r\n        child.material.needsUpdate = true;\r\n      }\r\n    });\r\n  }\r\n\r\n  private _getMaterials(): Material[] {\r\n    const materials: Material[] = [];\r\n    this._floorPlane.traverse((child: Object3D) => {\r\n      if (child instanceof Mesh && child.material) {\r\n        materials.push(child.material);\r\n      }\r\n    });\r\n    return materials;\r\n  }\r\n}\r\n"]}