@colijnit/homedecorator 255.1.1

package/esm2015/app/plugins/core3d/service/message-board.service.js

@@ -0,0 +1,60 @@
+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 { DoubleSide, Mesh, MeshBasicMaterial, PlaneGeometry, Vector3 } from 'three';
+import { makeTextMesh } from '../hud/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../core/service/homedecorator-settings.service";
+import * as i2 from "./font.service";
+export class MessageBoardService {
+    constructor(_settingsService, _fontService) {
+        this._settingsService = _settingsService;
+        this._fontService = _fontService;
+        this.messages = [];
+    }
+    init(scene) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.scene = scene;
+            if (this._settingsService.settings.options.xrDebug) {
+                this._createMessageBoard();
+                // this.font = await this._loadFont();
+            }
+        });
+    }
+    addMessage(message) {
+        if (this._settingsService.settings.options.xrDebug) {
+            const newMessage = makeTextMesh(message, this._fontService.monospaceFont, 0x000000, 6, false);
+            this.messages.push(newMessage);
+            this.board.add(newMessage);
+            newMessage.position.set(5, -this.messages.length * 10, 0);
+        }
+    }
+    _createMessageBoard() {
+        const planeWidth = 200;
+        const planeHeight = 250;
+        const planeGeo = new PlaneGeometry(planeWidth, planeHeight);
+        const planeMaterial = new MeshBasicMaterial({ color: 0x8bb2ff, side: DoubleSide, transparent: true, opacity: 0.5 });
+        this.board = new Mesh(planeGeo, planeMaterial);
+        // this.board.add(new AxesHelper(200));
+        this.board.rotateOnAxis(new Vector3(0, 1, 0), 180 * (Math.PI / 180));
+        this.board.geometry.translate(planeWidth / 2, -planeHeight / 2, 0);
+        this.scene.add(this.board);
+        this.board.position.set(0, 260, 0);
+    }
+}
+MessageBoardService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MessageBoardService, deps: [{ token: i1.HomedecoratorSettingsService }, { token: i2.FontService }], target: i0.ɵɵFactoryTarget.Injectable });
+MessageBoardService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MessageBoardService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MessageBoardService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HomedecoratorSettingsService }, { type: i2.FontService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,146 @@
+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 { Mesh } from 'three';
+import * as Geometry from '../model/geometry';
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { ThreedModel } from '../model/threed-model';
+import { MaterialUtils } from '../../../core/utils/material.utils';
+import { ModelType } from '../../../core/enum/model-type.enum';
+import { isFurnitureType, isInWallType } from '../items/factory';
+import { ConfigurationKey } from '../../../core/enum/configuration-key.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../core/service/utils.service";
+import * as i2 from "../../../core/service/json-utils.service";
+import * as i3 from "../../../core/service/homedecorator-app.service";
+import * as i4 from "../../../core/service/configuration.service";
+// export type ThreeObject = THREE.Object3D | THREE.Mesh | THREE.Group | ThreeGeoMat;
+export class ModelsService {
+    constructor(_utilsService, _jsonUtilsService, _appService, _configurationService) {
+        this._utilsService = _utilsService;
+        this._jsonUtilsService = _jsonUtilsService;
+        this._appService = _appService;
+        this._configurationService = _configurationService;
+        this.customButtons = [];
+        this.modelsLoaded = new BehaviorSubject(false);
+        this._modelsLoadedSub = this._appService.modelsLoaded.subscribe((models) => {
+            if (models) {
+                this.models = models;
+                this.modelsLoaded.next(true);
+            }
+        });
+        window.onbeforeunload = () => this.ngOnDestroy();
+    }
+    ngOnDestroy() {
+        this._modelsLoadedSub.unsubscribe();
+        this.customButtons.length = 0;
+        this.models.length = 0;
+    }
+    _load(model) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (model.texture) {
+                return {
+                    geometry: Geometry.wallBox(model.width, model.height, this._getInWallItemThickness()),
+                    materials: [
+                        MaterialUtils.defaultWindow,
+                        MaterialUtils.defaultWindow,
+                        MaterialUtils.defaultWindow,
+                        MaterialUtils.defaultWindow,
+                        MaterialUtils.defaultWindow,
+                        MaterialUtils.defaultWindow
+                    ]
+                };
+            }
+            // if (model.isLoaded) {
+            //   return model.object;
+            // }
+            switch (model.modelType) {
+                case ModelType.JSON:
+                    const geoMat = yield this._utilsService.loadJsonModel(model.url);
+                    return new Mesh(geoMat.geometry, geoMat.materials);
+                case ModelType.JSON_OBJECT:
+                    return yield this._utilsService.loadJsonObjectModel(model.url);
+                case ModelType.OBJ:
+                    return yield this._utilsService.loadObjModel(model.url, model.mtlUrl);
+                case ModelType.GLB:
+                    return yield this._utilsService.loadGlbModel(model.url);
+                default:
+                    return new Mesh(Geometry.wallBox(model.width, model.height, this._getInWallItemThickness()), []);
+            }
+        });
+    }
+    getModel(name) {
+        // await this.initialize();
+        const models = this.models ? this.models.filter((model) => model.name === name) : undefined;
+        if (models && models.length) {
+            const returnModel = new ThreedModel();
+            Object.assign(returnModel, models[0]);
+            return returnModel;
+        }
+        else {
+            console.error(`Error retrieving ${name} model`);
+            return null;
+        }
+    }
+    hasModel(name) {
+        return !!this.getModel(name);
+    }
+    get(name, overrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const model = this.getModel(name);
+            if (!model) {
+                return null;
+            }
+            if (overrides) {
+                model.object = yield this._load(Object.assign(Object.assign({}, model), overrides)).catch(() => model.object = null);
+                model.isLoaded = true;
+                return Object.assign(Object.assign({}, model), overrides);
+            }
+            else if (!model.isLoaded) {
+                model.object = yield this._load(model).catch(() => model.object = null);
+                model.isLoaded = true;
+            }
+            return model;
+        });
+    }
+    getFurnitures() {
+        // await this.initialize();
+        return this.models ? this.models.filter((model) => isFurnitureType(model.type)) : [];
+    }
+    getItemsFromCategory(category) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!category) {
+                return yield this.getFurnitures();
+            }
+            return this.models ? this.models.filter((model) => (model.category === category && model.show)) : [];
+        });
+    }
+    getInWalls() {
+        // await this.initialize();
+        return this.models ? this.models.filter((model) => isInWallType(model.type)) : [];
+    }
+    addCustomButton(button) {
+        if (this.customButtons.indexOf(button) === -1) {
+            this.customButtons.push(button);
+        }
+    }
+    _getInWallItemThickness() {
+        return (this._configurationService.getValue(ConfigurationKey.WallThickness) / 100) - 0.01;
+    }
+}
+ModelsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ModelsService, deps: [{ token: i1.UtilsService }, { token: i2.JsonUtilsService }, { token: i3.HomedecoratorAppService }, { token: i4.ConfigurationService }], target: i0.ɵɵFactoryTarget.Injectable });
+ModelsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ModelsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ModelsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.UtilsService }, { type: i2.JsonUtilsService }, { type: i3.HomedecoratorAppService }, { type: i4.ConfigurationService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"models.service.js","sourceRoot":"","sources":["../../../../../../../src/client/app/plugins/core3d/service/models.service.ts"],"names":[],"mappings":"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","sourcesContent":["import * as THREE from 'three';\r\nimport {Mesh} from 'three';\r\nimport * as Geometry from '../model/geometry';\r\nimport {Injectable, OnDestroy} from '@angular/core';\r\nimport {BehaviorSubject, Subscription} from 'rxjs';\r\nimport {CustomButton} from '../../../core/model/custom-button';\r\nimport {JsonUtilsService} from '../../../core/service/json-utils.service';\r\nimport {ThreedModel} from '../model/threed-model';\r\nimport {UtilsService} from '../../../core/service/utils.service';\r\nimport {HomedecoratorAppService} from '../../../core/service/homedecorator-app.service';\r\nimport {ConfigurationService} from '../../../core/service/configuration.service';\r\nimport {MaterialUtils} from '../../../core/utils/material.utils';\r\nimport {ModelType} from '../../../core/enum/model-type.enum';\r\nimport {isFurnitureType, isInWallType} from '../items/factory';\r\nimport {ConfigurationKey} from '../../../core/enum/configuration-key.enum';\r\nimport {ThreeObject} from '../../../core/model/three-object';\r\n\r\nexport interface ThreeGeoMat {\r\n  geometry: THREE.BufferGeometry;\r\n  materials: THREE.Material[];\r\n}\r\n\r\n// export type ThreeObject = THREE.Object3D | THREE.Mesh | THREE.Group | ThreeGeoMat;\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class ModelsService implements OnDestroy {\r\n\r\n  public customButtons: CustomButton[] = [];\r\n\r\n  public models: ThreedModel[];\r\n\r\n  public modelsLoaded: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);\r\n\r\n  private _modelsLoadedSub: Subscription;\r\n\r\n  constructor(\r\n    private _utilsService: UtilsService,\r\n    private _jsonUtilsService: JsonUtilsService,\r\n    private _appService: HomedecoratorAppService,\r\n    private _configurationService: ConfigurationService\r\n  ) {\r\n    this._modelsLoadedSub = this._appService.modelsLoaded.subscribe((models: ThreedModel[]) => {\r\n      if (models) {\r\n        this.models = models;\r\n        this.modelsLoaded.next(true);\r\n      }\r\n    });\r\n    window.onbeforeunload = () => this.ngOnDestroy();\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this._modelsLoadedSub.unsubscribe();\r\n    this.customButtons.length = 0;\r\n    this.models.length = 0;\r\n  }\r\n\r\n  private async _load(model: ThreedModel): Promise<ThreeObject> {\r\n    if (model.texture) {\r\n      return {\r\n        geometry: Geometry.wallBox(model.width, model.height, this._getInWallItemThickness()),\r\n        materials: [\r\n          MaterialUtils.defaultWindow,\r\n          MaterialUtils.defaultWindow,\r\n          MaterialUtils.defaultWindow,\r\n          MaterialUtils.defaultWindow,\r\n          MaterialUtils.defaultWindow,\r\n          MaterialUtils.defaultWindow\r\n        ]\r\n      };\r\n    }\r\n    // if (model.isLoaded) {\r\n    //   return model.object;\r\n    // }\r\n    switch (model.modelType) {\r\n      case ModelType.JSON:\r\n        const geoMat = await this._utilsService.loadJsonModel(model.url);\r\n        return new Mesh(geoMat.geometry, geoMat.materials);\r\n      case ModelType.JSON_OBJECT:\r\n        return await this._utilsService.loadJsonObjectModel(model.url);\r\n      case ModelType.OBJ:\r\n        return await this._utilsService.loadObjModel(model.url, model.mtlUrl);\r\n      case ModelType.GLB:\r\n        return await this._utilsService.loadGlbModel(model.url);\r\n      default:\r\n        return new Mesh(Geometry.wallBox(model.width, model.height, this._getInWallItemThickness()), []);\r\n    }\r\n  }\r\n\r\n  private getModel(name: string): ThreedModel {\r\n    // await this.initialize();\r\n    const models = this.models ? this.models.filter((model: ThreedModel) => model.name === name) : undefined;\r\n    if (models && models.length) {\r\n      const returnModel = new ThreedModel();\r\n      Object.assign(returnModel, models[0]);\r\n      return returnModel;\r\n    } else {\r\n      console.error(`Error retrieving ${name} model`);\r\n      return null;\r\n    }\r\n  }\r\n\r\n  public hasModel(name: string): boolean {\r\n    return !!this.getModel(name);\r\n  }\r\n\r\n  public async get(name: string, overrides?: any): Promise<ThreedModel> {\r\n    const model = this.getModel(name);\r\n    if (!model) {\r\n      return null;\r\n    }\r\n    if (overrides) {\r\n      model.object = await this._load({...model, ...overrides}).catch(() => model.object = null);\r\n      model.isLoaded = true;\r\n      return { ...model, ...overrides };\r\n    } else if (!model.isLoaded) {\r\n      model.object = await this._load(model).catch(() => model.object = null);\r\n      model.isLoaded = true;\r\n    }\r\n    return model;\r\n  }\r\n\r\n  public getFurnitures(): ThreedModel[] {\r\n    // await this.initialize();\r\n    return this.models ? this.models.filter((model: ThreedModel) =>\r\n      isFurnitureType(model.type)) : [];\r\n  }\r\n\r\n  public async getItemsFromCategory(category: string): Promise<ThreedModel[]> {\r\n    if (!category) {\r\n      return await this.getFurnitures();\r\n    }\r\n    return this.models ? this.models.filter((model: ThreedModel) =>\r\n      (model.category === category && model.show)) : [];\r\n  }\r\n\r\n  public getInWalls(): ThreedModel[] {\r\n    // await this.initialize();\r\n    return this.models ? this.models.filter((model: ThreedModel) =>\r\n      isInWallType(model.type)) : [];\r\n  }\r\n\r\n  public addCustomButton(button: CustomButton): void {\r\n    if (this.customButtons.indexOf(button) === -1) {\r\n      this.customButtons.push(button);\r\n    }\r\n  }\r\n\r\n  private _getInWallItemThickness(): number {\r\n    return (this._configurationService.getValue(ConfigurationKey.WallThickness) / 100) - 0.01;\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,150 @@
+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 { NearestFilter, RGBAFormat, SRGBColorSpace, Vector2, WebGLRenderTarget } from 'three';
+import { OutlinePass } from 'three/examples/jsm/postprocessing/OutlinePass';
+import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer';
+import { RenderPass } from 'three/examples/jsm/postprocessing/RenderPass';
+import * as TWEEN from '@tweenjs/tween.js';
+import { ShaderPass } from 'three/examples/jsm/postprocessing/ShaderPass';
+import { FXAAShader } from 'three/examples/jsm/shaders/FXAAShader';
+import { GammaCorrectionShader } from 'three/examples/jsm/shaders/GammaCorrectionShader';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../core/service/homedecorator-app-event.service";
+export class OutlineService {
+    constructor(_appEventService) {
+        this._appEventService = _appEventService;
+        this._enabled = true;
+        this._hideOutlineTimeout = 10000;
+        this._animationDuration = 5000;
+        this._outlinePassAsError = false;
+        this._useMSAA = false;
+        this._initializing = false;
+        this._subs = [];
+        this.needsRender = false;
+        this._subs.push(this._appEventService.showOutline.subscribe((object) => this.showOutline(object)), this._appEventService.hideOutline.subscribe(() => this.hideOutline()));
+    }
+    ngOnDestroy() {
+        this._subs.forEach(s => s.unsubscribe());
+    }
+    init(renderer, scene, camera, width, height) {
+        this._renderer = renderer;
+        this._scene = scene;
+        this._camera = camera;
+        this._renderTarget = new WebGLRenderTarget(width, height, {
+            minFilter: NearestFilter,
+            magFilter: NearestFilter,
+            format: RGBAFormat,
+            colorSpace: SRGBColorSpace
+        });
+        this._renderTarget.samples = 4;
+        this._composer = new EffectComposer(this._renderer, this._renderTarget);
+        this._composer.setPixelRatio(window.devicePixelRatio);
+        const renderPass = new RenderPass(this._scene, this._camera);
+        this._composer.addPass(renderPass);
+        this._outlinePass = new OutlinePass(new Vector2(width, height), this._scene, this._camera);
+        this._composer.addPass(this._outlinePass);
+        this._fxaaPass = new ShaderPass(FXAAShader);
+        this._fxaaPass.material.uniforms['resolution'].value.set(1 / width, 1 / height);
+        this._composer.addPass(this._fxaaPass);
+        // needed for the sRGBEncoding to work
+        // https://stackoverflow.com/questions/72936071/srgbencoding-in-not-working-in-three-effectcomposer
+        const gammaCorrectionPass = new ShaderPass(GammaCorrectionShader);
+        this._composer.addPass(gammaCorrectionPass);
+        this._setSelectionGlowSettings();
+        this._composer.setSize(width, height);
+    }
+    setSize(width, height) {
+        this._renderTarget.setSize(width, height);
+        this._composer.setSize(width, height);
+    }
+    render() {
+        this._composer.render();
+    }
+    forceRenderCanvas() {
+        this.render();
+    }
+    showErrorOutline(item) {
+        if (!this._outlinePassAsError) {
+            this._setErrorGlowSettings();
+            this._outlinePassAsError = true;
+        }
+        this._outlinePass.selectedObjects = [item];
+    }
+    showOutline(item) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // if (item && (item instanceof FloorPin || item instanceof WallPin)) {
+            //   return;
+            // }
+            clearTimeout(this._hideOutlineTimer);
+            if (this._outlinePassAsError) {
+                this._setSelectionGlowSettings();
+                this._outlinePassAsError = false;
+            }
+            this._outlinePass.selectedObjects = [item];
+            // await this._animatedOutlineStrength(0, 300);
+            // remove after x amount of ms
+            this._hideOutlineTimer = setTimeout(() => {
+                this.hideOutline();
+            }, this._hideOutlineTimeout);
+            this.needsRender = true;
+        });
+    }
+    hideOutline() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._outlinePass.selectedObjects.length > 0) {
+                // await this._animatedOutlineStrength(300, 0);
+                this._outlinePass.selectedObjects = [];
+                this.needsRender = true;
+            }
+        });
+    }
+    _animatedOutlineStrength(from, to) {
+        return new Promise((resolve) => {
+            const strength = from;
+            new TWEEN.Tween(strength)
+                .to(to, this._animationDuration)
+                .easing(TWEEN.Easing.Circular.In)
+                .onUpdate(() => {
+                this._outlinePass.edgeStrength = strength;
+                this.needsRender = true;
+            })
+                .onComplete(() => {
+                resolve();
+            })
+                .start();
+        });
+    }
+    _setErrorGlowSettings() {
+        this._outlinePass.visibleEdgeColor.set('#e60002');
+        this._outlinePass.hiddenEdgeColor.set('#e60002');
+        this._outlinePass.edgeStrength = 4;
+        this._outlinePass.edgeGlow = 1;
+        this._outlinePass.edgeThickness = 1;
+        this._outlinePass.pulsePeriod = 1.5;
+    }
+    _setSelectionGlowSettings() {
+        this._outlinePass.visibleEdgeColor.set('#ffffff');
+        this._outlinePass.hiddenEdgeColor.set('#ffffff');
+        this._outlinePass.edgeStrength = 2;
+        this._outlinePass.edgeGlow = 0.5;
+        this._outlinePass.edgeThickness = 1.5;
+        this._outlinePass.pulsePeriod = 0;
+    }
+}
+OutlineService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: OutlineService, deps: [{ token: i1.HomedecoratorAppEventService }], target: i0.ɵɵFactoryTarget.Injectable });
+OutlineService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: OutlineService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: OutlineService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HomedecoratorAppEventService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"outline.service.js","sourceRoot":"","sources":["../../../../../../../src/client/app/plugins/core3d/service/outline.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\r\nimport {NearestFilter, PerspectiveCamera, RGBAFormat, Scene, SRGBColorSpace, Vector2, WebGLRenderer, WebGLRenderTarget} from 'three';\r\nimport {OutlinePass} from 'three/examples/jsm/postprocessing/OutlinePass';\r\nimport {EffectComposer} from 'three/examples/jsm/postprocessing/EffectComposer';\r\nimport {RenderPass} from 'three/examples/jsm/postprocessing/RenderPass';\r\nimport * as TWEEN from '@tweenjs/tween.js';\r\nimport {Item} from '../items/item';\r\nimport {TexturePass} from 'three/examples/jsm/postprocessing/TexturePass';\r\nimport {ShaderPass} from 'three/examples/jsm/postprocessing/ShaderPass';\r\nimport {FXAAShader} from 'three/examples/jsm/shaders/FXAAShader';\r\nimport {GammaCorrectionShader} from 'three/examples/jsm/shaders/GammaCorrectionShader';\r\nimport {HomedecoratorAppEventService} from '../../../core/service/homedecorator-app-event.service';\r\nimport {Subscription} from 'rxjs';\r\nimport {Furniture} from '../items/furniture';\r\nimport {CustomObject3D} from '../items/custom-objects';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class OutlineService implements OnDestroy {\r\n\r\n  private _outlinePass: OutlinePass;\r\n  private _texturePass: TexturePass;\r\n  private _fxaaPass: ShaderPass;\r\n  private _composer: EffectComposer;\r\n  private _enabled: boolean = true;\r\n  private _hideOutlineTimer: any;\r\n  private _hideOutlineTimeout: number = 10000;\r\n  private _animationDuration: number = 5000;\r\n  private _outlinePassAsError: boolean = false;\r\n  private _useMSAA: boolean = false;\r\n  private _renderTarget: WebGLRenderTarget;\r\n  private _initializing: boolean = false;\r\n  private _scene: Scene;\r\n  private _renderer: WebGLRenderer;\r\n  private _camera: PerspectiveCamera;\r\n  private _subs: Subscription[] = [];\r\n\r\n  public needsRender: boolean = false;\r\n\r\n  constructor(\r\n      private _appEventService: HomedecoratorAppEventService\r\n  ) {\r\n    this._subs.push(\r\n        this._appEventService.showOutline.subscribe((object: Item) => this.showOutline(object)),\r\n        this._appEventService.hideOutline.subscribe(() => this.hideOutline()),\r\n    )\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this._subs.forEach(s => s.unsubscribe());\r\n  }\r\n\r\n  public init(renderer: WebGLRenderer, scene: Scene, camera: PerspectiveCamera, width: number, height: number): void {\r\n    this._renderer = renderer;\r\n    this._scene = scene;\r\n    this._camera = camera;\r\n\r\n    this._renderTarget = new WebGLRenderTarget(width, height, {\r\n      minFilter: NearestFilter,\r\n      magFilter: NearestFilter,\r\n      format: RGBAFormat,\r\n      colorSpace: SRGBColorSpace\r\n    });\r\n    this._renderTarget.samples = 4;\r\n\r\n    this._composer = new EffectComposer(this._renderer, this._renderTarget);\r\n    this._composer.setPixelRatio(window.devicePixelRatio);\r\n\r\n    const renderPass = new RenderPass(this._scene, this._camera);\r\n    this._composer.addPass(renderPass);\r\n\r\n    this._outlinePass = new OutlinePass(new Vector2(width, height), this._scene, this._camera);\r\n    this._composer.addPass(this._outlinePass);\r\n\r\n    this._fxaaPass = new ShaderPass(FXAAShader);\r\n    this._fxaaPass.material.uniforms['resolution'].value.set(1 / width, 1 / height);\r\n    this._composer.addPass(this._fxaaPass);\r\n\r\n    // needed for the sRGBEncoding to work\r\n    // https://stackoverflow.com/questions/72936071/srgbencoding-in-not-working-in-three-effectcomposer\r\n    const gammaCorrectionPass = new ShaderPass(GammaCorrectionShader);\r\n    this._composer.addPass(gammaCorrectionPass);\r\n\r\n    this._setSelectionGlowSettings();\r\n    this._composer.setSize(width, height);\r\n  }\r\n\r\n  public setSize(width: number, height: number): void {\r\n    this._renderTarget.setSize(width, height);\r\n    this._composer.setSize(width, height);\r\n  }\r\n\r\n  public render(): void {\r\n    this._composer.render();\r\n  }\r\n\r\n  public forceRenderCanvas(): void {\r\n    this.render();\r\n  }\r\n\r\n  public showErrorOutline(item: Furniture): void {\r\n    if (!this._outlinePassAsError) {\r\n      this._setErrorGlowSettings();\r\n      this._outlinePassAsError = true;\r\n    }\r\n    this._outlinePass.selectedObjects = [item];\r\n  }\r\n\r\n  public async showOutline(item: Furniture | CustomObject3D): Promise<void> {\r\n    // if (item && (item instanceof FloorPin || item instanceof WallPin)) {\r\n    //   return;\r\n    // }\r\n    clearTimeout(this._hideOutlineTimer);\r\n    if (this._outlinePassAsError) {\r\n      this._setSelectionGlowSettings();\r\n      this._outlinePassAsError = false;\r\n    }\r\n    this._outlinePass.selectedObjects = [item];\r\n    // await this._animatedOutlineStrength(0, 300);\r\n    // remove after x amount of ms\r\n    this._hideOutlineTimer = setTimeout(() => {\r\n      this.hideOutline();\r\n    }, this._hideOutlineTimeout);\r\n    this.needsRender = true;\r\n  }\r\n\r\n  public async hideOutline(): Promise<void> {\r\n    if (this._outlinePass.selectedObjects.length > 0) {\r\n      // await this._animatedOutlineStrength(300, 0);\r\n      this._outlinePass.selectedObjects = [];\r\n      this.needsRender = true;\r\n    }\r\n  }\r\n\r\n  private _animatedOutlineStrength(from: number, to: number): Promise<void> {\r\n    return new Promise((resolve: Function) => {\r\n      const strength: number = from;\r\n      new TWEEN.Tween(strength)\r\n        .to(to, this._animationDuration)\r\n        .easing(TWEEN.Easing.Circular.In)\r\n        .onUpdate(() => {\r\n          this._outlinePass.edgeStrength = strength;\r\n          this.needsRender = true;\r\n        })\r\n        .onComplete(() => {\r\n          resolve();\r\n        })\r\n        .start();\r\n    });\r\n  }\r\n\r\n  private _setErrorGlowSettings(): void {\r\n    this._outlinePass.visibleEdgeColor.set('#e60002');\r\n    this._outlinePass.hiddenEdgeColor.set('#e60002');\r\n    this._outlinePass.edgeStrength = 4;\r\n    this._outlinePass.edgeGlow = 1;\r\n    this._outlinePass.edgeThickness = 1;\r\n    this._outlinePass.pulsePeriod = 1.5;\r\n  }\r\n\r\n  private _setSelectionGlowSettings(): void {\r\n    this._outlinePass.visibleEdgeColor.set('#ffffff');\r\n    this._outlinePass.hiddenEdgeColor.set('#ffffff');\r\n    this._outlinePass.edgeStrength = 2;\r\n    this._outlinePass.edgeGlow = 0.5;\r\n    this._outlinePass.edgeThickness = 1.5;\r\n    this._outlinePass.pulsePeriod = 0;\r\n  }\r\n}\r\n"]}