@colijnit/homedecorator 255.1.1

package/esm2015/app/plugins/core3d/service/scene-options.service.js

@@ -0,0 +1,24 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class SceneOptionsService {
+    constructor() {
+        this.sceneOptionButtonAdded = new BehaviorSubject(undefined);
+        this.sceneOptionButtonUpdated = new Subject();
+    }
+    addSceneOptionButton(button) {
+        this.sceneOptionButtonAdded.next(button);
+    }
+    updateSceneOptionButton(button) {
+        this.sceneOptionButtonUpdated.next(button);
+    }
+}
+SceneOptionsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SceneOptionsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+SceneOptionsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SceneOptionsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SceneOptionsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NlbmUtb3B0aW9ucy5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2NsaWVudC9hcHAvcGx1Z2lucy9jb3JlM2Qvc2VydmljZS9zY2VuZS1vcHRpb25zLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFVBQVUsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUMsZUFBZSxFQUFFLE9BQU8sRUFBQyxNQUFNLE1BQU0sQ0FBQzs7QUFNOUMsTUFBTSxPQUFPLG1CQUFtQjtJQUhoQztRQUtTLDJCQUFzQixHQUFnRCxJQUFJLGVBQWUsQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUNyRyw2QkFBd0IsR0FBd0MsSUFBSSxPQUFPLEVBQUUsQ0FBQztLQVV0RjtJQVJRLG9CQUFvQixDQUFDLE1BQWtDO1FBQzVELElBQUksQ0FBQyxzQkFBc0IsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDM0MsQ0FBQztJQUVNLHVCQUF1QixDQUFDLE1BQWtDO1FBQy9ELElBQUksQ0FBQyx3QkFBd0IsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDN0MsQ0FBQzs7aUhBWFUsbUJBQW1CO3FIQUFuQixtQkFBbUIsY0FGbEIsTUFBTTs0RkFFUCxtQkFBbUI7a0JBSC9CLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtJbmplY3RhYmxlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHtCZWhhdmlvclN1YmplY3QsIFN1YmplY3R9IGZyb20gJ3J4anMnO1xyXG5pbXBvcnQge1NjZW5lT3B0aW9uQnV0dG9uSW50ZXJmYWNlfSBmcm9tICcuLi9pbnRlcmZhY2Uvc2NlbmUtb3B0aW9uLWJ1dHRvbi5pbnRlcmZhY2UnO1xyXG5cclxuQEluamVjdGFibGUoe1xyXG4gIHByb3ZpZGVkSW46ICdyb290J1xyXG59KVxyXG5leHBvcnQgY2xhc3MgU2NlbmVPcHRpb25zU2VydmljZSB7XHJcblxyXG4gIHB1YmxpYyBzY2VuZU9wdGlvbkJ1dHRvbkFkZGVkOiBCZWhhdmlvclN1YmplY3Q8U2NlbmVPcHRpb25CdXR0b25JbnRlcmZhY2U+ID0gbmV3IEJlaGF2aW9yU3ViamVjdCh1bmRlZmluZWQpO1xyXG4gIHB1YmxpYyBzY2VuZU9wdGlvbkJ1dHRvblVwZGF0ZWQ6IFN1YmplY3Q8U2NlbmVPcHRpb25CdXR0b25JbnRlcmZhY2U+ID0gbmV3IFN1YmplY3QoKTtcclxuXHJcbiAgcHVibGljIGFkZFNjZW5lT3B0aW9uQnV0dG9uKGJ1dHRvbjogU2NlbmVPcHRpb25CdXR0b25JbnRlcmZhY2UpOiB2b2lkIHtcclxuICAgIHRoaXMuc2NlbmVPcHRpb25CdXR0b25BZGRlZC5uZXh0KGJ1dHRvbik7XHJcbiAgfVxyXG5cclxuICBwdWJsaWMgdXBkYXRlU2NlbmVPcHRpb25CdXR0b24oYnV0dG9uOiBTY2VuZU9wdGlvbkJ1dHRvbkludGVyZmFjZSk6IHZvaWQge1xyXG4gICAgdGhpcy5zY2VuZU9wdGlvbkJ1dHRvblVwZGF0ZWQubmV4dChidXR0b24pO1xyXG4gIH1cclxuXHJcbn1cclxuIl19

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

@@ -0,0 +1,351 @@
+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 { Color, PCFSoftShadowMap, PerspectiveCamera, Scene, SRGBColorSpace, TextureLoader, WebGLRenderer } from 'three';
+import { BehaviorSubject, Subject } from 'rxjs';
+import * as TWEEN from '@tweenjs/tween.js';
+import { ACESFilmicToneMapping } from 'three/src/constants';
+import { ViewMode } from '../../../core/enum/view-mode.enum';
+import { MessageType } from '../../../core/enum/message-type.enum';
+import { FileUtils } from '../../../core/utils/file.utils';
+import { Utils } from '../core/utils';
+import { Scene3DUtil } from '../../threedselector/threedselector/utils/scene-3d.utils';
+import { RelativePositionUtils } from '../../../core/utils/relative-position.utils';
+// import WebGPU from 'three/examples/jsm/capabilities/WebGPU';
+// import WebGL from 'three/examples/jsm/capabilities/WebGL';
+// import WebGPURenderer from 'three/examples/jsm/renderers/webgpu/WebGPURenderer';
+import { WebGLPathTracer } from 'three-gpu-pathtracer';
+import { ParallelMeshBVHWorker } from 'three-mesh-bvh/src/workers/ParallelMeshBVHWorker.js';
+import * as i0 from "@angular/core";
+import * as i1 from "./camera.service";
+import * as i2 from "../../../core/service/configuration.service";
+import * as i3 from "./xr.service";
+import * as i4 from "./vr.service";
+import * as i5 from "./ar.service";
+import * as i6 from "../../../core/service/message-bus.service";
+import * as i7 from "../../../core/service/view-mode.service";
+import * as i8 from "./outline.service";
+import * as i9 from "../../../core/service/homedecorator-settings.service";
+export class SceneService {
+    constructor(_cameraService, _configurationService, _xrService, _vrService, _arService, _messageBusService, _viewModeService, _outlineService, _settingsService) {
+        this._cameraService = _cameraService;
+        this._configurationService = _configurationService;
+        this._xrService = _xrService;
+        this._vrService = _vrService;
+        this._arService = _arService;
+        this._messageBusService = _messageBusService;
+        this._viewModeService = _viewModeService;
+        this._outlineService = _outlineService;
+        this._settingsService = _settingsService;
+        this.onBeforeRender = new Subject();
+        this.onAfterRender = new Subject();
+        this.sceneInitialized = new BehaviorSubject(false);
+        this.renderingThroughPostProcessingPipeline = true;
+        this._arMode = false;
+        this._subs = [];
+        window.onbeforeunload = () => this.ngOnDestroy();
+    }
+    set needsRender(value) {
+        this._needsRender = value;
+        if (this.pathTracer) {
+            this.pathTracer.updateCamera();
+            this.pathTracer.updateLights();
+            this.pathTracer.updateMaterials();
+            this.pathTracer.updateEnvironment();
+        }
+        this._numberOfSamplesRendered = 0;
+    }
+    get needsRender() {
+        return this._needsRender;
+    }
+    ngOnDestroy() {
+        this.domElement = undefined;
+        this._subs.forEach(s => s.unsubscribe());
+    }
+    getScene() {
+        return this.arMode ? this._arService.scene : this.scene;
+    }
+    set arMode(value) {
+        this._arMode = value;
+        if (this._arMode) {
+            this._arService.init(this.renderer);
+            this._viewModeService.viewMode = ViewMode.AR;
+        }
+    }
+    get arMode() {
+        return this._arMode;
+    }
+    init(element) {
+        this.domElement = element;
+        this._initScene();
+        this._initRenderer();
+        this._initCamera();
+        this._initOutline();
+        this._animate();
+        this._subs.push(this._cameraService.cameraMovementChanged.subscribe(() => {
+            this.needsRender = true;
+        }), this._messageBusService.subscribe(MessageType.TakeScreenshot, () => __awaiter(this, void 0, void 0, function* () {
+            if (this._viewModeService.is3dViewActive() || this._viewModeService.isTopViewActive()) {
+                this.renderer.render(this.scene, this._cameraService.camera);
+                const dataUrl = this.renderer.domElement.toDataURL('image/jpeg');
+                FileUtils.DownloadFromDataUri(dataUrl, `MyRoomplan${new Date().toISOString()}.jpeg`);
+            }
+        })), this._arService.shouldAddObjectToScene.subscribe((object) => {
+            this.arMode = false;
+            this.addObject(object);
+        }), this._viewModeService.viewModeChanged.subscribe((mode) => {
+            // if (this._is3DMode(mode)) {
+            //   this._animate();
+            // } else {
+            //   this._pauseAnimation();
+            // }
+            if (mode === ViewMode.VR) {
+                this._vrService.init(this.scene, this.renderer);
+            }
+            else {
+                this._vrService.endSession();
+            }
+        }), this._settingsService.settingsLoaded.subscribe((loaded) => {
+            if (loaded) {
+                this._initPathTracer();
+                this._maxRenderSamples = this._settingsService.settings.options.maxRenderSamples;
+            }
+        })
+        // this._xrService.sessionStarted.subscribe((mode: XrMode) => {
+        //   if (mode === XrMode.ArMode) {
+        //     this._animateAr();
+        //   }
+        // })
+        );
+        this._xrService.init(this.renderer, this.scene, this._cameraService.camera);
+        this.sceneInitialized.next(true);
+    }
+    addObject(obj, forceRender = true) {
+        if (this._arMode) {
+            this._arService.addObjectToARScene(obj);
+        }
+        else {
+            this.scene.add(obj);
+            this.updatePathTracer();
+        }
+        if (forceRender) {
+            this.needsRender = true;
+        }
+    }
+    removeObject(obj, forceRender = true, cleanUp = true) {
+        this.scene.remove(obj);
+        if (forceRender) {
+            this.needsRender = true;
+        }
+        if (cleanUp) {
+            Utils.DisposeObject(obj);
+        }
+    }
+    updatePathTracer() {
+        if (this._settingsService.settings.options.pathTracer && this.pathTracer) {
+            try {
+                this.pathTracer.setScene(this.scene, this._cameraService.camera);
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
+    }
+    positionInSceneToScreen(pos) {
+        return Scene3DUtil.Convert3DPointToScreenPoint(pos, this._cameraService.camera, this.domElement.clientWidth, this.domElement.clientHeight);
+    }
+    rendererPropsChange() {
+        this.scene.traverse((node) => {
+            if (!node.isMesh) {
+                return;
+            }
+            if (Array.isArray(node.material)) {
+                node.material.forEach(function (material) {
+                    material.needsUpdate = true;
+                });
+            }
+            else {
+                node.material.needsUpdate = true;
+            }
+        });
+        this.needsRender = true;
+    }
+    _initScene() {
+        this.scene = new Scene();
+        this._setSceneBackground();
+        // const box1geo = new BoxGeometry(1, 1, 1);
+        // const box1 = new Mesh(box1geo, new MeshPhongMaterial({color: 'green'}));
+        // box1.position.set(-0.5, 0.7, -0.5);
+        // box1.castShadow = true;
+        // box1.receiveShadow = true;
+        // this.scene.add(box1);
+        // const box2geo = new BoxGeometry(0.6, 0.6, 0.6);
+        // const box2 = new Mesh(box2geo, new MeshPhongMaterial({color: 'red'}));
+        // box2.position.set(0.5, 1.5, 0.5);
+        // box2.castShadow = true;
+        // box2.receiveShadow = true;
+        // this.scene.add(box2);
+    }
+    _initCamera() {
+        this._cameraService.init(this.domElement);
+    }
+    _initOutline() {
+        this._outlineService.init(this.renderer, this.scene, this._cameraService.camera, this.domElement.clientWidth * window.devicePixelRatio, this.domElement.clientHeight * window.devicePixelRatio);
+    }
+    _initPathTracer() {
+        if (this._settingsService.settings.options.pathTracer) {
+            this.pathTracer = new WebGLPathTracer(this.renderer);
+            this.pathTracer.setBVHWorker(new ParallelMeshBVHWorker());
+            this.pathTracer.filterGlossyFactor = 1;
+            this.pathTracer.tiles.set(3, 3);
+            this.pathTracer.multipleImportanceSampling = true;
+            this.pathTracer.transmissiveBounces = 10;
+            this.pathTracer.renderScale = 1;
+            this.pathTracer.setScene(this.scene, this._cameraService.camera);
+            this.pathTracer.enablePathTracing = true;
+        }
+    }
+    _initRenderer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // if (WebGPU.isAvailable() === false && WebGL.isWebGL2Available() === false) {
+            //   document.body.appendChild( WebGPU.getErrorMessage() );
+            //   throw new Error('No WebGPU or WebGL2 support');
+            // }
+            const canvasElement = document.createElement('canvas');
+            const context = canvasElement.getContext('webgl2', { antialias: true });
+            this.webGL2Available = context !== undefined;
+            // this.renderer = new WebGPURenderer({ alpha: true, antialias: true });
+            // this.renderer =
+            //   new WebGLRenderer({
+            //     canvas: canvasElement,
+            //     context: context,
+            //     alpha: true,
+            //     antialias: true,
+            //     preserveDrawingBuffer: true,
+            //     premultipliedAlpha: false/*,
+            //     logarithmicDepthBuffer: true*/
+            //   });
+            this.renderer = new WebGLRenderer({ alpha: true, antialias: true, preserveDrawingBuffer: true, premultipliedAlpha: false });
+            this.renderer.autoClear = false;
+            this.renderer.setPixelRatio(window.devicePixelRatio);
+            this.renderer.toneMapping = ACESFilmicToneMapping; // LinearToneMapping;
+            this.renderer.shadowMap.enabled = true;
+            this.renderer.shadowMap.type = PCFSoftShadowMap;
+            this.domElement.appendChild(this.renderer.domElement);
+            this.renderer.domElement.setAttribute('id', 'threed_canvas');
+        });
+    }
+    _resizeRendererToDisplaySize() {
+        this.renderer.setSize(this.domElement.clientWidth, this.domElement.clientHeight, true);
+        this._outlineService.setSize(this.domElement.clientWidth, this.domElement.clientHeight);
+    }
+    _updateWindowSize() {
+        this._resizeRendererToDisplaySize();
+        RelativePositionUtils.SetApplicationOffset(this.domElement);
+        if (this._cameraService.camera instanceof PerspectiveCamera) {
+            const aspect = this.domElement.clientWidth / this.domElement.clientHeight;
+            this._cameraService.realAspectRatio = aspect;
+            this._cameraService.camera.aspect = aspect;
+            this._cameraService.camera.updateProjectionMatrix();
+        }
+        this.needsRender = true;
+    }
+    _checkCanvasResize() {
+        if (this.domElement.clientWidth !== this.renderer.domElement.width ||
+            this.domElement.clientHeight !== this.renderer.domElement.height) {
+            this._updateWindowSize();
+        }
+    }
+    _render(t, frame) {
+        if (!this.renderer.xr.enabled) {
+            TWEEN.update();
+            this._checkCanvasResize();
+        }
+        if (this._settingsService.settings.options.pathTracer && this.pathTracer) {
+            if (this._numberOfSamplesRendered >= this._maxRenderSamples) {
+                this.pathTracer.enablePathTracing = false;
+            }
+            else {
+                this.pathTracer.enablePathTracing = true;
+                this.renderer.clear();
+                this.pathTracer.renderSample();
+            }
+            this._numberOfSamplesRendered = Math.floor(this.pathTracer.samples);
+        }
+        else {
+            if (this._needsRender || this.arMode || this._viewModeService.isVRViewActive() || this._outlineService.needsRender) {
+                this.renderer.clear();
+                if (this._arMode && frame) {
+                    this._arService.handleFrame(frame);
+                }
+                else if (this._viewModeService.isVRViewActive()) {
+                    this._vrService.render();
+                }
+                else {
+                    this.onBeforeRender.next({ renderer: this.renderer, scene: this.scene });
+                    if (!this.renderingThroughPostProcessingPipeline) {
+                        this.renderer.render(this.scene, this._cameraService.camera);
+                    }
+                    else {
+                        this._outlineService.render();
+                    }
+                    // this.renderer.render(this.scene, this._cameraService.camera);
+                }
+                this.onAfterRender.next({ renderer: this.renderer, scene: this.scene });
+                this._outlineService.needsRender = false;
+                this.needsRender = false;
+            }
+        }
+    }
+    _animate() {
+        this.needsRender = true;
+        setTimeout(() => {
+            this.renderer.setAnimationLoop((timestamp, frame) => this._render(timestamp, frame));
+        }, 200);
+    }
+    _pauseAnimation() {
+        this.needsRender = true;
+        setTimeout(() => {
+            this.renderer.setAnimationLoop(null);
+        }, 200);
+    }
+    _is3DMode(mode) {
+        return mode !== ViewMode.FloorPlan2D;
+    }
+    _setSceneBackground() {
+        this._subs.push(this._settingsService.settingsLoaded.subscribe((loaded) => {
+            if (loaded && this._settingsService.settings.sceneBackground) {
+                this.scene.background = new TextureLoader().load(this._settingsService.settings.sceneBackground, (material) => {
+                    material.colorSpace = SRGBColorSpace;
+                });
+            }
+            else if (loaded && this._settingsService.settings.sceneBackgroundColor) {
+                try {
+                    this.scene.background = new Color(parseInt(this._settingsService.settings.sceneBackgroundColor, 0));
+                }
+                catch (e) {
+                }
+            }
+        }));
+    }
+    getSceneCanvasImage() {
+        this.renderer.render(this.scene, this._cameraService.camera);
+        return this.renderer.domElement.toDataURL('image/jpeg');
+    }
+}
+SceneService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SceneService, deps: [{ token: i1.CameraService }, { token: i2.ConfigurationService }, { token: i3.XrService }, { token: i4.VrService }, { token: i5.ArService }, { token: i6.MessageBusService }, { token: i7.ViewModeService }, { token: i8.OutlineService }, { token: i9.HomedecoratorSettingsService }], target: i0.ɵɵFactoryTarget.Injectable });
+SceneService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SceneService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SceneService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.CameraService }, { type: i2.ConfigurationService }, { type: i3.XrService }, { type: i4.VrService }, { type: i5.ArService }, { type: i6.MessageBusService }, { type: i7.ViewModeService }, { type: i8.OutlineService }, { type: i9.HomedecoratorSettingsService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scene.service.js","sourceRoot":"","sources":["../../../../../../../src/client/app/plugins/core3d/service/scene.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\r\nimport {\r\n  Color, DataTexture, EquirectangularReflectionMapping, Fog,\r\n  Object3D,\r\n  PCFSoftShadowMap,\r\n  PerspectiveCamera,\r\n  PMREMGenerator,\r\n  ReinhardToneMapping,\r\n  Scene,\r\n  SRGBColorSpace,\r\n  TextureLoader,\r\n  Vector2,\r\n  Vector3,\r\n  WebGLRenderer\r\n} from 'three';\r\nimport {BehaviorSubject, Subject, Subscription} from 'rxjs';\r\nimport * as TWEEN from '@tweenjs/tween.js';\r\nimport {ACESFilmicToneMapping, FloatType, PCFShadowMap} from 'three/src/constants';\r\nimport {CameraService} from './camera.service';\r\nimport {ConfigurationService} from '../../../core/service/configuration.service';\r\nimport {XrService} from './xr.service';\r\nimport {VrService} from './vr.service';\r\nimport {ArService} from './ar.service';\r\nimport {MessageBusService} from '../../../core/service/message-bus.service';\r\nimport {ViewModeService} from '../../../core/service/view-mode.service';\r\nimport {OutlineService} from './outline.service';\r\nimport {HomedecoratorSettingsService} from '../../../core/service/homedecorator-settings.service';\r\nimport {ViewMode} from '../../../core/enum/view-mode.enum';\r\nimport {MessageType} from '../../../core/enum/message-type.enum';\r\nimport {FileUtils} from '../../../core/utils/file.utils';\r\nimport {Utils} from '../core/utils';\r\nimport {Scene3DUtil} from '../../threedselector/threedselector/utils/scene-3d.utils';\r\nimport {RelativePositionUtils} from '../../../core/utils/relative-position.utils';\r\nimport {RGBELoader} from 'three/examples/jsm/loaders/RGBELoader';\r\n// import WebGPU from 'three/examples/jsm/capabilities/WebGPU';\r\n// import WebGL from 'three/examples/jsm/capabilities/WebGL';\r\n// import WebGPURenderer from 'three/examples/jsm/renderers/webgpu/WebGPURenderer';\r\nimport {WebGLPathTracer} from 'three-gpu-pathtracer';\r\nimport {ParallelMeshBVHWorker} from 'three-mesh-bvh/src/workers/ParallelMeshBVHWorker.js';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class SceneService implements OnDestroy {\r\n\r\n  public set needsRender(value: boolean) {\r\n    this._needsRender = value;\r\n    if (this.pathTracer) {\r\n      this.pathTracer.updateCamera();\r\n      this.pathTracer.updateLights();\r\n      this.pathTracer.updateMaterials();\r\n      this.pathTracer.updateEnvironment();\r\n    }\r\n    this._numberOfSamplesRendered = 0;\r\n  }\r\n\r\n  public get needsRender(): boolean {\r\n    return this._needsRender;\r\n  }\r\n\r\n  public scene: Scene;\r\n  public renderer: WebGLRenderer/* | WebGPURenderer*/;\r\n  public pathTracer: WebGLPathTracer;\r\n\r\n  public onBeforeRender: Subject<{ renderer: WebGLRenderer, scene: Scene }> = new Subject<{ renderer: WebGLRenderer, scene: Scene }>();\r\n  public onAfterRender: Subject<{ renderer: WebGLRenderer, scene: Scene }> = new Subject<{ renderer: WebGLRenderer, scene: Scene }>();\r\n  public sceneInitialized: BehaviorSubject<boolean> = new BehaviorSubject(false);\r\n  public renderingThroughPostProcessingPipeline: boolean = true;\r\n  public webGL2Available: boolean;\r\n  public domElement: HTMLElement;\r\n\r\n  private _needsRender: boolean;\r\n  private _arMode: boolean = false;\r\n  private _subs: Subscription[] = [];\r\n  private _maxRenderSamples: number;\r\n  private _numberOfSamplesRendered: number;\r\n\r\n  constructor(\r\n    private _cameraService: CameraService,\r\n    private _configurationService: ConfigurationService,\r\n    private _xrService: XrService,\r\n    private _vrService: VrService,\r\n    private _arService: ArService,\r\n    private _messageBusService: MessageBusService,\r\n    private _viewModeService: ViewModeService,\r\n    private _outlineService: OutlineService,\r\n    private _settingsService: HomedecoratorSettingsService\r\n  ) {\r\n    window.onbeforeunload = () => this.ngOnDestroy();\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.domElement = undefined;\r\n    this._subs.forEach(s => s.unsubscribe());\r\n  }\r\n\r\n  public getScene(): Scene {\r\n    return this.arMode ? this._arService.scene : this.scene;\r\n  }\r\n\r\n  public set arMode(value: boolean) {\r\n    this._arMode = value;\r\n    if (this._arMode) {\r\n      this._arService.init(this.renderer as WebGLRenderer);\r\n      this._viewModeService.viewMode = ViewMode.AR;\r\n    }\r\n  }\r\n\r\n  public get arMode(): boolean {\r\n    return this._arMode;\r\n  }\r\n\r\n  public init(element: HTMLElement): void {\r\n    this.domElement = element;\r\n    this._initScene();\r\n    this._initRenderer();\r\n    this._initCamera();\r\n    this._initOutline();\r\n    this._animate();\r\n    this._subs.push(\r\n      this._cameraService.cameraMovementChanged.subscribe(() => {\r\n        this.needsRender = true;\r\n      }),\r\n      this._messageBusService.subscribe(MessageType.TakeScreenshot, async () => {\r\n        if (this._viewModeService.is3dViewActive() || this._viewModeService.isTopViewActive()) {\r\n          this.renderer.render(this.scene, this._cameraService.camera);\r\n          const dataUrl = this.renderer.domElement.toDataURL('image/jpeg');\r\n          FileUtils.DownloadFromDataUri(dataUrl, `MyRoomplan${new Date().toISOString()}.jpeg`);\r\n        }\r\n      }),\r\n      this._arService.shouldAddObjectToScene.subscribe((object) => {\r\n        this.arMode = false;\r\n        this.addObject(object);\r\n      }),\r\n      this._viewModeService.viewModeChanged.subscribe((mode) => {\r\n        // if (this._is3DMode(mode)) {\r\n        //   this._animate();\r\n        // } else {\r\n        //   this._pauseAnimation();\r\n        // }\r\n        if (mode === ViewMode.VR) {\r\n          this._vrService.init(this.scene, this.renderer as WebGLRenderer);\r\n        } else {\r\n          this._vrService.endSession();\r\n        }\r\n      }),\r\n      this._settingsService.settingsLoaded.subscribe((loaded: boolean) => {\r\n        if (loaded) {\r\n          this._initPathTracer();\r\n          this._maxRenderSamples = this._settingsService.settings.options.maxRenderSamples;\r\n        }\r\n      })\r\n      // this._xrService.sessionStarted.subscribe((mode: XrMode) => {\r\n      //   if (mode === XrMode.ArMode) {\r\n      //     this._animateAr();\r\n      //   }\r\n      // })\r\n    );\r\n    this._xrService.init(this.renderer as WebGLRenderer, this.scene, this._cameraService.camera);\r\n    this.sceneInitialized.next(true);\r\n  }\r\n\r\n  public addObject(obj: Object3D, forceRender: boolean = true): void {\r\n    if (this._arMode) {\r\n      this._arService.addObjectToARScene(obj);\r\n    } else {\r\n      this.scene.add(obj);\r\n      this.updatePathTracer();\r\n    }\r\n\r\n    if (forceRender) {\r\n      this.needsRender = true;\r\n    }\r\n  }\r\n\r\n  public removeObject(obj: Object3D, forceRender: boolean = true, cleanUp: boolean = true): void {\r\n    this.scene.remove(obj);\r\n    if (forceRender) {\r\n      this.needsRender = true;\r\n    }\r\n    if (cleanUp) {\r\n      Utils.DisposeObject(obj);\r\n    }\r\n  }\r\n\r\n  public updatePathTracer(): void {\r\n    if (this._settingsService.settings.options.pathTracer && this.pathTracer) {\r\n      try {\r\n        this.pathTracer.setScene(this.scene, this._cameraService.camera);\r\n      } catch (e) {\r\n        console.error(e);\r\n      }\r\n    }\r\n  }\r\n\r\n  public positionInSceneToScreen(pos: Vector3): Vector2 {\r\n    return Scene3DUtil.Convert3DPointToScreenPoint(\r\n      pos, this._cameraService.camera, this.domElement.clientWidth, this.domElement.clientHeight);\r\n  }\r\n\r\n  public rendererPropsChange(): void {\r\n    this.scene.traverse((node: any) => {\r\n      if (!node.isMesh) {\r\n        return;\r\n      }\r\n      if (Array.isArray(node.material)) {\r\n        node.material.forEach(function (material) {\r\n          material.needsUpdate = true;\r\n        });\r\n      } else {\r\n        node.material.needsUpdate = true;\r\n      }\r\n    });\r\n    this.needsRender = true;\r\n  }\r\n\r\n  private _initScene(): void {\r\n    this.scene = new Scene();\r\n    this._setSceneBackground();\r\n    // const box1geo = new BoxGeometry(1, 1, 1);\r\n    // const box1 = new Mesh(box1geo, new MeshPhongMaterial({color: 'green'}));\r\n    // box1.position.set(-0.5, 0.7, -0.5);\r\n    // box1.castShadow = true;\r\n    // box1.receiveShadow = true;\r\n    // this.scene.add(box1);\r\n    // const box2geo = new BoxGeometry(0.6, 0.6, 0.6);\r\n    // const box2 = new Mesh(box2geo, new MeshPhongMaterial({color: 'red'}));\r\n    // box2.position.set(0.5, 1.5, 0.5);\r\n    // box2.castShadow = true;\r\n    // box2.receiveShadow = true;\r\n    // this.scene.add(box2);\r\n  }\r\n\r\n  private _initCamera(): void {\r\n    this._cameraService.init(this.domElement);\r\n  }\r\n\r\n  private _initOutline(): void {\r\n    this._outlineService.init(this.renderer as WebGLRenderer, this.scene, this._cameraService.camera,\r\n      this.domElement.clientWidth * window.devicePixelRatio,\r\n      this.domElement.clientHeight * window.devicePixelRatio);\r\n  }\r\n\r\n  private _initPathTracer(): void {\r\n    if (this._settingsService.settings.options.pathTracer) {\r\n      this.pathTracer = new WebGLPathTracer(this.renderer as WebGLRenderer);\r\n      this.pathTracer.setBVHWorker(new ParallelMeshBVHWorker());\r\n      this.pathTracer.filterGlossyFactor = 1;\r\n      this.pathTracer.tiles.set(3, 3);\r\n      this.pathTracer.multipleImportanceSampling = true;\r\n      this.pathTracer.transmissiveBounces = 10;\r\n      this.pathTracer.renderScale = 1;\r\n      this.pathTracer.setScene(this.scene, this._cameraService.camera);\r\n      this.pathTracer.enablePathTracing = true;\r\n    }\r\n  }\r\n\r\n  private async _initRenderer(): Promise<void> {\r\n    // if (WebGPU.isAvailable() === false && WebGL.isWebGL2Available() === false) {\r\n    //   document.body.appendChild( WebGPU.getErrorMessage() );\r\n    //   throw new Error('No WebGPU or WebGL2 support');\r\n    // }\r\n    const canvasElement: HTMLCanvasElement = document.createElement('canvas');\r\n    const context: any = canvasElement.getContext('webgl2', {antialias: true});\r\n    this.webGL2Available = context !== undefined;\r\n    // this.renderer = new WebGPURenderer({ alpha: true, antialias: true });\r\n    // this.renderer =\r\n    //   new WebGLRenderer({\r\n    //     canvas: canvasElement,\r\n    //     context: context,\r\n    //     alpha: true,\r\n    //     antialias: true,\r\n    //     preserveDrawingBuffer: true,\r\n    //     premultipliedAlpha: false/*,\r\n    //     logarithmicDepthBuffer: true*/\r\n    //   });\r\n    this.renderer = new WebGLRenderer({alpha: true, antialias: true, preserveDrawingBuffer: true, premultipliedAlpha: false});\r\n    this.renderer.autoClear = false;\r\n    this.renderer.setPixelRatio(window.devicePixelRatio);\r\n    this.renderer.toneMapping = ACESFilmicToneMapping; // LinearToneMapping;\r\n    this.renderer.shadowMap.enabled = true;\r\n    this.renderer.shadowMap.type = PCFSoftShadowMap;\r\n    this.domElement.appendChild(this.renderer.domElement);\r\n    this.renderer.domElement.setAttribute('id', 'threed_canvas');\r\n  }\r\n\r\n  private _resizeRendererToDisplaySize(): void {\r\n    this.renderer.setSize(this.domElement.clientWidth, this.domElement.clientHeight, true);\r\n    this._outlineService.setSize(this.domElement.clientWidth, this.domElement.clientHeight);\r\n  }\r\n\r\n  private _updateWindowSize(): void {\r\n    this._resizeRendererToDisplaySize();\r\n    RelativePositionUtils.SetApplicationOffset(this.domElement);\r\n    if (this._cameraService.camera instanceof PerspectiveCamera) {\r\n      const aspect = this.domElement.clientWidth / this.domElement.clientHeight;\r\n      this._cameraService.realAspectRatio = aspect;\r\n      this._cameraService.camera.aspect = aspect;\r\n      (this._cameraService.camera as PerspectiveCamera).updateProjectionMatrix();\r\n    }\r\n    this.needsRender = true;\r\n  }\r\n\r\n  private _checkCanvasResize(): void {\r\n    if (this.domElement.clientWidth !== this.renderer.domElement.width ||\r\n      this.domElement.clientHeight !== this.renderer.domElement.height) {\r\n      this._updateWindowSize();\r\n    }\r\n  }\r\n\r\n  private _render(t, frame) {\r\n    if (!this.renderer.xr.enabled) {\r\n      TWEEN.update();\r\n      this._checkCanvasResize();\r\n    }\r\n    if (this._settingsService.settings.options.pathTracer && this.pathTracer) {\r\n      if (this._numberOfSamplesRendered >= this._maxRenderSamples) {\r\n        this.pathTracer.enablePathTracing = false;\r\n      } else {\r\n        this.pathTracer.enablePathTracing = true;\r\n        this.renderer.clear();\r\n        this.pathTracer.renderSample();\r\n      }\r\n      this._numberOfSamplesRendered = Math.floor(this.pathTracer.samples);\r\n    } else {\r\n      if (this._needsRender || this.arMode || this._viewModeService.isVRViewActive() || this._outlineService.needsRender) {\r\n        this.renderer.clear();\r\n        if (this._arMode && frame) {\r\n          this._arService.handleFrame(frame);\r\n        } else if (this._viewModeService.isVRViewActive()) {\r\n          this._vrService.render();\r\n        } else {\r\n          this.onBeforeRender.next({renderer: this.renderer as WebGLRenderer, scene: this.scene});\r\n          if (!this.renderingThroughPostProcessingPipeline) {\r\n            this.renderer.render(this.scene, this._cameraService.camera);\r\n          } else {\r\n            this._outlineService.render();\r\n          }\r\n          // this.renderer.render(this.scene, this._cameraService.camera);\r\n        }\r\n        this.onAfterRender.next({renderer: this.renderer as WebGLRenderer, scene: this.scene});\r\n        this._outlineService.needsRender = false;\r\n        this.needsRender = false;\r\n      }\r\n    }\r\n  }\r\n\r\n  private _animate(): void {\r\n    this.needsRender = true;\r\n    setTimeout(() => {\r\n      this.renderer.setAnimationLoop((timestamp, frame) => this._render(timestamp, frame));\r\n    }, 200);\r\n  }\r\n\r\n  private _pauseAnimation(): void {\r\n    this.needsRender = true;\r\n    setTimeout(() => {\r\n      this.renderer.setAnimationLoop(null);\r\n    }, 200);\r\n  }\r\n\r\n  private _is3DMode(mode: ViewMode): boolean {\r\n    return mode !== ViewMode.FloorPlan2D;\r\n  }\r\n\r\n  private _setSceneBackground(): void {\r\n    this._subs.push(\r\n      this._settingsService.settingsLoaded.subscribe((loaded: boolean) => {\r\n          if (loaded && this._settingsService.settings.sceneBackground) {\r\n            this.scene.background = new TextureLoader().load(this._settingsService.settings.sceneBackground, (material) => {\r\n              material.colorSpace = SRGBColorSpace;\r\n            });\r\n          } else if (loaded && this._settingsService.settings.sceneBackgroundColor) {\r\n            try {\r\n              this.scene.background = new Color(parseInt(this._settingsService.settings.sceneBackgroundColor, 0));\r\n            } catch (e) {\r\n            }\r\n          }\r\n        }\r\n      ));\r\n  }\r\n\r\n  public getSceneCanvasImage(): string {\r\n    this.renderer.render(this.scene, this._cameraService.camera);\r\n    return this.renderer.domElement.toDataURL('image/jpeg');\r\n  }\r\n\r\n}\r\n"]}