@colijnit/homedecorator 255.1.1

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

@@ -0,0 +1,340 @@
+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 { Box3, PerspectiveCamera, Vector2, Vector3 } from 'three';
+import { Subject } from 'rxjs';
+import { Controls } from './controls';
+import { ViewMode } from '../../../core/enum/view-mode.enum';
+import { MessageType } from '../../../core/enum/message-type.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../core/service/view-mode.service";
+import * as i2 from "../../../core/service/message-bus.service";
+import * as i3 from "../../../core/service/configuration.service";
+const DEFAULT_CAMERA_ASPECT_RATIO = 1;
+const DEFAULT_CAMERA_FOV = 45;
+const DEFAULT_CAMERA_FOCUS = 10;
+export class CameraService {
+    constructor(_viewModeService, _messageBusService, _configurationService) {
+        this._viewModeService = _viewModeService;
+        this._messageBusService = _messageBusService;
+        this._configurationService = _configurationService;
+        this.panSpeed = 30;
+        this.rotateBy = Math.PI / 32;
+        this.moveBy = 25;
+        this.cameraDefaultHeight = 1.7;
+        this.targetDefaultOffset = 1;
+        this.exploreDistanceFromCorner = 0.8;
+        this.cameraMovementChanged = new Subject();
+        this._cameraLocked = false;
+        this._realAspectRatio = DEFAULT_CAMERA_ASPECT_RATIO;
+        this._aspectRatio = window.innerWidth / window.innerHeight;
+        this._subs = [];
+        this._subs.push(this._viewModeService.viewModeChanged.subscribe((mode) => {
+            this._viewSize = this._viewModeService.viewSize;
+            this._viewCenter = this._viewModeService.viewCenter;
+            this.viewMode = mode;
+        }), _messageBusService.subscribe(MessageType.WalkThroughCameraSettingsChanged, () => this._walkThroughCameraSettingsChanged()));
+    }
+    set viewMode(value) {
+        const shouldMoveCamera = !!this._viewMode;
+        this._viewMode = value;
+        if (shouldMoveCamera) {
+            this._turnOffExploreMode();
+            this._turnOffTopViewMode();
+            switch (this._viewMode) {
+                case ViewMode.TopView:
+                    this._turnOnTopViewMode();
+                    this._animateTopView();
+                    break;
+                case ViewMode.WalkThrough:
+                    this._turnOnExploreMode();
+                    this._animateWalkThrough();
+                    break;
+                case ViewMode.RoomPlan3D:
+                    this._animate3D();
+                    break;
+            }
+        }
+    }
+    get cameraLocked() {
+        return this._cameraLocked;
+    }
+    set realAspectRatio(value) {
+        this._realAspectRatio = value;
+    }
+    ngOnDestroy() {
+        this._subs.forEach(s => s.unsubscribe());
+        this.controls.removeEventListener('change', () => this._controlsUpdate());
+        this._element = undefined;
+    }
+    init(element) {
+        this._element = element;
+        this.camera = new PerspectiveCamera(45, 1, 0.01, 100);
+        this.camera.position.set(0, 3, 1.5);
+        this.camera.aspect = window.innerWidth / window.innerHeight;
+        this.camera.updateProjectionMatrix();
+        this.controls = new Controls(this.camera, this._element);
+        this.controls.addEventListener('change', () => this._controlsUpdate());
+        this.controls.update();
+    }
+    cameraLeft() {
+        if (this._viewMode === ViewMode.WalkThrough) {
+            this.controls.cameraLeft();
+        }
+        else {
+            this.controls.panXY(this.panSpeed, 0);
+        }
+    }
+    cameraRight() {
+        if (this._viewMode === ViewMode.WalkThrough) {
+            this.controls.cameraRight();
+        }
+        else {
+            this.controls.panXY(-this.panSpeed, 0);
+        }
+    }
+    cameraUp() {
+        if (this._viewMode === ViewMode.WalkThrough) {
+            this.controls.cameraForward();
+        }
+        else {
+            this.controls.panXY(0, this.panSpeed);
+        }
+    }
+    cameraDown() {
+        if (this._viewMode === ViewMode.WalkThrough) {
+            this.controls.cameraBackward();
+        }
+        else {
+            this.controls.panXY(0, -this.panSpeed);
+        }
+    }
+    cameraZoomIn() {
+        this.controls.dollyIn(1.1);
+        this.controls.update();
+    }
+    cameraZoomOut() {
+        this.controls.dollyOut(1.1);
+        this.controls.update();
+    }
+    centerCamera(pan, distance) {
+        if (this._cameraLocked) {
+            return;
+        }
+        const offset = this._getCameraOffset(pan, distance);
+        if (pan && offset) {
+            this.controls.target = pan;
+            this.camera.position.copy(offset);
+        }
+        this.controls.update();
+    }
+    lockCamera() {
+        this._cameraLocked = true;
+    }
+    unlockCamera() {
+        this._cameraLocked = false;
+    }
+    disableRotate() {
+        this.controls.noRotate = true;
+    }
+    disableRotateHorizontal() {
+        this.controls.noRotateHorizontal = true;
+    }
+    disableRotateVertical() {
+        this.controls.noRotateVertical = true;
+    }
+    disablePan() {
+        this.controls.noPan = true;
+    }
+    disableZoom() {
+        this.controls.noZoom = true;
+    }
+    getView() {
+        return {
+            position: this.camera.position,
+            pan: this.controls.getPan(),
+            target: this.controls.target,
+            explore: this.controls.exploreMode
+        };
+    }
+    projectVector(vec3, ignoreMargin = false) {
+        const widthHalf = this._element.clientWidth / 2;
+        const heightHalf = this._element.clientHeight / 2;
+        const vector = new Vector3();
+        vector.copy(vec3);
+        vector.project(this.camera);
+        const vec2 = new Vector2();
+        vec2.x = (vector.x * widthHalf) + widthHalf;
+        vec2.y = -(vector.y * heightHalf) + heightHalf;
+        ignoreMargin = ignoreMargin ? ignoreMargin : false;
+        if (!ignoreMargin) {
+            const widthMargin = this._element.offsetLeft;
+            const heightMargin = this._element.offsetTop;
+            vec2.x += widthMargin;
+            vec2.y += heightMargin;
+        }
+        return vec2;
+    }
+    setView(data) {
+        if (this._cameraLocked) {
+            return;
+        }
+        this.camera.position.copy(data.position);
+        this.controls.target.copy(data.target);
+        this.controls.setExploreMode(data.explore);
+        this.controls.panTo(this.controls.target.clone());
+        this.cameraMovementChanged.next();
+    }
+    moveCameraToFitObject(object, offset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!object) {
+                return;
+            }
+            offset = offset || 1.15;
+            // get bounding box of object - this will be used to setup controls and camera
+            const boundingBox = new Box3();
+            boundingBox.setFromObject(object);
+            const center = new Vector3();
+            boundingBox.getCenter(center);
+            const size = new Vector3();
+            boundingBox.getSize(size);
+            // get the max side of the bounding box (fits to width OR height as needed )
+            const maxDim = Math.max(size.x, size.y, size.z);
+            const fov = this.camera.fov * (Math.PI / 180);
+            // let cameraZ = Math.abs(maxDim / 4 * Math.tan(fov * 200));
+            let cameraZ = Math.abs((maxDim / 2) / Math.tan(fov / 2));
+            cameraZ *= offset; // zoom out a little so that objects don't fill the screen
+            const newPosition = new Vector3(0, size.y * 1.25, cameraZ);
+            // this.camera.position.y = size.y * 1.25;
+            // this.camera.position.z = cameraZ;
+            // this.camera.lookAt(center);
+            // if (this.controls) {
+            //   // set camera to rotate around center of loaded object
+            //   this.controls.target = center;
+            // }
+            const tween = yield this.controls.animateCameraMovement(newPosition, center, 2000);
+        });
+    }
+    mouseTo3DPosition(vec2) {
+        const mPosition = new Vector2((vec2.x / (this._element ? this._element.clientWidth : 1)) * 2 - 1, -(vec2.y / (this._element ? this._element.clientHeight : 1)) * 2 + 1);
+        const vector = new Vector3(mPosition.x, mPosition.y, 0.5);
+        vector.unproject(this.camera);
+        return vector;
+    }
+    _animateTopView() {
+        const max = Math.max(this._viewSize.x, this._viewSize.z);
+        const target = this._viewCenter.setY(max / 2);
+        const cameraPosition = target.clone().setY(max * 2).setZ(this._viewCenter.z + 0.1);
+        return this.controls.animateCameraMovement(cameraPosition, target);
+    }
+    _animateWalkThrough() {
+        if (this.cameraLocked) {
+            return;
+        }
+        const startPoint = this._viewModeService.walkThroughCameraStartPoint;
+        if (startPoint) {
+            this._placeWalkThroughCameraAtStartPoint(startPoint[0], startPoint[1]);
+        }
+        else {
+            this._placeWalkThroughCameraInCorner(this._viewModeService.viewCorner);
+        }
+    }
+    _animate3D() {
+        if (this.cameraLocked) {
+            return;
+        }
+        if (Number.isFinite(this._exploreTargetDistance)) {
+            this.controls.target = this.camera.position.clone().lerp(this.controls.target, this._exploreTargetDistance);
+        }
+        this.controls.update();
+        const target = this._viewCenter;
+        const distance = this._viewSize.z * 1.5;
+        const offset = target.clone().add(new Vector3(0, distance, distance));
+        return this.controls.animateCameraMovement(offset, target);
+    }
+    _getCameraOffset(target, distance) {
+        const targetDistance = distance * 1.5;
+        return target.clone().add(new Vector3(0, targetDistance, targetDistance));
+    }
+    _placeWalkThroughCameraInCorner(viewCorner) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const center2d = this._viewCenter;
+            const center = new Vector3(center2d.x, this.cameraDefaultHeight, center2d.y);
+            // place in a corner to have a better view
+            const corner2d = viewCorner;
+            const corner = new Vector3(corner2d.x, this.cameraDefaultHeight, corner2d.y);
+            const distance = corner.distanceTo(center);
+            const diff = (distance - this.targetDefaultOffset) / distance;
+            const lerpAlpha = this.exploreDistanceFromCorner / distance;
+            const nearCorner = corner.clone().lerp(center, lerpAlpha < 1 ? lerpAlpha : 0.1);
+            this._exploreTargetDistance = nearCorner.distanceTo(center);
+            const tween = yield this.controls.animateCameraMovement(nearCorner, center);
+            this.controls.target = nearCorner.clone().lerp(center, 1 - diff);
+            this.controls.update();
+        });
+    }
+    _placeWalkThroughCameraAtStartPoint(position, rotation) {
+        const cameraPosition = position.setY(this.cameraDefaultHeight);
+        const cameraRotationY = rotation.y;
+        const diff = new Vector3(0, 0, this.targetDefaultOffset);
+        const endTarget = cameraPosition.clone().add(diff.applyAxisAngle(new Vector3(0, 1, 0), cameraRotationY));
+        this.controls.animateCameraMovement(cameraPosition, endTarget);
+        this.controls.update();
+    }
+    _controlsUpdate() {
+        this.cameraMovementChanged.next();
+    }
+    _turnOnExploreMode() {
+        if (this.camera && this.controls) {
+            this.controls.setExploreMode(true);
+            this._walkThroughCameraSettingsChanged();
+        }
+    }
+    _turnOffExploreMode() {
+        if (this.camera && this.controls) {
+            this.controls.setExploreMode(false);
+            this._updateCameraSettings();
+        }
+    }
+    _turnOnTopViewMode() {
+        if (this.controls) {
+            this.controls.setBirdsEyeMode(true);
+        }
+    }
+    _turnOffTopViewMode() {
+        if (this.controls) {
+            this.controls.setBirdsEyeMode(false);
+        }
+    }
+    _walkThroughCameraSettingsChanged() {
+        /*
+        this._updateCameraSettings(
+          this._configurationService.getValue(ConfigurationKey.WalkThroughCameraFoV),
+          this._configurationService.getValue(ConfigurationKey.WalkThroughCameraAspectRatio),
+          this._configurationService.getValue(ConfigurationKey.WalkThroughCameraFocus)
+        );
+        */
+    }
+    _updateCameraSettings(fov, aspect, focus) {
+        this.camera.fov = fov ? fov : DEFAULT_CAMERA_FOV;
+        this.camera.aspect = this._aspectRatio ? this._aspectRatio : DEFAULT_CAMERA_ASPECT_RATIO;
+        this.camera.focus = focus ? focus : DEFAULT_CAMERA_FOCUS;
+        this.camera.updateProjectionMatrix();
+    }
+}
+CameraService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CameraService, deps: [{ token: i1.ViewModeService }, { token: i2.MessageBusService }, { token: i3.ConfigurationService }], target: i0.ɵɵFactoryTarget.Injectable });
+CameraService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CameraService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CameraService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ViewModeService }, { type: i2.MessageBusService }, { type: i3.ConfigurationService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"camera.service.js","sourceRoot":"","sources":["../../../../../../../src/client/app/plugins/core3d/service/camera.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\r\nimport {Box3, Euler, PerspectiveCamera, Vector2, Vector3} from 'three';\r\nimport {Subject, Subscription} from 'rxjs';\r\nimport {Controls} from './controls';\r\nimport * as TWEEN from '@tweenjs/tween.js';\r\nimport {ViewMode} from '../../../core/enum/view-mode.enum';\r\nimport {ViewModeService} from '../../../core/service/view-mode.service';\r\nimport {MessageBusService} from '../../../core/service/message-bus.service';\r\nimport {ConfigurationService} from '../../../core/service/configuration.service';\r\nimport {MessageType} from '../../../core/enum/message-type.enum';\r\nimport * as THREE from 'three';\r\n\r\nconst DEFAULT_CAMERA_ASPECT_RATIO: number = 1;\r\nconst DEFAULT_CAMERA_FOV: number = 45;\r\nconst DEFAULT_CAMERA_FOCUS: number = 10;\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class CameraService implements OnDestroy {\r\n\r\n  public readonly panSpeed = 30;\r\n  public readonly rotateBy = Math.PI / 32;\r\n  public readonly moveBy = 25;\r\n  public readonly cameraDefaultHeight = 1.7;\r\n  public readonly targetDefaultOffset = 1;\r\n  public readonly exploreDistanceFromCorner = 0.8;\r\n\r\n  public camera: PerspectiveCamera;\r\n  public controls: any;\r\n  public cameraMovementChanged: Subject<void> = new Subject();\r\n\r\n  private _cameraLocked: boolean = false;\r\n  private _element: HTMLElement;\r\n  private _viewSize: Vector3;\r\n  private _viewCenter: Vector3;\r\n  private _exploreTargetDistance: number;\r\n  private _realAspectRatio: number = DEFAULT_CAMERA_ASPECT_RATIO;\r\n  private _aspectRatio: number = window.innerWidth / window.innerHeight;\r\n  private _viewMode: ViewMode;\r\n  private _subs: Subscription[] = [];\r\n\r\n  private set viewMode(value: ViewMode) {\r\n    const shouldMoveCamera: boolean = !!this._viewMode;\r\n    this._viewMode = value;\r\n    if (shouldMoveCamera) {\r\n      this._turnOffExploreMode();\r\n      this._turnOffTopViewMode();\r\n      switch (this._viewMode) {\r\n        case ViewMode.TopView:\r\n          this._turnOnTopViewMode();\r\n          this._animateTopView();\r\n          break;\r\n        case ViewMode.WalkThrough:\r\n          this._turnOnExploreMode();\r\n          this._animateWalkThrough();\r\n          break;\r\n        case ViewMode.RoomPlan3D:\r\n          this._animate3D();\r\n          break;\r\n      }\r\n    }\r\n  }\r\n\r\n  get cameraLocked(): boolean {\r\n    return this._cameraLocked;\r\n  }\r\n\r\n  set realAspectRatio(value: number) {\r\n    this._realAspectRatio = value;\r\n  }\r\n\r\n  constructor(\r\n    private _viewModeService: ViewModeService,\r\n    private _messageBusService: MessageBusService,\r\n    private _configurationService: ConfigurationService\r\n  ) {\r\n    this._subs.push(\r\n      this._viewModeService.viewModeChanged.subscribe((mode: ViewMode) => {\r\n        this._viewSize = this._viewModeService.viewSize;\r\n        this._viewCenter = this._viewModeService.viewCenter;\r\n        this.viewMode = mode;\r\n      }),\r\n      _messageBusService.subscribe(MessageType.WalkThroughCameraSettingsChanged, () => this._walkThroughCameraSettingsChanged())\r\n    );\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this._subs.forEach(s => s.unsubscribe());\r\n    this.controls.removeEventListener('change', () => this._controlsUpdate());\r\n    this._element = undefined;\r\n  }\r\n\r\n  public init(element: HTMLElement): void {\r\n    this._element = element;\r\n    this.camera = new PerspectiveCamera(45, 1, 0.01, 100);\r\n    this.camera.position.set(0, 3, 1.5);\r\n    this.camera.aspect = window.innerWidth / window.innerHeight;\r\n    this.camera.updateProjectionMatrix();\r\n    this.controls = new Controls(this.camera, this._element);\r\n    this.controls.addEventListener('change', () => this._controlsUpdate());\r\n    this.controls.update();\r\n  }\r\n\r\n  public cameraLeft(): void {\r\n    if (this._viewMode === ViewMode.WalkThrough) {\r\n      this.controls.cameraLeft();\r\n    } else {\r\n      this.controls.panXY(this.panSpeed, 0);\r\n    }\r\n  }\r\n\r\n  public cameraRight(): void {\r\n    if (this._viewMode === ViewMode.WalkThrough) {\r\n      this.controls.cameraRight();\r\n    } else {\r\n      this.controls.panXY(-this.panSpeed, 0);\r\n    }\r\n  }\r\n\r\n  public cameraUp(): void {\r\n    if (this._viewMode === ViewMode.WalkThrough) {\r\n      this.controls.cameraForward();\r\n    } else {\r\n      this.controls.panXY(0, this.panSpeed);\r\n    }\r\n  }\r\n\r\n  public cameraDown(): void {\r\n    if (this._viewMode === ViewMode.WalkThrough) {\r\n      this.controls.cameraBackward();\r\n    } else {\r\n      this.controls.panXY(0, -this.panSpeed);\r\n    }\r\n  }\r\n\r\n  public cameraZoomIn(): void {\r\n    this.controls.dollyIn(1.1);\r\n    this.controls.update();\r\n  }\r\n\r\n  public cameraZoomOut(): void {\r\n    this.controls.dollyOut(1.1);\r\n    this.controls.update();\r\n  }\r\n\r\n  public centerCamera(pan: Vector3, distance: number): void {\r\n    if (this._cameraLocked) {\r\n      return;\r\n    }\r\n    const offset = this._getCameraOffset(pan, distance);\r\n    if (pan && offset) {\r\n      this.controls.target = pan;\r\n      this.camera.position.copy(offset);\r\n    }\r\n    this.controls.update();\r\n  }\r\n\r\n  public lockCamera(): void {\r\n    this._cameraLocked = true;\r\n  }\r\n\r\n  public unlockCamera(): void {\r\n    this._cameraLocked = false;\r\n  }\r\n\r\n  public disableRotate(): void {\r\n    this.controls.noRotate = true;\r\n  }\r\n\r\n  public disableRotateHorizontal(): void {\r\n    this.controls.noRotateHorizontal = true;\r\n  }\r\n\r\n  public disableRotateVertical(): void {\r\n    this.controls.noRotateVertical = true;\r\n  }\r\n\r\n  public disablePan(): void {\r\n    this.controls.noPan = true;\r\n  }\r\n\r\n  public disableZoom(): void {\r\n    this.controls.noZoom = true;\r\n  }\r\n\r\n  public getView(): any { // todo: fix this any\r\n    return {\r\n      position: this.camera.position,\r\n      pan: this.controls.getPan(),\r\n      target: this.controls.target,\r\n      explore: this.controls.exploreMode\r\n    };\r\n  }\r\n\r\n  public projectVector(vec3: Vector3, ignoreMargin: boolean = false): Vector2 {\r\n    const widthHalf = this._element.clientWidth / 2;\r\n    const heightHalf = this._element.clientHeight / 2;\r\n\r\n    const vector = new Vector3();\r\n    vector.copy(vec3);\r\n    vector.project(this.camera);\r\n\r\n    const vec2 = new Vector2();\r\n\r\n    vec2.x = (vector.x * widthHalf) + widthHalf;\r\n    vec2.y = -(vector.y * heightHalf) + heightHalf;\r\n\r\n    ignoreMargin = ignoreMargin ? ignoreMargin : false;\r\n    if (!ignoreMargin) {\r\n      const widthMargin = this._element.offsetLeft;\r\n      const heightMargin = this._element.offsetTop;\r\n      vec2.x += widthMargin;\r\n      vec2.y += heightMargin;\r\n    }\r\n\r\n    return vec2;\r\n  }\r\n\r\n  public setView(data: any): void {\r\n    if (this._cameraLocked) {\r\n      return;\r\n    }\r\n    this.camera.position.copy(data.position);\r\n    this.controls.target.copy(data.target);\r\n    this.controls.setExploreMode(data.explore);\r\n    this.controls.panTo(this.controls.target.clone());\r\n    this.cameraMovementChanged.next();\r\n  }\r\n\r\n  public async moveCameraToFitObject(object: any, offset?: number): Promise<void> {\r\n    if (!object) {\r\n      return;\r\n    }\r\n    offset = offset || 1.15;\r\n\r\n    // get bounding box of object - this will be used to setup controls and camera\r\n    const boundingBox = new Box3();\r\n    boundingBox.setFromObject(object);\r\n    const center: Vector3 = new Vector3();\r\n    boundingBox.getCenter(center);\r\n    const size: Vector3 = new Vector3();\r\n    boundingBox.getSize(size);\r\n\r\n    // get the max side of the bounding box (fits to width OR height as needed )\r\n    const maxDim = Math.max(size.x, size.y, size.z);\r\n\r\n    const fov: number = this.camera.fov * (Math.PI / 180);\r\n    // let cameraZ = Math.abs(maxDim / 4 * Math.tan(fov * 200));\r\n    let cameraZ = Math.abs((maxDim / 2) / Math.tan(fov / 2));\r\n    cameraZ *= offset; // zoom out a little so that objects don't fill the screen\r\n\r\n    const newPosition = new Vector3(0, size.y * 1.25, cameraZ);\r\n\r\n    // this.camera.position.y = size.y * 1.25;\r\n    // this.camera.position.z = cameraZ;\r\n    // this.camera.lookAt(center);\r\n    // if (this.controls) {\r\n    //   // set camera to rotate around center of loaded object\r\n    //   this.controls.target = center;\r\n    // }\r\n\r\n    const tween = await this.controls.animateCameraMovement(newPosition, center, 2000);\r\n  }\r\n\r\n\r\n  public mouseTo3DPosition(vec2: Vector2): Vector3 {\r\n    const mPosition = new Vector2(\r\n      (vec2.x / (this._element ? this._element.clientWidth : 1)) * 2 - 1,\r\n      -(vec2.y / (this._element ? this._element.clientHeight : 1)) * 2 + 1\r\n    );\r\n    const vector = new Vector3(mPosition.x, mPosition.y, 0.5);\r\n    vector.unproject(this.camera);\r\n    return vector;\r\n  }\r\n\r\n  private _animateTopView(): void {\r\n    const max = Math.max(this._viewSize.x, this._viewSize.z);\r\n    const target = this._viewCenter.setY(max / 2);\r\n    const cameraPosition = target.clone().setY(max * 2).setZ(this._viewCenter.z + 0.1);\r\n    return this.controls.animateCameraMovement(cameraPosition, target);\r\n  }\r\n\r\n  private _animateWalkThrough(): void {\r\n    if (this.cameraLocked) { return; }\r\n\r\n    const startPoint = this._viewModeService.walkThroughCameraStartPoint;\r\n    if (startPoint) {\r\n      this._placeWalkThroughCameraAtStartPoint(startPoint[0], startPoint[1]);\r\n    } else {\r\n      this._placeWalkThroughCameraInCorner(this._viewModeService.viewCorner);\r\n    }\r\n  }\r\n\r\n  private _animate3D(): Promise<TWEEN.Tween> {\r\n    if (this.cameraLocked) { return; }\r\n\r\n    if (Number.isFinite(this._exploreTargetDistance)) {\r\n      this.controls.target = this.camera.position.clone().lerp(this.controls.target, this._exploreTargetDistance);\r\n    }\r\n    this.controls.update();\r\n    const target = this._viewCenter;\r\n    const distance = this._viewSize.z * 1.5;\r\n    const offset = target.clone().add(new Vector3(0, distance, distance));\r\n    return this.controls.animateCameraMovement(offset, target);\r\n  }\r\n\r\n  private _getCameraOffset(target: Vector3, distance: number): Vector3 {\r\n    const targetDistance = distance * 1.5;\r\n    return target.clone().add(\r\n      new Vector3(0, targetDistance, targetDistance));\r\n  }\r\n\r\n  private async _placeWalkThroughCameraInCorner(viewCorner: Vector2): Promise<void> {\r\n    const center2d = this._viewCenter;\r\n    const center = new Vector3(center2d.x, this.cameraDefaultHeight, center2d.y);\r\n\r\n    // place in a corner to have a better view\r\n    const corner2d = viewCorner;\r\n    const corner = new Vector3(corner2d.x, this.cameraDefaultHeight, corner2d.y);\r\n    const distance = corner.distanceTo(center);\r\n    const diff = (distance - this.targetDefaultOffset) / distance;\r\n    const lerpAlpha = this.exploreDistanceFromCorner / distance;\r\n    const nearCorner = corner.clone().lerp(center, lerpAlpha < 1 ? lerpAlpha : 0.1);\r\n    this._exploreTargetDistance = nearCorner.distanceTo(center);\r\n    const tween = await this.controls.animateCameraMovement(nearCorner, center);\r\n    this.controls.target = nearCorner.clone().lerp(center, 1 - diff);\r\n    this.controls.update();\r\n  }\r\n\r\n  private _placeWalkThroughCameraAtStartPoint(position: Vector3, rotation: Euler): void {\r\n    const cameraPosition = position.setY(this.cameraDefaultHeight);\r\n    const cameraRotationY = rotation.y;\r\n    const diff = new Vector3(0, 0, this.targetDefaultOffset);\r\n    const endTarget = cameraPosition.clone().add(diff.applyAxisAngle(new Vector3(0, 1, 0), cameraRotationY));\r\n    this.controls.animateCameraMovement(cameraPosition, endTarget);\r\n    this.controls.update();\r\n  }\r\n\r\n  private _controlsUpdate(): void {\r\n    this.cameraMovementChanged.next();\r\n  }\r\n\r\n  private _turnOnExploreMode() {\r\n    if (this.camera && this.controls) {\r\n      this.controls.setExploreMode(true);\r\n      this._walkThroughCameraSettingsChanged();\r\n    }\r\n  }\r\n\r\n  private _turnOffExploreMode() {\r\n    if (this.camera && this.controls) {\r\n      this.controls.setExploreMode(false);\r\n      this._updateCameraSettings();\r\n    }\r\n  }\r\n\r\n  private _turnOnTopViewMode() {\r\n    if (this.controls) {\r\n      this.controls.setBirdsEyeMode(true);\r\n    }\r\n  }\r\n\r\n  private _turnOffTopViewMode() {\r\n    if (this.controls) {\r\n      this.controls.setBirdsEyeMode(false);\r\n    }\r\n  }\r\n\r\n  private _walkThroughCameraSettingsChanged() {\r\n    /*\r\n    this._updateCameraSettings(\r\n      this._configurationService.getValue(ConfigurationKey.WalkThroughCameraFoV),\r\n      this._configurationService.getValue(ConfigurationKey.WalkThroughCameraAspectRatio),\r\n      this._configurationService.getValue(ConfigurationKey.WalkThroughCameraFocus)\r\n    );\r\n    */\r\n  }\r\n\r\n  private _updateCameraSettings(fov?: number, aspect?: number, focus?: number) {\r\n    this.camera.fov = fov ? fov : DEFAULT_CAMERA_FOV;\r\n    this.camera.aspect = this._aspectRatio ? this._aspectRatio : DEFAULT_CAMERA_ASPECT_RATIO;\r\n    this.camera.focus = focus ? focus : DEFAULT_CAMERA_FOCUS;\r\n    this.camera.updateProjectionMatrix();\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,104 @@
+import { Injectable } from '@angular/core';
+import { FrontSide, MeshStandardMaterial, Shape, ShapeGeometry } from 'three';
+import { ConfigurationKey } from '../../../core/enum/configuration-key.enum';
+import { ThreeMesh } from '../items/three-mesh';
+import { MaterialUtils } from '../../../core/utils/material.utils';
+import { isNill } from '../../../core/utils/function/is-nill.function';
+import { CornerUtils } from '../core/corner-utils';
+import * as i0 from "@angular/core";
+import * as i1 from "./scene.service";
+import * as i2 from "../../../core/service/configuration.service";
+export class CeilingService {
+    constructor(_sceneService, _configurationService) {
+        this._sceneService = _sceneService;
+        this._configurationService = _configurationService;
+        this._ceilings = [];
+        this._subs = [];
+        this._subs.push(this._configurationService.onChange.subscribe((changed) => {
+            if (ConfigurationKey.ShowCeiling in changed) {
+                this._showHideCeilings(changed[ConfigurationKey.ShowCeiling]);
+            }
+        }));
+    }
+    get planes() {
+        return this._ceilings;
+    }
+    ngOnDestroy() {
+        this._subs.forEach(s => s.unsubscribe());
+    }
+    removeCeilings() {
+        this._ceilings.forEach(ceiling => this._sceneService.removeObject(ceiling));
+        this._ceilings.length = 0;
+    }
+    removeCeiling(ceiling, forceRender = true) {
+        this._ceilings.splice(this._ceilings.indexOf(ceiling), 1);
+        this._sceneService.removeObject(ceiling, forceRender);
+    }
+    generateCeilingPlane(color, corners, edgeHeights, texture) {
+        // const ceilingMaterial = new MeshBasicMaterial({
+        //   side: FrontSide,
+        //   color: 0xe5e5e5
+        // });
+        const offset = 1 + this._configurationService.getValue(ConfigurationKey.WallThickness) / 100 / 2;
+        const points = CornerUtils.PolygonFromCorners(corners);
+        const shape = new Shape(points);
+        const geometry = new ShapeGeometry(shape);
+        // const extrudeSettings = { depth: 0.2, bevelEnabled: false, bevelSegments: 2, steps: 2, bevelSize: 1, bevelThickness: 1 };
+        // const geometry = new ExtrudeGeometry(shape, extrudeSettings);
+        geometry.scale(1.02, 1.02, 1);
+        // const geometry = new BoxGeometry(8, 8, 0.1);
+        const ceilingMaterial = this._createCeilingMaterial(color, texture);
+        MaterialUtils.GetMaterialMaps(ceilingMaterial, texture).then(() => {
+            ceilingMaterial.needsUpdate = true;
+            this._sceneService.needsRender = true;
+        });
+        ceilingMaterial.metalness = 0;
+        // ceilingMaterial.side = 2;
+        const ceilingPlane = new ThreeMesh(geometry, ceilingMaterial);
+        ceilingPlane.name = 'ceilingPlane-plane';
+        ceilingPlane.rotation.set(Math.PI / 2, 0, 0);
+        ceilingPlane.position.y = Math.max.apply(null, [0, ...edgeHeights]);
+        ceilingPlane.receiveShadow = false;
+        ceilingPlane.castShadow = true;
+        // const floorCenter = this._floorplanService.getCenter();
+        // ceilingPlane.position.set(floorCenter.x, Math.max.apply(null, [0, ...edgeHeights]) + 0.05, floorCenter.z);
+        this._addCeiling(ceilingPlane, false);
+        return ceilingPlane;
+    }
+    _showHideCeilings(show) {
+        this._ceilings.forEach(c => c.visible = show);
+        this._sceneService.needsRender = true;
+    }
+    _addCeiling(ceiling, forceRender = true) {
+        this._ceilings.push(ceiling);
+        this._sceneService.addObject(ceiling, forceRender);
+    }
+    _createCeilingMaterial(color, texture) {
+        const options = {
+            side: FrontSide
+        };
+        if (color) {
+            options.color = color;
+        }
+        const ceilingMaterial = new MeshStandardMaterial(options);
+        ceilingMaterial.transparent = false;
+        ceilingMaterial.polygonOffset = true;
+        ceilingMaterial.polygonOffsetFactor = 0.5;
+        ceilingMaterial.needsUpdate = true;
+        if (texture) {
+            ceilingMaterial.roughness = !isNill(texture.roughness) ? texture.roughness : 0.8;
+            ceilingMaterial.metalness = !isNill(texture.metalness) ? texture.metalness : 0;
+            ceilingMaterial.bumpScale = !isNill(texture.bumpScale) ? texture.bumpScale : 1;
+        }
+        return ceilingMaterial;
+    }
+}
+CeilingService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CeilingService, deps: [{ token: i1.SceneService }, { token: i2.ConfigurationService }], target: i0.ɵɵFactoryTarget.Injectable });
+CeilingService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CeilingService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CeilingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SceneService }, { type: i2.ConfigurationService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ceiling.service.js","sourceRoot":"","sources":["../../../../../../../src/client/app/plugins/core3d/service/ceiling.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAY,MAAM,eAAe,CAAC;AACpD,OAAO,EAAQ,SAAS,EAAQ,oBAAoB,EAAE,KAAK,EAAE,aAAa,EAAC,MAAM,OAAO,CAAC;AAKzF,OAAO,EAAC,gBAAgB,EAAC,MAAM,2CAA2C,CAAC;AAG3E,OAAO,EAAC,SAAS,EAAC,MAAM,qBAAqB,CAAC;AAC9C,OAAO,EAAC,aAAa,EAAC,MAAM,oCAAoC,CAAC;AACjE,OAAO,EAAC,MAAM,EAAC,MAAM,+CAA+C,CAAC;AACrE,OAAO,EAAC,WAAW,EAAC,MAAM,sBAAsB,CAAC;;;;AAKjD,MAAM,OAAO,cAAc;IASzB,YACU,aAA2B,EAC3B,qBAA2C;QAD3C,kBAAa,GAAb,aAAa,CAAc;QAC3B,0BAAqB,GAArB,qBAAqB,CAAsB;QAL7C,cAAS,GAAW,EAAE,CAAC;QACvB,UAAK,GAAmB,EAAE,CAAC;QAMjC,IAAI,CAAC,KAAK,CAAC,IAAI,CACb,IAAI,CAAC,qBAAqB,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,OAA0B,EAAE,EAAE;YAC3E,IAAI,gBAAgB,CAAC,WAAW,IAAI,OAAO,EAAE;gBAC3C,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,gBAAgB,CAAC,WAAW,CAAC,CAAC,CAAC;aAC/D;QACH,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAlBD,IAAW,MAAM;QACf,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAkBD,WAAW;QACT,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC;IAC3C,CAAC;IAEM,cAAc;QACnB,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC;QAC5E,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC;IAC5B,CAAC;IAEM,aAAa,CAAC,OAAa,EAAE,cAAuB,IAAI;QAC7D,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC;QAC1D,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;IACxD,CAAC;IAEM,oBAAoB,CAAC,KAA8B,EAAE,OAAiB,EAAE,WAAkB,EAAE,OAAiB;QAClH,kDAAkD;QAClD,qBAAqB;QACrB,oBAAoB;QACpB,MAAM;QACN,MAAM,MAAM,GAAW,CAAC,GAAG,IAAI,CAAC,qBAAqB,CAAC,QAAQ,CAAC,gBAAgB,CAAC,aAAa,CAAC,GAAG,GAAG,GAAG,CAAC,CAAC;QAEzG,MAAM,MAAM,GAAG,WAAW,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC;QACvD,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC,MAAM,CAAC,CAAC;QAChC,MAAM,QAAQ,GAAG,IAAI,aAAa,CAAC,KAAK,CAAC,CAAC;QAC1C,4HAA4H;QAC5H,gEAAgE;QAChE,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;QAC9B,+CAA+C;QAE/C,MAAM,eAAe,GAAG,IAAI,CAAC,sBAAsB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACpE,aAAa,CAAC,eAAe,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE;YAChE,eAAe,CAAC,WAAW,GAAG,IAAI,CAAC;YACnC,IAAI,CAAC,aAAa,CAAC,WAAW,GAAG,IAAI,CAAC;QACxC,CAAC,CAAC,CAAC;QACH,eAAe,CAAC,SAAS,GAAG,CAAC,CAAC;QAC9B,4BAA4B;QAC5B,MAAM,YAAY,GAAS,IAAI,SAAS,CAAC,QAAQ,EAAE,eAAe,CAAC,CAAC;QACpE,YAAY,CAAC,IAAI,GAAG,oBAAoB,CAAC;QACzC,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QAC7C,YAAY,CAAC,QAAQ,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,GAAG,WAAW,CAAC,CAAC,CAAC;QACpE,YAAY,CAAC,aAAa,GAAG,KAAK,CAAC;QACnC,YAAY,CAAC,UAAU,GAAG,IAAI,CAAC;QAC/B,0DAA0D;QAC1D,6GAA6G;QAC7G,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;QACtC,OAAO,YAAY,CAAC;IACtB,CAAC;IAEO,iBAAiB,CAAC,IAAa;QACrC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC;QAC9C,IAAI,CAAC,aAAa,CAAC,WAAW,GAAG,IAAI,CAAC;IACxC,CAAC;IAEO,WAAW,CAAC,OAAa,EAAE,cAAuB,IAAI;QAC5D,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC7B,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;IACrD,CAAC;IAEO,sBAAsB,CAAC,KAA8B,EAAE,OAAiB;QAC9E,MAAM,OAAO,GAAQ;YACnB,IAAI,EAAE,SAAS;SAChB,CAAC;QACF,IAAI,KAAK,EAAE;YACT,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC;SACvB;QAED,MAAM,eAAe,GAAG,IAAI,oBAAoB,CAAC,OAAO,CAAC,CAAC;QAC1D,eAAe,CAAC,WAAW,GAAG,KAAK,CAAC;QACpC,eAAe,CAAC,aAAa,GAAG,IAAI,CAAC;QACrC,eAAe,CAAC,mBAAmB,GAAG,GAAG,CAAC;QAC1C,eAAe,CAAC,WAAW,GAAG,IAAI,CAAC;QACnC,IAAI,OAAO,EAAE;YACX,eAAe,CAAC,SAAS,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC;YACjF,eAAe,CAAC,SAAS,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;YAC/E,eAAe,CAAC,SAAS,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;SAChF;QACD,OAAO,eAAe,CAAC;IACzB,CAAC;;4GAnGU,cAAc;gHAAd,cAAc,cAFb,MAAM;4FAEP,cAAc;kBAH1B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\r\nimport {Color, FrontSide, Mesh, MeshStandardMaterial, Shape, ShapeGeometry} from 'three';\r\nimport {Subscription} from 'rxjs';\r\nimport {SceneService} from './scene.service';\r\nimport {ConfigurationService} from '../../../core/service/configuration.service';\r\nimport {ConfigurationData} from '../../../core/interface/configuration-data.interface';\r\nimport {ConfigurationKey} from '../../../core/enum/configuration-key.enum';\r\nimport {Corner} from '../items/wall-objects';\r\nimport {Texture} from '../../../core/model/texture';\r\nimport {ThreeMesh} from '../items/three-mesh';\r\nimport {MaterialUtils} from '../../../core/utils/material.utils';\r\nimport {isNill} from '../../../core/utils/function/is-nill.function';\r\nimport {CornerUtils} from '../core/corner-utils';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class CeilingService implements OnDestroy {\r\n\r\n  public get planes(): Mesh[] {\r\n    return this._ceilings;\r\n  }\r\n\r\n  private _ceilings: Mesh[] = [];\r\n  private _subs: Subscription[] = [];\r\n\r\n  constructor(\r\n    private _sceneService: SceneService,\r\n    private _configurationService: ConfigurationService\r\n  ) {\r\n    this._subs.push(\r\n      this._configurationService.onChange.subscribe((changed: ConfigurationData) => {\r\n        if (ConfigurationKey.ShowCeiling in changed) {\r\n          this._showHideCeilings(changed[ConfigurationKey.ShowCeiling]);\r\n        }\r\n      })\r\n    );\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this._subs.forEach(s => s.unsubscribe());\r\n  }\r\n\r\n  public removeCeilings(): void {\r\n    this._ceilings.forEach(ceiling => this._sceneService.removeObject(ceiling));\r\n    this._ceilings.length = 0;\r\n  }\r\n\r\n  public removeCeiling(ceiling: Mesh, forceRender: boolean = true): void {\r\n    this._ceilings.splice(this._ceilings.indexOf(ceiling), 1);\r\n    this._sceneService.removeObject(ceiling, forceRender);\r\n  }\r\n\r\n  public generateCeilingPlane(color: Color | string | number, corners: Corner[], edgeHeights: any[], texture?: Texture): ThreeMesh {\r\n    // const ceilingMaterial = new MeshBasicMaterial({\r\n    //   side: FrontSide,\r\n    //   color: 0xe5e5e5\r\n    // });\r\n    const offset: number = 1 + this._configurationService.getValue(ConfigurationKey.WallThickness) / 100 / 2;\r\n\r\n    const points = CornerUtils.PolygonFromCorners(corners);\r\n    const shape = new Shape(points);\r\n    const geometry = new ShapeGeometry(shape);\r\n    // const extrudeSettings = { depth: 0.2, bevelEnabled: false, bevelSegments: 2, steps: 2, bevelSize: 1, bevelThickness: 1 };\r\n    // const geometry = new ExtrudeGeometry(shape, extrudeSettings);\r\n    geometry.scale(1.02, 1.02, 1);\r\n    // const geometry = new BoxGeometry(8, 8, 0.1);\r\n\r\n    const ceilingMaterial = this._createCeilingMaterial(color, texture);\r\n    MaterialUtils.GetMaterialMaps(ceilingMaterial, texture).then(() => {\r\n      ceilingMaterial.needsUpdate = true;\r\n      this._sceneService.needsRender = true;\r\n    });\r\n    ceilingMaterial.metalness = 0;\r\n    // ceilingMaterial.side = 2;\r\n    const ceilingPlane: Mesh = new ThreeMesh(geometry, ceilingMaterial);\r\n    ceilingPlane.name = 'ceilingPlane-plane';\r\n    ceilingPlane.rotation.set(Math.PI / 2, 0, 0);\r\n    ceilingPlane.position.y = Math.max.apply(null, [0, ...edgeHeights]);\r\n    ceilingPlane.receiveShadow = false;\r\n    ceilingPlane.castShadow = true;\r\n    // const floorCenter = this._floorplanService.getCenter();\r\n    // ceilingPlane.position.set(floorCenter.x, Math.max.apply(null, [0, ...edgeHeights]) + 0.05, floorCenter.z);\r\n    this._addCeiling(ceilingPlane, false);\r\n    return ceilingPlane;\r\n  }\r\n\r\n  private _showHideCeilings(show: boolean): void {\r\n    this._ceilings.forEach(c => c.visible = show);\r\n    this._sceneService.needsRender = true;\r\n  }\r\n\r\n  private _addCeiling(ceiling: Mesh, forceRender: boolean = true): void {\r\n    this._ceilings.push(ceiling);\r\n    this._sceneService.addObject(ceiling, forceRender);\r\n  }\r\n\r\n  private _createCeilingMaterial(color: Color | string | number, texture?: Texture): MeshStandardMaterial {\r\n    const options: any = {\r\n      side: FrontSide\r\n    };\r\n    if (color) {\r\n      options.color = color;\r\n    }\r\n\r\n    const ceilingMaterial = new MeshStandardMaterial(options);\r\n    ceilingMaterial.transparent = false;\r\n    ceilingMaterial.polygonOffset = true;\r\n    ceilingMaterial.polygonOffsetFactor = 0.5;\r\n    ceilingMaterial.needsUpdate = true;\r\n    if (texture) {\r\n      ceilingMaterial.roughness = !isNill(texture.roughness) ? texture.roughness : 0.8;\r\n      ceilingMaterial.metalness = !isNill(texture.metalness) ? texture.metalness : 0;\r\n      ceilingMaterial.bumpScale = !isNill(texture.bumpScale) ? texture.bumpScale : 1;\r\n    }\r\n    return ceilingMaterial;\r\n  }\r\n\r\n}\r\n"]}