@colijnit/configurator 261.1.0 → 261.1.1

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

@@ -0,0 +1,313 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import { BufferGeometry, Color, Mesh, NoToneMapping, PCFSoftShadowMap, PerspectiveCamera, Scene, SRGBColorSpace, TextureLoader, WebGLRenderer } from 'three';
+import { BehaviorSubject, Subject } from 'rxjs';
+import * as TWEEN from '@tweenjs/tween.js';
+import { WebGLPathTracer } from 'three-gpu-pathtracer';
+import { ParallelMeshBVHWorker } from 'three-mesh-bvh/src/workers/ParallelMeshBVHWorker.js';
+import { ViewMode } from '../enum/view-mode.enum';
+import { acceleratedRaycast, computeBoundsTree, disposeBoundsTree } from 'three-mesh-bvh';
+import { DeviceTier } from '../enum/device-tier.enum';
+import { DeviceUtils } from '../utils/device.utils';
+import { RelativePositionUtils } from '../utils/relative-position.utils';
+import { ObjectUtils } from '../utils/object.utils';
+import { Scene3DUtil } from '../utils/scene-3d.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "./camera.service";
+import * as i2 from "./xr.service";
+import * as i3 from "./vr.service";
+import * as i4 from "./ar.service";
+import * as i5 from "./settings.service";
+import * as i6 from "./post-processing.service";
+import * as i7 from "./view-mode.service";
+export class SceneService {
+    constructor(_cameraService, _xrService, _vrService, _arService, _settingsService, _postProcessing, _viewModeService) {
+        this._cameraService = _cameraService;
+        this._xrService = _xrService;
+        this._vrService = _vrService;
+        this._arService = _arService;
+        this._settingsService = _settingsService;
+        this._postProcessing = _postProcessing;
+        this._viewModeService = _viewModeService;
+        this.standAlone = true;
+        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;
+    }
+    takeScreenshot() {
+        if (!this.renderer || !this.scene || !this._cameraService.camera) {
+            return '';
+        }
+        this.renderer.render(this.scene, this._cameraService.camera);
+        return this.renderer.domElement.toDataURL('image/jpeg');
+    }
+    init(element) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.domElement = element;
+            this._initScene();
+            this._initRenderer();
+            this._initCamera();
+            this._initPostProcessing();
+            this._animate();
+            this._subs.push(this._cameraService.cameraMovementChanged.subscribe(() => {
+                this._postProcessing.cameraMovementChanged();
+                this.needsRender = true;
+            }), 
+            // this._messageBusService.subscribe(MessageType.TakeScreenshot, async () => {
+            //   if (this._viewModeService.is3dViewActive() || this._viewModeService.isTopViewActive()) {
+            //     FileUtils.DownloadFromDataUri(this.takeScreenshot(), `MyRoomplan${new Date().toISOString()}.jpeg`);
+            //   }
+            // }),
+            // this._arService.shouldAddObjectToScene.subscribe((object) => {
+            //   this.arMode = false;
+            //   this.addObject(object);
+            // }),
+            // this._viewModeService.viewModeChanged.subscribe((mode) => {
+            //   if (mode === ViewMode.VR) {
+            //     this._vrService.init(this.scene, this.renderer as WebGLRenderer);
+            //   } else {
+            //     this._vrService.endSession();
+            //   }
+            // }),
+            this._settingsService.settingsLoaded.subscribe((loaded) => {
+                if (loaded) {
+                    this._initPathTracer();
+                    this._maxRenderSamples = this._settingsService.settings.options.maxRenderSamples;
+                }
+            }));
+            this._xrService.init(this.renderer, this.scene, this._cameraService.camera);
+            this.sceneInitialized.next(true);
+        });
+    }
+    getSceneCanvasImage() {
+        this.renderer.render(this.scene, this._cameraService.camera);
+        return this.renderer.domElement.toDataURL('image/jpeg');
+    }
+    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) {
+            ObjectUtils.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() {
+        BufferGeometry.prototype.computeBoundsTree = computeBoundsTree;
+        BufferGeometry.prototype.disposeBoundsTree = disposeBoundsTree;
+        Mesh.prototype.raycast = acceleratedRaycast;
+        this.scene = new Scene();
+        this._setSceneBackground();
+    }
+    _initCamera() {
+        this._cameraService.init(this.domElement);
+    }
+    _initPostProcessing() {
+        this._postProcessing.init(this.renderer, this.scene, this._cameraService.camera, this.domElement.clientWidth, this.domElement.clientHeight, this.standAlone);
+    }
+    _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* () {
+            const canvasElement = document.createElement('canvas');
+            const context = canvasElement.getContext('webgl2');
+            this.webGL2Available = context !== undefined;
+            const deviceTier = DeviceUtils.GetDeviceTier();
+            this.renderer = new WebGLRenderer({
+                precision: deviceTier === DeviceTier.High ? 'highp' : 'mediump',
+                powerPreference: deviceTier === DeviceTier.High ? 'high-performance' : 'default',
+                preserveDrawingBuffer: true,
+                alpha: false
+            });
+            this.renderer.outputColorSpace = SRGBColorSpace;
+            this.renderer.autoClear = true;
+            this.renderer.setPixelRatio(DeviceUtils.GetPixelRatio());
+            this.renderer.toneMapping = NoToneMapping; // AgXToneMapping; // NoToneMapping; // ACESFilmicToneMapping; // LinearToneMapping;
+            this.renderer.toneMappingExposure = 1;
+            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._postProcessing.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) {
+            return;
+        }
+        if (this.domElement.clientWidth !== this.renderer.domElement.width ||
+            this.domElement.clientHeight !== this.renderer.domElement.height) {
+            this._updateWindowSize();
+        }
+    }
+    _render(t, frame) {
+        this._cameraService.controls.inertiaLoop();
+        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.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 });
+                    this._postProcessing.render();
+                }
+                this.onAfterRender.next({ renderer: this.renderer, scene: this.scene });
+                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);
+    }
+    _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(`#${this._settingsService.settings.sceneBackgroundColor}`);
+                }
+                catch (e) {
+                }
+            }
+        }));
+    }
+}
+SceneService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SceneService, deps: [{ token: i1.CameraService }, { token: i2.XrService }, { token: i3.VrService }, { token: i4.ArService }, { token: i5.SettingsService }, { token: i6.PostProcessingService }, { token: i7.ViewModeService }], 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.XrService }, { type: i3.VrService }, { type: i4.ArService }, { type: i5.SettingsService }, { type: i6.PostProcessingService }, { type: i7.ViewModeService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scene.service.js","sourceRoot":"","sources":["../../../../../projects/configurator/src/lib/services/scene.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\r\nimport {BufferGeometry, Color, Mesh, NoToneMapping, Object3D, PCFSoftShadowMap, PerspectiveCamera, Scene, SRGBColorSpace, TextureLoader, Vector2, Vector3, WebGLRenderer} from 'three';\r\nimport {BehaviorSubject, Subject, Subscription} from 'rxjs';\r\nimport * as TWEEN from '@tweenjs/tween.js';\r\nimport {WebGLPathTracer} from 'three-gpu-pathtracer';\r\nimport {ParallelMeshBVHWorker} from 'three-mesh-bvh/src/workers/ParallelMeshBVHWorker.js';\r\nimport {SettingsService} from './settings.service';\r\nimport {ViewMode} from '../enum/view-mode.enum';\r\nimport {CameraService} from './camera.service';\r\nimport {XrService} from './xr.service';\r\nimport {VrService} from './vr.service';\r\nimport {ArService} from './ar.service';\r\nimport {PostProcessingService} from './post-processing.service';\r\nimport {acceleratedRaycast, computeBoundsTree, disposeBoundsTree} from 'three-mesh-bvh';\r\nimport {DeviceTier} from '../enum/device-tier.enum';\r\nimport {DeviceUtils} from '../utils/device.utils';\r\nimport {RelativePositionUtils} from '../utils/relative-position.utils';\r\nimport {ViewModeService} from './view-mode.service';\r\nimport {ObjectUtils} from '../utils/object.utils';\r\nimport {Scene3DUtil} from '../utils/scene-3d.utils';\r\n\r\n@Injectable({providedIn: 'root'})\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  public standAlone: boolean = true;\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 _xrService: XrService,\r\n    private _vrService: VrService,\r\n    private _arService: ArService,\r\n    private _settingsService: SettingsService,\r\n    private _postProcessing: PostProcessingService,\r\n    private _viewModeService: ViewModeService\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 takeScreenshot(): string {\r\n    if (!this.renderer || !this.scene || !this._cameraService.camera) {\r\n      return '';\r\n    }\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  public async init(element: HTMLElement): Promise<void> {\r\n    this.domElement = element;\r\n    this._initScene();\r\n    this._initRenderer();\r\n    this._initCamera();\r\n    this._initPostProcessing();\r\n    this._animate();\r\n    this._subs.push(\r\n      this._cameraService.cameraMovementChanged.subscribe(() => {\r\n        this._postProcessing.cameraMovementChanged();\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      //     FileUtils.DownloadFromDataUri(this.takeScreenshot(), `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 (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    );\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 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  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    if (forceRender) {\r\n      this.needsRender = true;\r\n    }\r\n  }\r\n\r\n  public removeObject(obj: Object3D | Mesh, 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      ObjectUtils.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    BufferGeometry.prototype.computeBoundsTree = computeBoundsTree;\r\n    BufferGeometry.prototype.disposeBoundsTree = disposeBoundsTree;\r\n    Mesh.prototype.raycast = acceleratedRaycast;\r\n\r\n    this.scene = new Scene();\r\n    this._setSceneBackground();\r\n  }\r\n\r\n  private _initCamera(): void {\r\n    this._cameraService.init(this.domElement);\r\n  }\r\n\r\n  private _initPostProcessing(): void {\r\n    this._postProcessing.init(\r\n      this.renderer as WebGLRenderer,\r\n      this.scene,\r\n      this._cameraService.camera,\r\n      this.domElement.clientWidth,\r\n      this.domElement.clientHeight,\r\n      this.standAlone);\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\r\n    const canvasElement: HTMLCanvasElement = document.createElement('canvas');\r\n    const context: any = canvasElement.getContext('webgl2');\r\n    this.webGL2Available = context !== undefined;\r\n\r\n    const deviceTier: DeviceTier = DeviceUtils.GetDeviceTier();\r\n    this.renderer = new WebGLRenderer({\r\n      precision: deviceTier === DeviceTier.High ? 'highp' : 'mediump',\r\n      powerPreference: deviceTier === DeviceTier.High ? 'high-performance' : 'default',\r\n      preserveDrawingBuffer: true,\r\n      alpha: false\r\n    });\r\n    this.renderer.outputColorSpace = SRGBColorSpace;\r\n    this.renderer.autoClear = true;\r\n    this.renderer.setPixelRatio(DeviceUtils.GetPixelRatio());\r\n    this.renderer.toneMapping = NoToneMapping;  // AgXToneMapping; // NoToneMapping; // ACESFilmicToneMapping; // LinearToneMapping;\r\n    this.renderer.toneMappingExposure = 1;\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._postProcessing.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) {\r\n      return;\r\n    }\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    this._cameraService.controls.inertiaLoop();\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()) {\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          this._postProcessing.render();\r\n        }\r\n        this.onAfterRender.next({renderer: this.renderer as WebGLRenderer, scene: this.scene});\r\n\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\r\n    setTimeout(() => {\r\n      this.renderer.setAnimationLoop((timestamp, frame) =>\r\n        this._render(timestamp, frame)\r\n      );\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 _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(`#${this._settingsService.settings.sceneBackgroundColor}`);\r\n          } catch (e) {\r\n          }\r\n        }\r\n      }));\r\n  }\r\n}\r\n"]}

package/esm2015/lib/services/screen-size-analysis.service.js

@@ -0,0 +1,97 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { DeviceSizeType } from '../enum/device-size-type';
+import { NavigatorType } from '../enum/navigator-type.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+import * as i2 from "ngx-device-detector";
+export const minimalScreenWidthByDeviceType = {
+    [DeviceSizeType.Desktop]: 1024,
+    [DeviceSizeType.Tablet]: 800,
+    [DeviceSizeType.Phone]: 320 // px
+};
+export class ScreenSizeAnalysisService {
+    constructor(_eventManager, _deviceDetectorService) {
+        this._eventManager = _eventManager;
+        this._deviceDetectorService = _deviceDetectorService;
+    }
+    get screenSizeChanged() {
+        if (!this._onResizeSubject) {
+            this._initOnResizeObservable();
+        }
+        return this._onResizeSubject.asObservable();
+    }
+    get isMobileDevice() {
+        return this._deviceDetectorService.isMobile();
+    }
+    ngOnInit() {
+        this._checkImageBitmapDisable();
+    }
+    ngOnDestroy() { }
+    getScreenSizeInfo(window) {
+        const { width, height } = this._getCurrentScreenSize(window);
+        const deviceType = this._getDeviceSizeType(width);
+        return {
+            width,
+            height,
+            deviceSizeType: deviceType,
+            isDesktopSize: deviceType === DeviceSizeType.Desktop,
+            isTabletSize: deviceType === DeviceSizeType.Tablet,
+            isPhoneSize: deviceType === DeviceSizeType.Phone,
+            isPortraitMode: height > width
+        };
+    }
+    isIphoneOrIpad() {
+        return /iPad|iPhone|iPod/.test(window.navigator.platform) ||
+            (window.navigator.platform === 'MacIntel' && window.navigator.maxTouchPoints > 1) ||
+            /^(iPad|iPhone|iPod)/.test(window.navigator.platform) ||
+            (/^Mac/.test(window.navigator.platform) && window.navigator.maxTouchPoints > 1);
+    }
+    isSafari() {
+        return /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+    }
+    navigatorType() {
+        if (this.isIphoneOrIpad() && this.isSafari()) {
+            return NavigatorType.IOsSafari;
+        }
+        else {
+            return NavigatorType.Browser;
+        }
+    }
+    _getCurrentScreenSize(window) {
+        return {
+            width: window.innerWidth,
+            height: window.innerHeight
+        };
+    }
+    _initOnResizeObservable() {
+        this._onResizeSubject = new BehaviorSubject(this.getScreenSizeInfo(window));
+        this._eventManager.addGlobalEventListener('window', 'resize', (event) => {
+            this._onResizeSubject.next(this.getScreenSizeInfo(event.target));
+        });
+    }
+    _getDeviceSizeType(width) {
+        if (width >= minimalScreenWidthByDeviceType[DeviceSizeType.Desktop]) {
+            return DeviceSizeType.Desktop;
+        }
+        if (width >= minimalScreenWidthByDeviceType[DeviceSizeType.Tablet]) {
+            return DeviceSizeType.Tablet;
+        }
+        return DeviceSizeType.Phone;
+    }
+    _checkImageBitmapDisable() {
+        // Temporary fix until Apple fixes memory limit on image bitmap texture creation
+        if (this.isIphoneOrIpad() || this.isSafari()) {
+            window.createImageBitmap = undefined;
+        }
+    }
+}
+ScreenSizeAnalysisService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ScreenSizeAnalysisService, deps: [{ token: i1.EventManager }, { token: i2.DeviceDetectorService }], target: i0.ɵɵFactoryTarget.Injectable });
+ScreenSizeAnalysisService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ScreenSizeAnalysisService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ScreenSizeAnalysisService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.EventManager }, { type: i2.DeviceDetectorService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"screen-size-analysis.service.js","sourceRoot":"","sources":["../../../../../projects/configurator/src/lib/services/screen-size-analysis.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, OnDestroy, OnInit} from '@angular/core';\r\nimport {EventManager} from '@angular/platform-browser';\r\nimport {BehaviorSubject, Observable} from 'rxjs';\r\nimport { DeviceSizeType } from '../enum/device-size-type';\r\nimport {ScreenSizeInfo} from '../interfaces/screen-size-info';\r\nimport {NavigatorType} from '../enum/navigator-type.enum';\r\nimport {DeviceDetectorService} from 'ngx-device-detector';\r\n\r\nexport const minimalScreenWidthByDeviceType = {\r\n  [DeviceSizeType.Desktop]: 1024, // px\r\n  [DeviceSizeType.Tablet]: 800,  // px\r\n  [DeviceSizeType.Phone]: 320  // px\r\n};\r\n\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ScreenSizeAnalysisService implements OnDestroy, OnInit {\r\n\r\n  private _onResizeSubject: BehaviorSubject<ScreenSizeInfo>;\r\n\r\n  public get screenSizeChanged(): Observable<ScreenSizeInfo> {\r\n    if (!this._onResizeSubject) {\r\n      this._initOnResizeObservable();\r\n    }\r\n    return this._onResizeSubject.asObservable();\r\n  }\r\n\r\n  public get isMobileDevice(): boolean {\r\n    return this._deviceDetectorService.isMobile();\r\n  }\r\n\r\n  constructor(\r\n    private _eventManager: EventManager,\r\n    private _deviceDetectorService: DeviceDetectorService) {\r\n  }\r\n\r\n  public ngOnInit(): void {\r\n    this._checkImageBitmapDisable();\r\n  }\r\n\r\n  public ngOnDestroy() { }\r\n\r\n  public getScreenSizeInfo(window: Window): ScreenSizeInfo {\r\n    const { width, height } = this._getCurrentScreenSize(window);\r\n    const deviceType = this._getDeviceSizeType(width);\r\n    return {\r\n      width,\r\n      height,\r\n      deviceSizeType: deviceType,\r\n      isDesktopSize: deviceType === DeviceSizeType.Desktop,\r\n      isTabletSize: deviceType === DeviceSizeType.Tablet,\r\n      isPhoneSize: deviceType === DeviceSizeType.Phone,\r\n      isPortraitMode: height > width\r\n    };\r\n  }\r\n\r\n  public isIphoneOrIpad(): boolean {\r\n    return /iPad|iPhone|iPod/.test(window.navigator.platform) ||\r\n      (window.navigator.platform === 'MacIntel' && window.navigator.maxTouchPoints > 1) ||\r\n      /^(iPad|iPhone|iPod)/.test(window.navigator.platform) ||\r\n      (/^Mac/.test(window.navigator.platform) && window.navigator.maxTouchPoints > 1);\r\n  }\r\n\r\n  public isSafari(): boolean {\r\n    return /^((?!chrome|android).)*safari/i.test(navigator.userAgent);\r\n  }\r\n\r\n  public navigatorType(): NavigatorType {\r\n    if (this.isIphoneOrIpad() && this.isSafari()) {\r\n      return NavigatorType.IOsSafari;\r\n    } else {\r\n      return NavigatorType.Browser;\r\n    }\r\n  }\r\n\r\n  private _getCurrentScreenSize(window: Window): {width: number, height: number} {\r\n    return {\r\n      width: window.innerWidth,\r\n      height: window.innerHeight\r\n    };\r\n  }\r\n\r\n  private _initOnResizeObservable() {\r\n    this._onResizeSubject = new BehaviorSubject(this.getScreenSizeInfo(window));\r\n    this._eventManager.addGlobalEventListener('window', 'resize', (event: UIEvent) => {\r\n      this._onResizeSubject.next(this.getScreenSizeInfo(<Window>event.target));\r\n    });\r\n  }\r\n\r\n  private _getDeviceSizeType(width: number): DeviceSizeType {\r\n    if (width >= minimalScreenWidthByDeviceType[DeviceSizeType.Desktop]) { return DeviceSizeType.Desktop; }\r\n    if (width >= minimalScreenWidthByDeviceType[DeviceSizeType.Tablet]) { return DeviceSizeType.Tablet; }\r\n    return DeviceSizeType.Phone;\r\n  }\r\n\r\n  private _checkImageBitmapDisable(): void {\r\n    // Temporary fix until Apple fixes memory limit on image bitmap texture creation\r\n    if (this.isIphoneOrIpad() || this.isSafari()) {\r\n      window.createImageBitmap = undefined;\r\n    }\r\n  }\r\n\r\n}\r\n"]}