@colijnit/homedecorator 255.1.1

package/esm2015/app/plugins/core3d/service/light-presets.service.js

@@ -0,0 +1,296 @@
+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 { AmbientLight, Color, DirectionalLight, HemisphereLight, PointLight, SpotLight } from 'three';
+import { BehaviorSubject } from 'rxjs';
+import { LightPreset, outputEncodingMap, shadowMapTypesMap } from '../../../core/model/light-preset';
+import { LightEnum } from '../../../core/enum/light.enum';
+import { DialogType } from '../../../shared/dialog/enum/dialog-type.enum';
+import { ErrorMessage } from '../../../core/model/error-message';
+import { LightProperties } from '../../../core/model/light-properties';
+import { LightCreateService } from '../../threedselector/threedselector/service/light-creation.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./lights.service";
+import * as i2 from "../../../core/service/homedecorator-settings.service";
+import * as i3 from "../../../core/service/homedecorator-app.service";
+import * as i4 from "../../../core/service/view-mode.service";
+import * as i5 from "./scene.service";
+import * as i6 from "../../../core/service/homedecorator-dictionary.service";
+import * as i7 from "../../../shared/dialog/service/dialog.service";
+import * as i8 from "../../../shared/screen-size-analysis/screen-size-analysis.service";
+export class LightPresetsService {
+    constructor(_lightsService, _settingsService, _appService, _viewModeService, _sceneService, _dictionaryService, _dialogService, _screenSizeAnalysis) {
+        this._lightsService = _lightsService;
+        this._settingsService = _settingsService;
+        this._appService = _appService;
+        this._viewModeService = _viewModeService;
+        this._sceneService = _sceneService;
+        this._dictionaryService = _dictionaryService;
+        this._dialogService = _dialogService;
+        this._screenSizeAnalysis = _screenSizeAnalysis;
+        this.presetLoaded = new BehaviorSubject(false);
+        // @ts-ignore
+        this._lightsMap = new Map([
+            [LightEnum.SpotLight, SpotLight],
+            [LightEnum.DirectionalLight, DirectionalLight],
+            [LightEnum.AmbientLight, AmbientLight],
+            [LightEnum.HemisphereLight, HemisphereLight],
+            [LightEnum.PointLight, PointLight]
+        ]);
+    }
+    set activeLightPreset(value) {
+        this._activeLightPreset = value;
+    }
+    get activeLightPreset() {
+        return this._activeLightPreset;
+    }
+    init() {
+        this._viewModeService.room3DUpdated.subscribe((updated) => {
+            if (updated) {
+                this.loadLightPreset(this.activeLightPreset);
+                this._lightsService.updateAllOffsets();
+            }
+        });
+        this._appService.lightPresetsLoaded.subscribe((lightPresets) => {
+            if (lightPresets) {
+                this.loadedLightPresets = lightPresets;
+                if (this.loadedLightPresets.length === 0) {
+                    this.createNewLightPreset();
+                }
+                else {
+                    if (!this._appService.sku) {
+                        const navigatorType = this._screenSizeAnalysis.navigatorType();
+                        let lightPreset = this.loadedLightPresets.find((preset) => preset.navigatorType === navigatorType && !preset.standalone);
+                        if (!lightPreset) {
+                            lightPreset = this.loadedLightPresets.find((preset) => preset.default);
+                        }
+                        if (lightPreset) {
+                            this.loadLightPreset(lightPreset);
+                        }
+                    }
+                }
+                if (this._appService.sku) {
+                    const navigatorType = this._screenSizeAnalysis.navigatorType();
+                    let lightPreset = this.loadedLightPresets.find((preset) => preset.navigatorType === navigatorType && preset.standalone);
+                    if (!lightPreset) {
+                        lightPreset = this.loadedLightPresets.find((preset) => preset.standalone);
+                    }
+                    if (!lightPreset.standalone) {
+                        lightPreset = this.loadedLightPresets.find((preset) => preset.default);
+                    }
+                    if (lightPreset) {
+                        this.loadLightPreset(lightPreset);
+                    }
+                }
+            }
+        });
+    }
+    ngOnDestroy() {
+        this._appService.lightPresetsLoaded.unsubscribe();
+        this._appService.skuSet.unsubscribe();
+        this._viewModeService.room3DUpdated.unsubscribe();
+    }
+    deleteCurrentPreset() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.saveOrDeletePreset(this.activeLightPreset, true);
+            const index = this.loadedLightPresets.findIndex(l => l.name === this.activeLightPreset.name);
+            this.loadedLightPresets.splice(index, 1);
+            if (this.loadedLightPresets.length === 0) {
+                this.createNewLightPreset();
+            }
+            this.loadLightPreset(this.loadedLightPresets[this.loadedLightPresets.length - 1]);
+        });
+    }
+    createNewLightPreset() {
+        this.loadedLightPresets.push(new LightPreset());
+        this.loadLightPreset(this.loadedLightPresets[this.loadedLightPresets.length - 1]);
+    }
+    loadLightPreset(lightPreset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // const bulbGeometry = new SphereGeometry( 0.2, 16, 8 );
+            // const bulbLight = new PointLight( 0xffee88, 1, 100, 2 );
+            //
+            // const bulbMat = new MeshStandardMaterial( {
+            //   emissive: 0xffffee,
+            //   emissiveIntensity: 1,
+            //   color: 0x000000
+            // } );
+            // bulbLight.add( new Mesh( bulbGeometry, bulbMat ) );
+            // bulbLight.position.set( 0, 2, 0 );
+            // bulbLight.castShadow = true;
+            // this._sceneService.addObject( bulbLight );
+            // const spotLight = new SpotLight(0xffffff, 4);
+            // spotLight.castShadow = true;
+            // spotLight.shadow.bias = -0.0001;
+            // spotLight.shadow.mapSize.width = 1024 * 4;
+            // spotLight.shadow.mapSize.height = 1024 * 4;
+            // spotLight.power = 4000;
+            // spotLight.position.set(10, 20, 0);
+            // spotLight.name = 'spot';
+            // this._sceneService.addObject(spotLight);
+            // const directionalLight = new DirectionalLight(0xffffff, 1);
+            // directionalLight.castShadow = true;
+            // directionalLight.shadow.bias = -0.0001;
+            // directionalLight.shadow.mapSize.width = 1024 * 4;
+            // directionalLight.shadow.mapSize.height = 1024 * 4;
+            // directionalLight.position.set(0, 2.6, 0);
+            // directionalLight.name = 'directional';
+            // this._sceneService.addObject(directionalLight);
+            // const hemiLight = new HemisphereLight(0xddeeff, 0x0f0e0d, 4);
+            // hemiLight.name = 'hemi';
+            // this._sceneService.addObject(hemiLight);
+            // const ambientLight = new AmbientLight(0xfffffff, 1);
+            // ambientLight.name = 'ambient';
+            // this._sceneService.addObject(ambientLight);
+            this._lightsService.removeAllLights();
+            // TODO
+            // this._sceneService.renderer.useLegacyLights = true;
+            this._sceneService.renderer.toneMappingExposure = lightPreset.toneMappingExposure;
+            this._sceneService.renderer.shadowMap.type = shadowMapTypesMap.get(lightPreset.shadowMapType);
+            this._sceneService.renderer.outputColorSpace = outputEncodingMap.get(lightPreset.outputEncoding);
+            for (const lightProperties of lightPreset.lights) {
+                this._createLightFromProperties(lightProperties);
+            }
+            this._lightsService.initiateLightPreset();
+            this._sceneService.rendererPropsChange();
+            this.activeLightPreset = lightPreset;
+            this.presetLoaded.next(true);
+        });
+    }
+    savePreset(preset) {
+        if (!preset) {
+            this.saveActivePreset();
+        }
+        else {
+            this.saveOrDeletePreset(this._prepareForSave(preset));
+        }
+    }
+    saveActivePreset() {
+        this.saveOrDeletePreset(this._prepareForSave(this.activeLightPreset));
+    }
+    saveOrDeletePreset(preset, deleteFromIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = this._settingsService.settings.assetPath + '/editIndex.php';
+            const data = {
+                file: 'assets/' + this._settingsService.settings.lightPresetsIndex,
+                data: [preset],
+                entry: 'lightpresets'
+            };
+            yield fetch(url, {
+                method: deleteFromIndex ? 'DELETE' : 'POST',
+                mode: deleteFromIndex ? 'cors' : 'no-cors',
+                cache: 'no-cache',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(data)
+            }).then((response) => {
+                const llPreset = this.loadedLightPresets.find(p => p.id === preset.id);
+                if (llPreset) {
+                    llPreset.dirty = false;
+                }
+            }).catch((error) => {
+                console.error(error);
+            });
+        });
+    }
+    removeLightByIndex(index) {
+        this.activeLightPreset.lights.splice(index, 1);
+    }
+    upsertLight(index, light) {
+        const lightProperties = new LightProperties();
+        for (const property in lightProperties) {
+            if (lightProperties.hasOwnProperty(property)) {
+                this._setObjectProperties(lightProperties, property, light[property]);
+            }
+        }
+        lightProperties.wallOffset = light.userData.wallOffset;
+        lightProperties.rotationOffset = light.userData.rotationOffset;
+        lightProperties.topDownDirectional = light.userData.topDownDirectional;
+        this.activeLightPreset.lights[index] = lightProperties;
+        this.activeLightPreset.dirty = true;
+    }
+    _checkDirtyPreset() {
+        return new Promise((resolve) => {
+            if (!this.activeLightPreset || !this.activeLightPreset.dirty) {
+                resolve();
+            }
+            else {
+                const messageConfig = {
+                    type: DialogType.Question,
+                    title: this._dictionaryService.get('SAVE'),
+                    messages: [new ErrorMessage(this._dictionaryService.get('SAVE_DIRTY_PRESET_MESSAGE'))]
+                };
+                const dialogRef = this._dialogService.showDialog({ data: messageConfig });
+                dialogRef.afterClosed().subscribe((result) => __awaiter(this, void 0, void 0, function* () {
+                    if (result) {
+                        yield this.saveActivePreset();
+                    }
+                    resolve();
+                }));
+            }
+        });
+    }
+    _createLightFromProperties(lightProperties) {
+        const lightType = lightProperties.type;
+        // const light: Light = new (this._lightsMap.get(lightType))();
+        const getLights = new LightCreateService();
+        const light = getLights.createNewLight(lightType);
+        light.userData.wallOffset = lightProperties.wallOffset;
+        light.userData.rotationOffset = lightProperties.rotationOffset;
+        light.userData.topDownDirectional = lightProperties.topDownDirectional;
+        for (const property in lightProperties) {
+            if (!light.hasOwnProperty(property)) {
+                continue;
+            }
+            if (property === 'position') {
+                light.position.y = lightProperties.position.y;
+            }
+            else if (property === 'color') {
+                light.color = new Color(lightProperties.color);
+            }
+            else if (property === 'groundColor') {
+                light.groundColor = new Color(lightProperties.groundColor);
+            }
+            else {
+                this._setObjectProperties(light, property, lightProperties[property]);
+            }
+        }
+        this._lightsService.addLight(light);
+    }
+    _setObjectProperties(object, property, value) {
+        if (property === 'shadow') {
+            for (const prop in value) {
+                if (!object[property].hasOwnProperty(prop)) {
+                    continue;
+                }
+                object[property][prop] = value[prop];
+            }
+        }
+        else {
+            object[property] = value;
+        }
+    }
+    _prepareForSave(preset) {
+        const result = JSON.parse(JSON.stringify(preset));
+        result.shadowMapType = shadowMapTypesMap.get(preset.shadowMapType);
+        result.outputEncoding = outputEncodingMap.get(preset.outputEncoding);
+        return result;
+    }
+}
+LightPresetsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: LightPresetsService, deps: [{ token: i1.LightsService }, { token: i2.HomedecoratorSettingsService }, { token: i3.HomedecoratorAppService }, { token: i4.ViewModeService }, { token: i5.SceneService }, { token: i6.HomedecoratorDictionaryService }, { token: i7.DialogService }, { token: i8.ScreenSizeAnalysisService }], target: i0.ɵɵFactoryTarget.Injectable });
+LightPresetsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: LightPresetsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: LightPresetsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.LightsService }, { type: i2.HomedecoratorSettingsService }, { type: i3.HomedecoratorAppService }, { type: i4.ViewModeService }, { type: i5.SceneService }, { type: i6.HomedecoratorDictionaryService }, { type: i7.DialogService }, { type: i8.ScreenSizeAnalysisService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"light-presets.service.js","sourceRoot":"","sources":["../../../../../../../src/client/app/plugins/core3d/service/light-presets.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\r\nimport {\r\n  AmbientLight,\r\n  Color,\r\n  DirectionalLight,\r\n  HemisphereLight,\r\n  Light,\r\n  Mesh,\r\n  MeshStandardMaterial,\r\n  PointLight,\r\n  SphereGeometry,\r\n  SpotLight\r\n} from 'three';\r\nimport {BehaviorSubject} from 'rxjs';\r\nimport {MatDialogRef} from '@angular/material/dialog';\r\nimport {LightPreset, outputEncodingMap, shadowMapTypesMap} from '../../../core/model/light-preset';\r\nimport {LightEnum} from '../../../core/enum/light.enum';\r\nimport {LightsService} from './lights.service';\r\nimport {HomedecoratorSettingsService} from '../../../core/service/homedecorator-settings.service';\r\nimport {HomedecoratorAppService} from '../../../core/service/homedecorator-app.service';\r\nimport {ViewModeService} from '../../../core/service/view-mode.service';\r\nimport {SceneService} from './scene.service';\r\nimport {HomedecoratorDictionaryService} from '../../../core/service/homedecorator-dictionary.service';\r\nimport {DialogService} from '../../../shared/dialog/service/dialog.service';\r\nimport {ScreenSizeAnalysisService} from '../../../shared/screen-size-analysis/screen-size-analysis.service';\r\nimport {ViewMode} from '../../../core/enum/view-mode.enum';\r\nimport {NavigatorType} from '../../../shared/screen-size-analysis/navigator-type.enum';\r\nimport {DialogConfig} from '../../../shared/dialog/interface/dialog-config.interface';\r\nimport {DialogType} from '../../../shared/dialog/enum/dialog-type.enum';\r\nimport {ErrorMessage} from '../../../core/model/error-message';\r\nimport {DialogComponent} from '../../../shared/dialog/dialog.component';\r\nimport {LightProperties} from '../../../core/model/light-properties';\r\nimport {LightCreateService} from '../../threedselector/threedselector/service/light-creation.service';\r\nimport {ItemService} from './item.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class LightPresetsService implements OnDestroy {\r\n\r\n  public set activeLightPreset(value: LightPreset) {\r\n    this._activeLightPreset = value;\r\n  }\r\n\r\n  public get activeLightPreset(): LightPreset {\r\n    return this._activeLightPreset;\r\n  }\r\n\r\n  public loadedLightPresets: LightPreset[];\r\n  public presetLoaded: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);\r\n\r\n  private _activeLightPreset: LightPreset;\r\n  // @ts-ignore\r\n  private _lightsMap: Map<LightEnum, typeof Light> = new Map<LightEnum, typeof Light>([\r\n    [LightEnum.SpotLight, SpotLight],\r\n    [LightEnum.DirectionalLight, DirectionalLight],\r\n    [LightEnum.AmbientLight, AmbientLight],\r\n    [LightEnum.HemisphereLight, HemisphereLight],\r\n    [LightEnum.PointLight, PointLight]\r\n  ]);\r\n\r\n  constructor(\r\n    private _lightsService: LightsService,\r\n    private _settingsService: HomedecoratorSettingsService,\r\n    private _appService: HomedecoratorAppService,\r\n    private _viewModeService: ViewModeService,\r\n    private _sceneService: SceneService,\r\n    private _dictionaryService: HomedecoratorDictionaryService,\r\n    private _dialogService: DialogService,\r\n    private _screenSizeAnalysis: ScreenSizeAnalysisService\r\n  ) {\r\n  }\r\n\r\n  init(): void {\r\n    this._viewModeService.room3DUpdated.subscribe((updated: boolean) => {\r\n      if (updated) {\r\n        this.loadLightPreset(this.activeLightPreset);\r\n        this._lightsService.updateAllOffsets();\r\n      }\r\n    });\r\n    this._appService.lightPresetsLoaded.subscribe((lightPresets: LightPreset[]) => {\r\n      if (lightPresets) {\r\n        this.loadedLightPresets = lightPresets;\r\n        if (this.loadedLightPresets.length === 0) {\r\n          this.createNewLightPreset();\r\n        } else {\r\n          if (!this._appService.sku) {\r\n            const navigatorType: NavigatorType = this._screenSizeAnalysis.navigatorType();\r\n            let lightPreset: LightPreset = this.loadedLightPresets.find((preset) => preset.navigatorType === navigatorType && !preset.standalone);\r\n            if (!lightPreset) {\r\n              lightPreset = this.loadedLightPresets.find((preset) => preset.default);\r\n            }\r\n            if (lightPreset) {\r\n              this.loadLightPreset(lightPreset);\r\n            }\r\n          }\r\n        }\r\n        if (this._appService.sku) {\r\n          const navigatorType: NavigatorType = this._screenSizeAnalysis.navigatorType();\r\n          let lightPreset: LightPreset =\r\n            this.loadedLightPresets.find((preset) => preset.navigatorType === navigatorType && preset.standalone);\r\n          if (!lightPreset) {\r\n            lightPreset = this.loadedLightPresets.find((preset) => preset.standalone);\r\n          }\r\n          if (!lightPreset.standalone) {\r\n            lightPreset = this.loadedLightPresets.find((preset) => preset.default);\r\n          }\r\n          if (lightPreset) {\r\n            this.loadLightPreset(lightPreset);\r\n          }\r\n        }\r\n      }\r\n    });\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this._appService.lightPresetsLoaded.unsubscribe();\r\n    this._appService.skuSet.unsubscribe();\r\n    this._viewModeService.room3DUpdated.unsubscribe();\r\n  }\r\n\r\n  public async deleteCurrentPreset(): Promise<void> {\r\n    await this.saveOrDeletePreset(this.activeLightPreset, true);\r\n    const index = this.loadedLightPresets.findIndex(l => l.name === this.activeLightPreset.name);\r\n    this.loadedLightPresets.splice(index, 1);\r\n    if (this.loadedLightPresets.length === 0) {\r\n      this.createNewLightPreset();\r\n    }\r\n    this.loadLightPreset(this.loadedLightPresets[this.loadedLightPresets.length - 1]);\r\n  }\r\n\r\n  public createNewLightPreset(): void {\r\n    this.loadedLightPresets.push(new LightPreset());\r\n    this.loadLightPreset(this.loadedLightPresets[this.loadedLightPresets.length - 1]);\r\n  }\r\n\r\n  public async loadLightPreset(lightPreset: LightPreset): Promise<void> {\r\n    // const bulbGeometry = new SphereGeometry( 0.2, 16, 8 );\r\n    // const bulbLight = new PointLight( 0xffee88, 1, 100, 2 );\r\n    //\r\n    // const bulbMat = new MeshStandardMaterial( {\r\n    //   emissive: 0xffffee,\r\n    //   emissiveIntensity: 1,\r\n    //   color: 0x000000\r\n    // } );\r\n    // bulbLight.add( new Mesh( bulbGeometry, bulbMat ) );\r\n    // bulbLight.position.set( 0, 2, 0 );\r\n    // bulbLight.castShadow = true;\r\n    // this._sceneService.addObject( bulbLight );\r\n\r\n    // const spotLight = new SpotLight(0xffffff, 4);\r\n    // spotLight.castShadow = true;\r\n    // spotLight.shadow.bias = -0.0001;\r\n    // spotLight.shadow.mapSize.width = 1024 * 4;\r\n    // spotLight.shadow.mapSize.height = 1024 * 4;\r\n    // spotLight.power = 4000;\r\n    // spotLight.position.set(10, 20, 0);\r\n    // spotLight.name = 'spot';\r\n    // this._sceneService.addObject(spotLight);\r\n    // const directionalLight = new DirectionalLight(0xffffff, 1);\r\n    // directionalLight.castShadow = true;\r\n    // directionalLight.shadow.bias = -0.0001;\r\n    // directionalLight.shadow.mapSize.width = 1024 * 4;\r\n    // directionalLight.shadow.mapSize.height = 1024 * 4;\r\n    // directionalLight.position.set(0, 2.6, 0);\r\n    // directionalLight.name = 'directional';\r\n    // this._sceneService.addObject(directionalLight);\r\n\r\n    // const hemiLight = new HemisphereLight(0xddeeff, 0x0f0e0d, 4);\r\n    // hemiLight.name = 'hemi';\r\n    // this._sceneService.addObject(hemiLight);\r\n    // const ambientLight = new AmbientLight(0xfffffff, 1);\r\n    // ambientLight.name = 'ambient';\r\n    // this._sceneService.addObject(ambientLight);\r\n\r\n\r\n    this._lightsService.removeAllLights();\r\n    // TODO\r\n    // this._sceneService.renderer.useLegacyLights = true;\r\n    this._sceneService.renderer.toneMappingExposure = lightPreset.toneMappingExposure;\r\n    this._sceneService.renderer.shadowMap.type = shadowMapTypesMap.get(lightPreset.shadowMapType);\r\n    this._sceneService.renderer.outputColorSpace  = outputEncodingMap.get(lightPreset.outputEncoding);\r\n    for (const lightProperties of lightPreset.lights) {\r\n      this._createLightFromProperties(lightProperties);\r\n    }\r\n    this._lightsService.initiateLightPreset();\r\n    this._sceneService.rendererPropsChange();\r\n    this.activeLightPreset = lightPreset;\r\n    this.presetLoaded.next(true);\r\n  }\r\n\r\n  public savePreset(preset?: LightPreset): void {\r\n    if (!preset) {\r\n      this.saveActivePreset();\r\n    } else {\r\n      this.saveOrDeletePreset(this._prepareForSave(preset));\r\n    }\r\n  }\r\n\r\n  public saveActivePreset(): void {\r\n    this.saveOrDeletePreset(this._prepareForSave(this.activeLightPreset));\r\n  }\r\n\r\n  public async saveOrDeletePreset(preset: LightPreset, deleteFromIndex?: boolean): Promise<void> {\r\n    const url = this._settingsService.settings.assetPath + '/editIndex.php';\r\n    const data = {\r\n      file: 'assets/' + this._settingsService.settings.lightPresetsIndex,\r\n      data: [preset],\r\n      entry: 'lightpresets'\r\n    };\r\n\r\n    await fetch(url, {\r\n      method: deleteFromIndex ? 'DELETE' : 'POST',\r\n      mode: deleteFromIndex ? 'cors' : 'no-cors',\r\n      cache: 'no-cache',\r\n      headers: {\r\n        'Content-Type': 'application/json'\r\n      },\r\n      body: JSON.stringify(data)\r\n    }).then((response) => {\r\n      const llPreset: LightPreset = this.loadedLightPresets.find(p => p.id === preset.id);\r\n      if (llPreset) {\r\n        llPreset.dirty = false;\r\n      }\r\n    }).catch((error) => {\r\n      console.error(error);\r\n    });\r\n  }\r\n\r\n  public removeLightByIndex(index: number): void {\r\n    this.activeLightPreset.lights.splice(index, 1);\r\n  }\r\n\r\n  public upsertLight(index: number, light: Light): void {\r\n    const lightProperties = new LightProperties();\r\n    for (const property in lightProperties) {\r\n      if (lightProperties.hasOwnProperty(property)) {\r\n        this._setObjectProperties(lightProperties, property, light[property]);\r\n      }\r\n    }\r\n    lightProperties.wallOffset = light.userData.wallOffset;\r\n    lightProperties.rotationOffset = light.userData.rotationOffset;\r\n    lightProperties.topDownDirectional = light.userData.topDownDirectional;\r\n    this.activeLightPreset.lights[index] = lightProperties;\r\n    this.activeLightPreset.dirty = true;\r\n  }\r\n\r\n  private _checkDirtyPreset(): Promise<void> {\r\n    return new Promise((resolve: Function) => {\r\n      if (!this.activeLightPreset || !this.activeLightPreset.dirty) {\r\n        resolve();\r\n      } else {\r\n        const messageConfig: DialogConfig = {\r\n          type: DialogType.Question,\r\n          title: this._dictionaryService.get('SAVE'),\r\n          messages: [new ErrorMessage(this._dictionaryService.get('SAVE_DIRTY_PRESET_MESSAGE'))]\r\n        };\r\n        const dialogRef: MatDialogRef<DialogComponent> = this._dialogService.showDialog({data: messageConfig});\r\n        dialogRef.afterClosed().subscribe(async result => {\r\n          if (result) {\r\n            await this.saveActivePreset();\r\n          }\r\n          resolve();\r\n        });\r\n      }\r\n    });\r\n  }\r\n\r\n  private _createLightFromProperties(lightProperties: LightProperties) {\r\n    const lightType: LightEnum = lightProperties.type;\r\n    // const light: Light = new (this._lightsMap.get(lightType))();\r\n    const getLights: LightCreateService = new LightCreateService();\r\n    const light: Light = getLights.createNewLight(lightType);\r\n    light.userData.wallOffset = lightProperties.wallOffset;\r\n    light.userData.rotationOffset = lightProperties.rotationOffset;\r\n    light.userData.topDownDirectional = lightProperties.topDownDirectional;\r\n\r\n    for (const property in lightProperties) {\r\n      if (!light.hasOwnProperty(property)) {\r\n        continue;\r\n      }\r\n      if (property === 'position') {\r\n        light.position.y = lightProperties.position.y;\r\n      } else if (property === 'color') {\r\n        light.color = new Color(lightProperties.color);\r\n      } else if (property === 'groundColor') {\r\n        (light as any).groundColor = new Color(lightProperties.groundColor);\r\n      } else {\r\n        this._setObjectProperties(light, property, lightProperties[property]);\r\n      }\r\n    }\r\n\r\n    this._lightsService.addLight(light);\r\n  }\r\n\r\n  private _setObjectProperties(object: Light | LightProperties, property: any, value: any): void {\r\n    if (property === 'shadow') {\r\n      for (const prop in value) {\r\n        if (!object[property].hasOwnProperty(prop)) {\r\n          continue;\r\n        }\r\n        object[property][prop] = value[prop];\r\n      }\r\n    } else {\r\n      object[property] = value;\r\n    }\r\n  }\r\n\r\n  private _prepareForSave(preset: LightPreset): any {\r\n    const result: any = JSON.parse(JSON.stringify(preset));\r\n    result.shadowMapType = shadowMapTypesMap.get(preset.shadowMapType);\r\n    result.outputEncoding = outputEncodingMap.get(preset.outputEncoding);\r\n    return result;\r\n  }\r\n}\r\n"]}

package/esm2015/app/plugins/core3d/service/lights.service.js

@@ -0,0 +1,190 @@
+import { Injectable } from '@angular/core';
+import { AmbientLight, DirectionalLight, HemisphereLight, PointLight, SpotLight } from 'three';
+import { Subject } from 'rxjs';
+import { ConfigurationKey } from '../../../core/enum/configuration-key.enum';
+import { LightCreateService } from '../../threedselector/threedselector/service/light-creation.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./scene.service";
+import * as i2 from "../../../core/service/configuration.service";
+import * as i3 from "../../room-planner/components/floorplanner/service/floorplan.service";
+import * as i4 from "./item.service";
+export class LightsService {
+    constructor(_sceneService, _configurationService, _floorplanService, _itemService) {
+        this._sceneService = _sceneService;
+        this._configurationService = _configurationService;
+        this._floorplanService = _floorplanService;
+        this._itemService = _itemService;
+        this.lights = [];
+        this.onLightAdded = new Subject();
+        this._subs = [];
+    }
+    ngOnDestroy() {
+        this._subs.forEach(s => s.unsubscribe());
+    }
+    init() {
+        this._subs.push(this._floorplanService.roomLoaded.subscribe(() => this.updateAllOffsets()), this._floorplanService.roomsUpdated.subscribe(() => this.updateAllOffsets()), this._configurationService.onChange.subscribe((changed) => {
+            if (ConfigurationKey.ShowInteriorLights in changed) {
+                this._showHideInteriorLights(changed[ConfigurationKey.ShowInteriorLights]);
+            }
+            if (ConfigurationKey.InteriorLightIntensity in changed) {
+                this._updateInteriorLights(changed[ConfigurationKey.InteriorLightIntensity]);
+            }
+        }));
+        // this._initLights();
+    }
+    createLight(modelClass) {
+        const getLights = new LightCreateService();
+        const light = getLights.createNewLight(modelClass);
+        // const light: T = new modelClass();
+        light.name = `new_${modelClass.name}`;
+        this._addLight(light);
+        this.onLightAdded.next({ light: light, index: this.lights.length - 1 });
+    }
+    addLight(light) {
+        // if (light.rotation) {
+        //   this.updateOffsets(light);
+        // }
+        // this.lights.push(light);
+        this._addLight(light);
+    }
+    removeLightByIndex(idx, updateLightArray = true) {
+        this._removeLight(this.lights[idx], updateLightArray);
+    }
+    removeAllLights() {
+        const currentLights = this.lights.slice();
+        // this.lights.length = 0;
+        currentLights.forEach(cl => {
+            this._removeLight(cl);
+        });
+    }
+    replaceLight(idx, light) {
+        this.removeLightByIndex(idx, false);
+        this._addLight(light, false);
+        this.lights[idx] = light;
+    }
+    initiateLightPreset() {
+        // this.lights.forEach(l => this._sceneService.addObject(l));
+        this.lights.forEach(l => this.updateOffsets(l));
+    }
+    updateAllOffsets() {
+        this.lights.forEach(l => this.updateOffsets(l));
+    }
+    updateOffsets(light) {
+        if (light instanceof AmbientLight || light instanceof HemisphereLight) {
+            return;
+        }
+        const ro = light.userData.rotationOffset;
+        const wo = light.userData.wallOffset;
+        const fc = this._floorplanService.getCenter();
+        const size = this._floorplanService.getSize();
+        const planHalfWidth = isFinite(size.x) ? size.x / 2.0 : 0;
+        const planHalfDepth = isFinite(size.z) ? size.z / 2.0 : 0;
+        // Reset position & rotation
+        light.position.x = fc.x;
+        light.position.z = fc.z;
+        light.rotation.set(0, 0, 0);
+        // Offset to the appropriate corner & translate in the opposite direction in equal steps based on the room dimensions.
+        if (ro > 315) {
+            light.translateZ(Math.abs(planHalfDepth + wo));
+            light.translateX(Math.abs(planHalfWidth + wo));
+            light.translateX(-Math.abs((((planHalfWidth * 2) + (wo * 2)) / 90) * (ro - 315)));
+        }
+        else if (ro > 225) {
+            light.translateX(Math.abs(planHalfWidth + wo));
+            light.translateZ(-Math.abs(planHalfDepth + wo));
+            light.translateZ(Math.abs((((planHalfDepth * 2) + (wo * 2)) / 90) * (ro - 225)));
+        }
+        else if (ro > 135) {
+            light.translateZ(-Math.abs(planHalfDepth + wo));
+            light.translateX(-Math.abs(planHalfWidth + wo));
+            light.translateX(Math.abs((((planHalfWidth * 2) + (wo * 2)) / 90) * (ro - 135)));
+        }
+        else if (ro > 45) {
+            light.translateX(-Math.abs(planHalfWidth + wo));
+            light.translateZ(Math.abs(planHalfDepth + wo));
+            light.translateZ(-Math.abs((((planHalfDepth * 2) + (wo * 2)) / 90) * (ro - 45)));
+        }
+        else if (ro >= 0) {
+            light.translateZ(Math.abs(planHalfDepth + wo));
+            light.translateX(-Math.abs((((planHalfWidth * 2) + (wo * 2)) / 90) * ro));
+        }
+        this._updateShadowCamera(light);
+    }
+    _showHideInteriorLights(show) {
+        this._itemService.items.forEach((item) => {
+            item.traverse(c => {
+                if (c.name && c.name.toLowerCase() === 'light_bulb') {
+                    c.traverse(l => {
+                        if (l instanceof PointLight) {
+                            l.visible = show;
+                        }
+                    });
+                }
+            });
+        });
+        this._sceneService.needsRender = true;
+    }
+    _updateInteriorLights(power) {
+        this._itemService.items.forEach((item) => {
+            item.traverse(c => {
+                if (c.name && c.name.toLowerCase() === 'light_bulb') {
+                    c.traverse(l => {
+                        if (l instanceof PointLight) {
+                            l.power = power;
+                        }
+                    });
+                }
+            });
+        });
+        this._sceneService.needsRender = true;
+    }
+    _removeLight(light, updateLightArray = true) {
+        const idx = this.lights.indexOf(light);
+        if (light instanceof SpotLight || light instanceof DirectionalLight) {
+            this._sceneService.removeObject(light.target);
+        }
+        this._sceneService.removeObject(light);
+        if (updateLightArray) {
+            this.lights.splice(idx, 1);
+        }
+    }
+    _addLight(light, updateLightArray = true) {
+        this._sceneService.addObject(light);
+        if (light instanceof SpotLight || light instanceof DirectionalLight) {
+            this._sceneService.addObject(light.target);
+            this._updateShadowCamera(light);
+        }
+        if (updateLightArray) {
+            this.lights.push(light);
+        }
+    }
+    _updateShadowCamera(light) {
+        const size = this._floorplanService.getSize();
+        if (size.x === -Infinity || size.y === -Infinity || size.z === -Infinity ||
+            size.x === Infinity || size.y === Infinity || size.z === Infinity) {
+            return;
+        }
+        const dWidth = (size.x + 3) / 2.0;
+        const dHeight = (size.z + 3) / 2.0;
+        const center = this._floorplanService.getCenter();
+        if (light instanceof SpotLight || light instanceof DirectionalLight) {
+            if (light instanceof DirectionalLight && light.userData.topDownDirectional) {
+                light.position.set(center.x, 3, center.z);
+                light.shadow.camera.left = -dWidth;
+                light.shadow.camera.right = dWidth;
+                light.shadow.camera.top = dHeight;
+                light.shadow.camera.bottom = -dHeight;
+            }
+            light.target.position.copy(center);
+        }
+    }
+}
+LightsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: LightsService, deps: [{ token: i1.SceneService }, { token: i2.ConfigurationService }, { token: i3.FloorplanService }, { token: i4.ItemService }], target: i0.ɵɵFactoryTarget.Injectable });
+LightsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: LightsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: LightsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SceneService }, { type: i2.ConfigurationService }, { type: i3.FloorplanService }, { type: i4.ItemService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lights.service.js","sourceRoot":"","sources":["../../../../../../../src/client/app/plugins/core3d/service/lights.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAY,MAAM,eAAe,CAAC;AACpD,OAAO,EAAC,YAAY,EAAE,gBAAgB,EAAE,eAAe,EAAS,UAAU,EAAE,SAAS,EAAC,MAAM,OAAO,CAAC;AACpG,OAAO,EAAC,OAAO,EAAe,MAAM,MAAM,CAAC;AAK3C,OAAO,EAAC,gBAAgB,EAAC,MAAM,2CAA2C,CAAC;AAC3E,OAAO,EAAC,kBAAkB,EAAC,MAAM,oEAAoE,CAAC;;;;;;AAKtG,MAAM,OAAO,aAAa;IAOxB,YACU,aAA2B,EAC3B,qBAA2C,EAC3C,iBAAmC,EACnC,YAAyB;QAHzB,kBAAa,GAAb,aAAa,CAAc;QAC3B,0BAAqB,GAArB,qBAAqB,CAAsB;QAC3C,sBAAiB,GAAjB,iBAAiB,CAAkB;QACnC,iBAAY,GAAZ,YAAY,CAAa;QAT5B,WAAM,GAAY,EAAE,CAAC;QACrB,iBAAY,GAA2C,IAAI,OAAO,EAAiC,CAAC;QAEnG,UAAK,GAAmB,EAAE,CAAC;IAOhC,CAAC;IAEJ,WAAW;QACT,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC;IAC3C,CAAC;IAEM,IAAI;QACT,IAAI,CAAC,KAAK,CAAC,IAAI,CACb,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,EAC1E,IAAI,CAAC,iBAAiB,CAAC,YAAY,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,EAC5E,IAAI,CAAC,qBAAqB,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,EAAE;YACxD,IAAI,gBAAgB,CAAC,kBAAkB,IAAI,OAAO,EAAE;gBAClD,IAAI,CAAC,uBAAuB,CAAC,OAAO,CAAC,gBAAgB,CAAC,kBAAkB,CAAC,CAAC,CAAC;aAC5E;YACD,IAAI,gBAAgB,CAAC,sBAAsB,IAAI,OAAO,EAAE;gBACtD,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC,gBAAgB,CAAC,sBAAsB,CAAC,CAAC,CAAC;aAC9E;QACH,CAAC,CAAC,CACH,CAAC;QACF,sBAAsB;IACxB,CAAC;IAEM,WAAW,CAAkB,UAAe;QAEjD,MAAM,SAAS,GAAuB,IAAI,kBAAkB,EAAE,CAAC;QAC/D,MAAM,KAAK,GAAU,SAAS,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;QAE1D,qCAAqC;QACrC,KAAK,CAAC,IAAI,GAAG,OAAO,UAAU,CAAC,IAAI,EAAE,CAAC;QACtC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACtB,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,EAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAC,CAAC,CAAC;IACxE,CAAC;IAEM,QAAQ,CAAC,KAAY;QAC1B,wBAAwB;QACxB,+BAA+B;QAC/B,IAAI;QACJ,2BAA2B;QAC3B,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IACxB,CAAC;IAEM,kBAAkB,CAAC,GAAW,EAAE,mBAA4B,IAAI;QACrE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,gBAAgB,CAAC,CAAC;IACxD,CAAC;IAEM,eAAe;QACpB,MAAM,aAAa,GAAY,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;QACnD,0BAA0B;QAC1B,aAAa,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE;YACzB,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC;QACxB,CAAC,CAAC,CAAC;IACL,CAAC;IAEM,YAAY,CAAC,GAAW,EAAE,KAAY;QAC3C,IAAI,CAAC,kBAAkB,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QACpC,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QAC7B,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;IAC3B,CAAC;IAEM,mBAAmB;QACxB,6DAA6D;QAC7D,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;IAClD,CAAC;IAEM,gBAAgB;QACrB,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;IAClD,CAAC;IAEM,aAAa,CAAC,KAAY;QAC/B,IAAI,KAAK,YAAY,YAAY,IAAI,KAAK,YAAY,eAAe,EAAE;YACrE,OAAO;SACR;QACD,MAAM,EAAE,GAAG,KAAK,CAAC,QAAQ,CAAC,cAAc,CAAC;QACzC,MAAM,EAAE,GAAG,KAAK,CAAC,QAAQ,CAAC,UAAU,CAAC;QACrC,MAAM,EAAE,GAAG,IAAI,CAAC,iBAAiB,CAAC,SAAS,EAAE,CAAC;QAE9C,MAAM,IAAI,GAAG,IAAI,CAAC,iBAAiB,CAAC,OAAO,EAAE,CAAC;QAC9C,MAAM,aAAa,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAC1D,MAAM,aAAa,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAE1D,4BAA4B;QAC5B,KAAK,CAAC,QAAQ,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;QACxB,KAAK,CAAC,QAAQ,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;QACxB,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QAE5B,sHAAsH;QACtH,IAAI,EAAE,GAAG,GAAG,EAAE;YACZ,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,GAAG,EAAE,CAAC,CAAC,CAAC;YAC/C,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,GAAG,EAAE,CAAC,CAAC,CAAC;YAC/C,KAAK,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,aAAa,GAAG,CAAC,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;SACnF;aAAM,IAAI,EAAE,GAAG,GAAG,EAAE;YACnB,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,GAAG,EAAE,CAAC,CAAC,CAAC;YAC/C,KAAK,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,GAAG,EAAE,CAAC,CAAC,CAAC;YAChD,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,aAAa,GAAG,CAAC,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;SAClF;aAAM,IAAI,EAAE,GAAG,GAAG,EAAE;YACnB,KAAK,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,CAAE,aAAa,GAAG,EAAE,CAAC,CAAC,CAAC;YACjD,KAAK,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,GAAG,EAAE,CAAC,CAAC,CAAC;YAChD,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,aAAa,GAAG,CAAC,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;SAClF;aAAM,IAAI,EAAE,GAAG,EAAE,EAAE;YAClB,KAAK,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,GAAG,EAAE,CAAC,CAAC,CAAC;YAChD,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,GAAG,EAAE,CAAC,CAAC,CAAC;YAC/C,KAAK,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,aAAa,GAAG,CAAC,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;SAClF;aAAM,IAAI,EAAE,IAAI,CAAC,EAAE;YAClB,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,GAAG,EAAE,CAAC,CAAC,CAAC;YAC/C,KAAK,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,aAAa,GAAG,CAAC,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;SAC3E;QACD,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC;IAEO,uBAAuB,CAAC,IAAa;QAC3C,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;YACvC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE;gBAChB,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,YAAY,EAAE;oBACnD,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE;wBACb,IAAI,CAAC,YAAY,UAAU,EAAE;4BAC3B,CAAC,CAAC,OAAO,GAAG,IAAI,CAAC;yBAClB;oBACH,CAAC,CAAC,CAAC;iBACJ;YACH,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,aAAa,CAAC,WAAW,GAAG,IAAI,CAAC;IACxC,CAAC;IAEO,qBAAqB,CAAC,KAAa;QACzC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;YACvC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE;gBAChB,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,YAAY,EAAE;oBACnD,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE;wBACb,IAAI,CAAC,YAAY,UAAU,EAAE;4BAC3B,CAAC,CAAC,KAAK,GAAG,KAAK,CAAC;yBACjB;oBACH,CAAC,CAAC,CAAC;iBACJ;YACH,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,aAAa,CAAC,WAAW,GAAG,IAAI,CAAC;IACxC,CAAC;IAEO,YAAY,CAAC,KAAY,EAAE,mBAA4B,IAAI;QACjE,MAAM,GAAG,GAAW,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QAC/C,IAAI,KAAK,YAAY,SAAS,IAAI,KAAK,YAAY,gBAAgB,EAAE;YACnE,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;SAC/C;QACD,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;QAEvC,IAAI,gBAAgB,EAAE;YACpB,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;SAC5B;IACH,CAAC;IAEO,SAAS,CAAC,KAAY,EAAE,mBAA4B,IAAI;QAC9D,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACpC,IAAI,KAAK,YAAY,SAAS,IAAI,KAAK,YAAY,gBAAgB,EAAE;YACnE,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;YAC3C,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;SACjC;QACD,IAAI,gBAAgB,EAAE;YACpB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;SACzB;IACH,CAAC;IAEO,mBAAmB,CAAC,KAAY;QACtC,MAAM,IAAI,GAAG,IAAI,CAAC,iBAAiB,CAAC,OAAO,EAAE,CAAC;QAE9C,IAAI,IAAI,CAAC,CAAC,KAAK,CAAC,QAAQ,IAAI,IAAI,CAAC,CAAC,KAAK,CAAC,QAAQ,IAAI,IAAI,CAAC,CAAC,KAAK,CAAC,QAAQ;YACtE,IAAI,CAAC,CAAC,KAAK,QAAQ,IAAI,IAAI,CAAC,CAAC,KAAK,QAAQ,IAAI,IAAI,CAAC,CAAC,KAAK,QAAQ,EAAE;YACnE,OAAO;SACR;QAED,MAAM,MAAM,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC;QAClC,MAAM,OAAO,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC;QACnC,MAAM,MAAM,GAAG,IAAI,CAAC,iBAAiB,CAAC,SAAS,EAAE,CAAC;QAElD,IAAI,KAAK,YAAY,SAAS,IAAI,KAAK,YAAY,gBAAgB,EAAE;YACnE,IAAI,KAAK,YAAY,gBAAgB,IAAI,KAAK,CAAC,QAAQ,CAAC,kBAAkB,EAAE;gBAC1E,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;gBAC1C,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC,MAAM,CAAC;gBACnC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,GAAG,MAAM,CAAC;gBACnC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,GAAG,OAAO,CAAC;gBAClC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,OAAO,CAAC;aACvC;YACD,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;SACpC;IACH,CAAC;;2GApMU,aAAa;+GAAb,aAAa,cAFZ,MAAM;4FAEP,aAAa;kBAHzB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\r\nimport {AmbientLight, DirectionalLight, HemisphereLight, Light, PointLight, SpotLight} from 'three';\r\nimport {Subject, Subscription} from 'rxjs';\r\nimport {SceneService} from './scene.service';\r\nimport {ConfigurationService} from '../../../core/service/configuration.service';\r\nimport {FloorplanService} from '../../room-planner/components/floorplanner/service/floorplan.service';\r\nimport {ItemService} from './item.service';\r\nimport {ConfigurationKey} from '../../../core/enum/configuration-key.enum';\r\nimport {LightCreateService} from '../../threedselector/threedselector/service/light-creation.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class LightsService implements OnDestroy {\r\n\r\n  public lights: Light[] = [];\r\n  public onLightAdded: Subject<{light: Light, index: number}> = new Subject<{light: Light, index: number}>();\r\n\r\n  private _subs: Subscription[] = [];\r\n\r\n  constructor (\r\n    private _sceneService: SceneService,\r\n    private _configurationService: ConfigurationService,\r\n    private _floorplanService: FloorplanService,\r\n    private _itemService: ItemService\r\n  ) {}\r\n\r\n  ngOnDestroy(): void {\r\n    this._subs.forEach(s => s.unsubscribe());\r\n  }\r\n\r\n  public init(): void {\r\n    this._subs.push(\r\n      this._floorplanService.roomLoaded.subscribe(() => this.updateAllOffsets()),\r\n      this._floorplanService.roomsUpdated.subscribe(() => this.updateAllOffsets()),\r\n      this._configurationService.onChange.subscribe((changed) => {\r\n        if (ConfigurationKey.ShowInteriorLights in changed) {\r\n          this._showHideInteriorLights(changed[ConfigurationKey.ShowInteriorLights]);\r\n        }\r\n        if (ConfigurationKey.InteriorLightIntensity in changed) {\r\n          this._updateInteriorLights(changed[ConfigurationKey.InteriorLightIntensity]);\r\n        }\r\n      }),\r\n    );\r\n    // this._initLights();\r\n  }\r\n\r\n  public createLight<T extends Light>(modelClass: any): void {\r\n\r\n    const getLights: LightCreateService = new LightCreateService();\r\n    const light: Light = getLights.createNewLight(modelClass);\r\n\r\n    // const light: T = new modelClass();\r\n    light.name = `new_${modelClass.name}`;\r\n    this._addLight(light);\r\n    this.onLightAdded.next({light: light, index: this.lights.length - 1});\r\n  }\r\n\r\n  public addLight(light: Light): void {\r\n    // if (light.rotation) {\r\n    //   this.updateOffsets(light);\r\n    // }\r\n    // this.lights.push(light);\r\n    this._addLight(light);\r\n  }\r\n\r\n  public removeLightByIndex(idx: number, updateLightArray: boolean = true): void {\r\n    this._removeLight(this.lights[idx], updateLightArray);\r\n  }\r\n\r\n  public removeAllLights() {\r\n    const currentLights: Light[] = this.lights.slice();\r\n    // this.lights.length = 0;\r\n    currentLights.forEach(cl => {\r\n      this._removeLight(cl);\r\n    });\r\n  }\r\n\r\n  public replaceLight(idx: number, light: Light): void {\r\n    this.removeLightByIndex(idx, false);\r\n    this._addLight(light, false);\r\n    this.lights[idx] = light;\r\n  }\r\n\r\n  public initiateLightPreset() {\r\n    // this.lights.forEach(l => this._sceneService.addObject(l));\r\n    this.lights.forEach(l => this.updateOffsets(l));\r\n  }\r\n\r\n  public updateAllOffsets(): void {\r\n    this.lights.forEach(l => this.updateOffsets(l));\r\n  }\r\n\r\n  public updateOffsets(light: Light) {\r\n    if (light instanceof AmbientLight || light instanceof HemisphereLight) {\r\n      return;\r\n    }\r\n    const ro = light.userData.rotationOffset;\r\n    const wo = light.userData.wallOffset;\r\n    const fc = this._floorplanService.getCenter();\r\n\r\n    const size = this._floorplanService.getSize();\r\n    const planHalfWidth = isFinite(size.x) ? size.x / 2.0 : 0;\r\n    const planHalfDepth = isFinite(size.z) ? size.z / 2.0 : 0;\r\n\r\n    // Reset position & rotation\r\n    light.position.x = fc.x;\r\n    light.position.z = fc.z;\r\n    light.rotation.set(0, 0, 0);\r\n\r\n    // Offset to the appropriate corner & translate in the opposite direction in equal steps based on the room dimensions.\r\n    if (ro > 315) {\r\n      light.translateZ(Math.abs(planHalfDepth + wo));\r\n      light.translateX(Math.abs(planHalfWidth + wo));\r\n      light.translateX(-Math.abs((((planHalfWidth * 2) + (wo * 2)) / 90) * (ro - 315)));\r\n    } else if (ro > 225) {\r\n      light.translateX(Math.abs(planHalfWidth + wo));\r\n      light.translateZ(-Math.abs(planHalfDepth + wo));\r\n      light.translateZ(Math.abs((((planHalfDepth * 2) + (wo * 2)) / 90) * (ro - 225)));\r\n    } else if (ro > 135) {\r\n      light.translateZ(-Math.abs( planHalfDepth + wo));\r\n      light.translateX(-Math.abs(planHalfWidth + wo));\r\n      light.translateX(Math.abs((((planHalfWidth * 2) + (wo * 2)) / 90) * (ro - 135)));\r\n    } else if (ro > 45) {\r\n      light.translateX(-Math.abs(planHalfWidth + wo));\r\n      light.translateZ(Math.abs(planHalfDepth + wo));\r\n      light.translateZ(-Math.abs((((planHalfDepth * 2) + (wo * 2)) / 90) * (ro - 45)));\r\n    } else if (ro >= 0) {\r\n      light.translateZ(Math.abs(planHalfDepth + wo));\r\n      light.translateX(-Math.abs((((planHalfWidth * 2) + (wo * 2)) / 90) * ro));\r\n    }\r\n    this._updateShadowCamera(light);\r\n  }\r\n\r\n  private _showHideInteriorLights(show: boolean): void {\r\n    this._itemService.items.forEach((item) => {\r\n      item.traverse(c => {\r\n        if (c.name && c.name.toLowerCase() === 'light_bulb') {\r\n          c.traverse(l => {\r\n            if (l instanceof PointLight) {\r\n              l.visible = show;\r\n            }\r\n          });\r\n        }\r\n      });\r\n    });\r\n    this._sceneService.needsRender = true;\r\n  }\r\n\r\n  private _updateInteriorLights(power: number): void {\r\n    this._itemService.items.forEach((item) => {\r\n      item.traverse(c => {\r\n        if (c.name && c.name.toLowerCase() === 'light_bulb') {\r\n          c.traverse(l => {\r\n            if (l instanceof PointLight) {\r\n              l.power = power;\r\n            }\r\n          });\r\n        }\r\n      });\r\n    });\r\n    this._sceneService.needsRender = true;\r\n  }\r\n\r\n  private _removeLight(light: Light, updateLightArray: boolean = true): void {\r\n    const idx: number = this.lights.indexOf(light);\r\n    if (light instanceof SpotLight || light instanceof DirectionalLight) {\r\n      this._sceneService.removeObject(light.target);\r\n    }\r\n    this._sceneService.removeObject(light);\r\n\r\n    if (updateLightArray) {\r\n      this.lights.splice(idx, 1);\r\n    }\r\n  }\r\n\r\n  private _addLight(light: Light, updateLightArray: boolean = true): void {\r\n    this._sceneService.addObject(light);\r\n    if (light instanceof SpotLight || light instanceof DirectionalLight) {\r\n      this._sceneService.addObject(light.target);\r\n      this._updateShadowCamera(light);\r\n    }\r\n    if (updateLightArray) {\r\n      this.lights.push(light);\r\n    }\r\n  }\r\n\r\n  private _updateShadowCamera(light: Light) {\r\n    const size = this._floorplanService.getSize();\r\n\r\n    if (size.x === -Infinity || size.y === -Infinity || size.z === -Infinity ||\r\n      size.x === Infinity || size.y === Infinity || size.z === Infinity) {\r\n      return;\r\n    }\r\n\r\n    const dWidth = (size.x + 3) / 2.0;\r\n    const dHeight = (size.z + 3) / 2.0;\r\n    const center = this._floorplanService.getCenter();\r\n\r\n    if (light instanceof SpotLight || light instanceof DirectionalLight) {\r\n      if (light instanceof DirectionalLight && light.userData.topDownDirectional) {\r\n        light.position.set(center.x, 3, center.z);\r\n        light.shadow.camera.left = -dWidth;\r\n        light.shadow.camera.right = dWidth;\r\n        light.shadow.camera.top = dHeight;\r\n        light.shadow.camera.bottom = -dHeight;\r\n      }\r\n      light.target.position.copy(center);\r\n    }\r\n  }\r\n}\r\n"]}