@colijnit/homedecorator 255.1.1

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

@@ -0,0 +1,397 @@
+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 WebXRPolyfill from 'webxr-polyfill';
+import { Injectable } from '@angular/core';
+import * as THREE from 'three';
+import { CylinderGeometry, Mesh, MeshStandardMaterial, Object3D, Vector3 } from 'three';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { XrMode } from '../../../core/enum/xr-mode.enum';
+import { isNill } from '../../../core/utils/function/is-nill.function';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../core/service/homedecorator-settings.service";
+import * as i2 from "../../../core/service/debug.service";
+import * as i3 from "./message-board.service";
+export class XrService {
+    constructor(_settingsService, _debugService, _messageBoard) {
+        this._settingsService = _settingsService;
+        this._debugService = _debugService;
+        this._messageBoard = _messageBoard;
+        this.axes = [0, 0];
+        this.touchpadIsPressed = false;
+        this.triggerIsPressed = false;
+        this.angularVelocity = new Vector3();
+        this.vrSupported = false;
+        this.arSupported = false;
+        this.sessionStarted = new Subject();
+        this.sessionEnded = new Subject();
+        this.userSelectInAr = new BehaviorSubject(undefined);
+        this._subs = [];
+        this._mode = XrMode.VrMode;
+    }
+    ngOnDestroy() {
+        this._subs.forEach(s => s.unsubscribe());
+    }
+    init(renderer, scene, camera) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._settingsService.settings.options.vrEnabled && !this._settingsService.settings.options.arEnabled) {
+                return;
+            }
+            this.renderer = renderer;
+            this.scene = scene;
+            this.scene.onBeforeRender =
+                (brRenderer, brScene, brCamera, brTarget) => this._doBeforeRenderScene(brRenderer, brScene, brCamera, brTarget);
+            this.camera = camera;
+            yield this._messageBoard.init(this.scene);
+            // this._createController();
+            this._logMessage('Starting XR');
+            // const polyfill = new WebXRPolyfill();
+            if (navigator.xr && !isNill(navigator.xr) && navigator.xr.isSessionSupported) {
+                this._logMessage('Checking support');
+                if (this._settingsService.settings.options.vrEnabled) {
+                    navigator.xr.isSessionSupported('immersive-vr')
+                        .then((supported) => {
+                        if (supported) {
+                            this._logMessage('Session for VR supported!');
+                            this.vrSupported = true;
+                        }
+                        else {
+                            this._logMessage('VR not supported!');
+                            this.vrSupported = false;
+                        }
+                    })
+                        .catch((e) => {
+                        this._logMessage(e.message);
+                    });
+                }
+                if (this._settingsService.settings.options.arEnabled) {
+                    navigator.xr.isSessionSupported('immersive-ar')
+                        .then((supported) => {
+                        if (supported) {
+                            this._logMessage('Session for AR supported!');
+                            this.arSupported = true;
+                        }
+                        else {
+                            this._logMessage('AR not supported!');
+                            this.arSupported = false;
+                            this._settingsService.settings.options.showArButton = false;
+                        }
+                    })
+                        .catch((e) => {
+                        this._logMessage(e.message);
+                    });
+                }
+            }
+            else {
+                if ('getVRDisplays' in navigator) {
+                    this._logMessage('getVRDisplays');
+                    const displays = yield navigator.getVRDisplays();
+                    if (displays.length > 0) {
+                        this._vrDisplay = displays[0];
+                        this._logMessage(this._vrDisplay.displayName);
+                        this.vrSupported = true;
+                        window.addEventListener('vrdisplaypresentchange', () => {
+                            if (!this._vrDisplay.isPresenting) {
+                                this.sessionEnded.next();
+                            }
+                        });
+                    }
+                    else {
+                        this._logMessage('No VR display found!');
+                        this.vrSupported = false;
+                    }
+                }
+            }
+            // if ('getVRDisplays' in navigator) {
+            //   this._debugService.addMessage('getVRDisplays');
+            // }
+            // if ('xr' in navigator && (navigator as any).xr !== null && 'requestDevice' in (navigator as any).xr) {
+            //   this._debugService.addMessage('Getting device');
+            //
+            //   (navigator as any).xr.requestDevice().then((device) => {
+            //
+            //     device.supportsSession({immersive: true, exclusive: true /* DEPRECATED */})
+            //       .then(() => {
+            //         this._debugService.addMessage('Device found!');
+            //         this.vrDevice = device;
+            //         this.vrSupported = true;
+            //       })
+            //       .catch((e) => {
+            //         this._debugService.addMessage(e.message);
+            //       });
+            //
+            //   }).catch((e) => {
+            //     this.vrSupported = false;
+            //     this._debugService.addMessage(e.message);
+            //   });
+            //
+            //
+            //   // (navigator as any).xr.supportsSession( 'immersive-vr' )
+            //   //   .then(() => {
+            //   //     this._debugService.addMessage('goedzo');
+            //   //   })
+            //   //   .catch((e) => {
+            //   //     this._debugService.addMessage(e.message);
+            //   //   });
+            //   return;
+            //
+            // } else if ('getVRDisplays' in navigator) {
+            //   this._debugService.addMessage('getVRDisplays');
+            //
+            //   window.addEventListener('vrdisplayconnect', (event) => {
+            //
+            //     console.log((event as any).display);
+            //
+            //   }, false);
+            //
+            //   window.addEventListener('vrdisplaydisconnect', ( /*event*/) => {
+            //
+            //     console.log('disconnected');
+            //
+            //   }, false);
+            //
+            //   window.addEventListener('vrdisplaypresentchange', (event) => {
+            //
+            //     console.log((event as any).display.isPresenting ? 'EXIT VR' : 'ENTER VR');
+            //
+            //   }, false);
+            //
+            //   window.addEventListener('vrdisplayactivate', (event) => {
+            //
+            //     (event as any).display.requestPresent([{source: this.renderer.domElement}]);
+            //
+            //   }, false);
+            //
+            //   navigator.getVRDisplays()
+            //     .then((displays) => {
+            //
+            //       if (displays.length > 0) {
+            //         this._debugService.addMessage(displays[0].displayName);
+            //       } else {
+            //         this._debugService.addMessage('VR not found');
+            //       }
+            //     }).catch((e) => this._debugService.addMessage(e.message));
+            //   return;
+            // } else {
+            //   this._debugService.addMessage('WebVR not supported');
+            //   //
+            //   // var message = document.createElement( 'a' );
+            //   // message.href = 'https://webvr.info';
+            //   // message.innerHTML = 'WEBVR NOT SUPPORTED';
+            //   //
+            //   // message.style.left = 'calc(50% - 90px)';
+            //   // message.style.width = '180px';
+            //   // message.style.textDecoration = 'none';
+            //   //
+            //   // stylizeElement( message );
+            //
+            //   return;
+            //
+            // }
+        });
+    }
+    startAr() {
+        this._mode = XrMode.ArMode;
+        this.renderer.xr.enabled = true;
+        this.renderer.setClearColor(0x000000, 0);
+        this.renderer.autoClear = false;
+        if (isNill(this.session)) {
+            const features = { requiredFeatures: ['local', 'hit-test'] };
+            navigator.xr.requestSession('immersive-ar', features).then((session) => {
+                this.renderer.xr.setReferenceSpaceType('local');
+                session.updateWorldTrackingState({ planeDetectionState: { enabled: true } });
+                session.requestReferenceSpace('viewer').then((refSpace) => {
+                    this.viewerSpace = refSpace;
+                    session.requestHitTestSource({ space: this.viewerSpace }).then((hitTestSource) => {
+                        this.hitTestSource = hitTestSource;
+                    });
+                });
+                session.requestReferenceSpace('local').then((refSpace) => {
+                    this.refSpace = refSpace;
+                    this._onSessionStarted(session);
+                });
+            });
+        }
+        else {
+            this.session.end();
+        }
+    }
+    stopAr() {
+        if (!isNill(this.session)) {
+            this.session.end();
+        }
+        if (this.renderer) {
+            this.renderer.xr.enabled = false;
+            this.renderer.setClearColor(0xfafafa);
+            this.renderer.autoClear = true;
+        }
+    }
+    startVr() {
+        if (this.vrSupported) {
+            this._mode = XrMode.VrMode;
+            this.renderer.xr.enabled = true;
+            if (isNill(this.session)) {
+                // Setting reference spaceType
+                this.renderer.xr.setReferenceSpaceType('local-floor');
+                // Initializing session
+                const sessionInit = { optionalFeatures: 'local-floor' };
+                navigator.xr.requestSession('immersive-vr', sessionInit).then((session) => {
+                    // Creating offset to compensate for shit scale
+                    // this._logMessage('Creating offset for VR reference space');
+                    // session.requestReferenceSpace('local-floor').then((refSpace) => {
+                    //   this.refSpace = refSpace.getOffsetReferenceSpace(
+                    //     new XRRigidTransform(new DOMPoint(0, 160, 0)));
+                    // });
+                    // Start session
+                    this._onSessionStarted(session);
+                });
+            }
+            else {
+                this.session.end();
+            }
+        }
+    }
+    stopVr() {
+        if (!isNill(this.session)) {
+            this.session.end();
+        }
+        if (this.renderer) {
+            this.renderer.xr.enabled = false;
+            // this.renderer.vr.setDevice(null);
+        }
+        if (this.camera && this._cameraHeight) {
+            this.camera.position.y = this._cameraHeight;
+        }
+    }
+    update() {
+        // this._updateController();
+    }
+    _doBeforeRenderScene(renderer, scene, camera, target) {
+        if (this.renderer.xr.enabled && this._mode === XrMode.VrMode) {
+        }
+    }
+    _logMessage(message) {
+        this._debugService.addMessage(message);
+        this._messageBoard.addMessage(message);
+    }
+    _onSessionStarted(session) {
+        this.session = session;
+        this.session.addEventListener('end', () => this._onSessionEnded());
+        this.session.addEventListener('select', () => this._onUserSelect());
+        this.renderer.xr.setSession(this.session);
+        this.sessionStarted.next(this._mode);
+    }
+    _onUserSelect() {
+        this.userSelectInAr.next(true);
+    }
+    _onSessionEnded() {
+        if (!isNill(this.session)) {
+            this.session.removeEventListener('select', () => this._onUserSelect());
+            this.session.removeEventListener('end', () => this._onSessionEnded());
+            this.session = null;
+            this.sessionEnded.next();
+        }
+    }
+    _updateController() {
+        if (!this._vrController) {
+            return;
+        }
+        this.gamepad = this._findGamepad();
+        if (this.gamepad !== undefined && this.gamepad.pose !== undefined) {
+            const pose = this.gamepad.pose;
+            if (pose === null) {
+                return; // no user action yet
+            }
+            //  orientation
+            if (pose.orientation !== null) {
+                this._vrController.quaternion.fromArray(pose.orientation);
+            }
+            this._vrController.updateMatrix();
+            this._vrController.visible = true;
+            try {
+                const direction = new Vector3().applyEuler(this._vrController.rotation);
+                const raycaster = new THREE.Raycaster(this._vrController.position, direction);
+                const intersections = raycaster.intersectObjects(this.scene.children, true);
+                if (intersections.length) {
+                    // this.controller.setMousePosition(Scene3DUtil.Convert3DPointToScreenPoint(
+                    //   intersections[0].point,
+                    //   this.camera,
+                    //   this.controller.getElement().clientWidth,
+                    //   this.controller.getElement().clientHeight));
+                    // this.controller.doMouseMove();
+                }
+            }
+            catch (e) {
+                this._logMessage(e.message);
+            }
+            // angular velocity
+            if (pose.angularVelocity !== null && !this.angularVelocity.equals(pose.angularVelocity)) {
+                this.angularVelocity.fromArray(pose.angularVelocity);
+                // this.dispatchEvent({type: 'angularvelocitychanged', angularVelocity: this.angularVelocity});
+            }
+            // axes (touchpad)
+            if (this.axes[0] !== this.gamepad.axes[0] || this.axes[1] !== this.gamepad.axes[1]) {
+                this.axes[0] = this.gamepad.axes[0];
+                this.axes[1] = this.gamepad.axes[1];
+                // this._logMessage('axes moved');
+                // this.dispatchEvent({type: 'axischanged', axes: this.axes});
+            }
+            // button (touchpad)
+            if (this.touchpadIsPressed !== this.gamepad.buttons[0].pressed) {
+                this.touchpadIsPressed = this.gamepad.buttons[0].pressed;
+                // this._logMessage('touchpad pressed');
+                // this.dispatchEvent({type: this.touchpadIsPressed ? 'touchpaddown' : 'touchpadup', axes: this.axes});
+            }
+            // trigger
+            if (this.triggerIsPressed !== this.gamepad.buttons[1].pressed) {
+                this.triggerIsPressed = this.gamepad.buttons[1].pressed;
+                // this._logMessage('trigger pressed');
+                // this.dispatchEvent({type: this.triggerIsPressed ? 'triggerdown' : 'triggerup'});
+            }
+            // app button not available, reserved for use by the browser
+        }
+        else {
+            this._vrController.visible = false;
+        }
+    }
+    _findGamepad() {
+        const gamepads = navigator.getGamepads && navigator.getGamepads();
+        for (let i = 0; i < 4; i++) {
+            const gamepad = gamepads[i];
+            if (gamepad && (gamepad.id === 'Gear VR Controller' || gamepad.id === 'Oculus Go Controller')) {
+                return gamepad;
+            }
+        }
+    }
+    _createController() {
+        this._vrController = new Object3D();
+        this._createMeshes();
+        this.scene.add(this._vrController);
+    }
+    _createMeshes() {
+        const meshColorOff = 0xffffff, meshColorOn = 0xF4C20D, controllerMaterial = new MeshStandardMaterial({ color: meshColorOff }), controllerMesh = new Mesh(new CylinderGeometry(0.001, 0.003, 0.5, 16), controllerMaterial);
+        // handleMesh = new Mesh(new BoxGeometry(30, 10, 30), controllerMaterial);
+        // controllerMesh.add(new AxesHelper(50));
+        controllerMesh.geometry.translate(0, 0.25, 0);
+        controllerMaterial.flatShading = true;
+        controllerMesh.rotation.x = -Math.PI / 2;
+        // handleMesh.position.y = -5;
+        // controllerMesh.add(handleMesh);
+        this._vrController.add(controllerMesh);
+    }
+}
+XrService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: XrService, deps: [{ token: i1.HomedecoratorSettingsService }, { token: i2.DebugService }, { token: i3.MessageBoardService }], target: i0.ɵɵFactoryTarget.Injectable });
+XrService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: XrService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: XrService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HomedecoratorSettingsService }, { type: i2.DebugService }, { type: i3.MessageBoardService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"xr.service.js","sourceRoot":"","sources":["../../../../../../../src/client/app/plugins/core3d/service/xr.service.ts"],"names":[],"mappings":"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","sourcesContent":["// import WebXRPolyfill from 'webxr-polyfill';\r\nimport {Injectable, OnDestroy} from '@angular/core';\r\nimport * as THREE from 'three';\r\nimport {Camera, CylinderGeometry, Mesh, MeshStandardMaterial, Object3D, Scene, Vector3, WebGLRenderer} from 'three';\r\nimport {BehaviorSubject, Subject, Subscription} from 'rxjs';\r\nimport {XrMode} from '../../../core/enum/xr-mode.enum';\r\nimport {HomedecoratorSettingsService} from '../../../core/service/homedecorator-settings.service';\r\nimport {DebugService} from '../../../core/service/debug.service';\r\nimport {MessageBoardService} from './message-board.service';\r\nimport {isNill} from '../../../core/utils/function/is-nill.function';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class XrService implements OnDestroy {\r\n\r\n  public gamepad;\r\n  public axes = [0, 0];\r\n\r\n  public touchpadIsPressed = false;\r\n  public triggerIsPressed = false;\r\n  public angularVelocity = new Vector3();\r\n  public renderer: WebGLRenderer;\r\n\r\n  public scene: Scene;\r\n  public camera: Camera;\r\n  public controller: any;\r\n  public vrSupported: boolean = false;\r\n  public arSupported: boolean = false;\r\n  public sessionStarted: Subject<XrMode> = new Subject();\r\n\r\n  public sessionEnded: Subject<void> = new Subject();\r\n  public userSelectInAr: BehaviorSubject<boolean> = new BehaviorSubject(undefined);\r\n  public refSpace: any;\r\n  public viewerSpace: any;\r\n  public session: any;\r\n  public hitTestSource: any;\r\n\r\n  private _vrDisplay: any;\r\n  private _vrController: Object3D;\r\n  private _subs: Subscription[] = [];\r\n  private _cameraHeight: number;\r\n  private _mode: XrMode = XrMode.VrMode;\r\n\r\n  constructor(\r\n    private _settingsService: HomedecoratorSettingsService,\r\n    private _debugService: DebugService,\r\n    private _messageBoard: MessageBoardService\r\n  ) {}\r\n\r\n  ngOnDestroy(): void {\r\n    this._subs.forEach(s => s.unsubscribe());\r\n  }\r\n\r\n  public async init(renderer: WebGLRenderer, scene: Scene, camera: Camera): Promise<void> {\r\n    if (!this._settingsService.settings.options.vrEnabled && !this._settingsService.settings.options.arEnabled) {\r\n      return;\r\n    }\r\n    this.renderer = renderer;\r\n    this.scene = scene;\r\n    this.scene.onBeforeRender =\r\n      (brRenderer, brScene, brCamera, brTarget) => this._doBeforeRenderScene(brRenderer, brScene, brCamera, brTarget);\r\n    this.camera = camera;\r\n    await this._messageBoard.init(this.scene);\r\n    // this._createController();\r\n    this._logMessage('Starting XR');\r\n    // const polyfill = new WebXRPolyfill();\r\n\r\n    if ((navigator as any).xr && !isNill((navigator as any).xr) && (navigator as any).xr.isSessionSupported) {\r\n      this._logMessage('Checking support');\r\n      if (this._settingsService.settings.options.vrEnabled) {\r\n        (navigator as any).xr.isSessionSupported('immersive-vr')\r\n          .then((supported) => {\r\n            if (supported) {\r\n              this._logMessage('Session for VR supported!');\r\n              this.vrSupported = true;\r\n            } else {\r\n              this._logMessage('VR not supported!');\r\n              this.vrSupported = false;\r\n            }\r\n          })\r\n          .catch((e) => {\r\n            this._logMessage(e.message);\r\n          });\r\n      }\r\n      if (this._settingsService.settings.options.arEnabled) {\r\n        (navigator as any).xr.isSessionSupported('immersive-ar')\r\n          .then((supported) => {\r\n            if (supported) {\r\n              this._logMessage('Session for AR supported!');\r\n              this.arSupported = true;\r\n            } else {\r\n              this._logMessage('AR not supported!');\r\n              this.arSupported = false;\r\n              this._settingsService.settings.options.showArButton = false;\r\n            }\r\n          })\r\n          .catch((e) => {\r\n            this._logMessage(e.message);\r\n          });\r\n      }\r\n    } else {\r\n      if ('getVRDisplays' in navigator) {\r\n        this._logMessage('getVRDisplays');\r\n        const displays = await navigator.getVRDisplays();\r\n        if (displays.length > 0) {\r\n          this._vrDisplay = displays[0];\r\n          this._logMessage(this._vrDisplay.displayName);\r\n          this.vrSupported = true;\r\n          window.addEventListener('vrdisplaypresentchange', () => {\r\n            if (!this._vrDisplay.isPresenting) {\r\n              this.sessionEnded.next();\r\n            }\r\n          });\r\n        } else {\r\n          this._logMessage('No VR display found!');\r\n          this.vrSupported = false;\r\n        }\r\n      }\r\n    }\r\n\r\n    // if ('getVRDisplays' in navigator) {\r\n    //   this._debugService.addMessage('getVRDisplays');\r\n    // }\r\n\r\n    // if ('xr' in navigator && (navigator as any).xr !== null && 'requestDevice' in (navigator as any).xr) {\r\n    //   this._debugService.addMessage('Getting device');\r\n    //\r\n    //   (navigator as any).xr.requestDevice().then((device) => {\r\n    //\r\n    //     device.supportsSession({immersive: true, exclusive: true /* DEPRECATED */})\r\n    //       .then(() => {\r\n    //         this._debugService.addMessage('Device found!');\r\n    //         this.vrDevice = device;\r\n    //         this.vrSupported = true;\r\n    //       })\r\n    //       .catch((e) => {\r\n    //         this._debugService.addMessage(e.message);\r\n    //       });\r\n    //\r\n    //   }).catch((e) => {\r\n    //     this.vrSupported = false;\r\n    //     this._debugService.addMessage(e.message);\r\n    //   });\r\n    //\r\n    //\r\n    //   // (navigator as any).xr.supportsSession( 'immersive-vr' )\r\n    //   //   .then(() => {\r\n    //   //     this._debugService.addMessage('goedzo');\r\n    //   //   })\r\n    //   //   .catch((e) => {\r\n    //   //     this._debugService.addMessage(e.message);\r\n    //   //   });\r\n    //   return;\r\n    //\r\n    // } else if ('getVRDisplays' in navigator) {\r\n    //   this._debugService.addMessage('getVRDisplays');\r\n    //\r\n    //   window.addEventListener('vrdisplayconnect', (event) => {\r\n    //\r\n    //     console.log((event as any).display);\r\n    //\r\n    //   }, false);\r\n    //\r\n    //   window.addEventListener('vrdisplaydisconnect', ( /*event*/) => {\r\n    //\r\n    //     console.log('disconnected');\r\n    //\r\n    //   }, false);\r\n    //\r\n    //   window.addEventListener('vrdisplaypresentchange', (event) => {\r\n    //\r\n    //     console.log((event as any).display.isPresenting ? 'EXIT VR' : 'ENTER VR');\r\n    //\r\n    //   }, false);\r\n    //\r\n    //   window.addEventListener('vrdisplayactivate', (event) => {\r\n    //\r\n    //     (event as any).display.requestPresent([{source: this.renderer.domElement}]);\r\n    //\r\n    //   }, false);\r\n    //\r\n    //   navigator.getVRDisplays()\r\n    //     .then((displays) => {\r\n    //\r\n    //       if (displays.length > 0) {\r\n    //         this._debugService.addMessage(displays[0].displayName);\r\n    //       } else {\r\n    //         this._debugService.addMessage('VR not found');\r\n    //       }\r\n    //     }).catch((e) => this._debugService.addMessage(e.message));\r\n    //   return;\r\n    // } else {\r\n    //   this._debugService.addMessage('WebVR not supported');\r\n    //   //\r\n    //   // var message = document.createElement( 'a' );\r\n    //   // message.href = 'https://webvr.info';\r\n    //   // message.innerHTML = 'WEBVR NOT SUPPORTED';\r\n    //   //\r\n    //   // message.style.left = 'calc(50% - 90px)';\r\n    //   // message.style.width = '180px';\r\n    //   // message.style.textDecoration = 'none';\r\n    //   //\r\n    //   // stylizeElement( message );\r\n    //\r\n    //   return;\r\n    //\r\n    // }\r\n  }\r\n\r\n  public startAr(): void {\r\n    this._mode = XrMode.ArMode;\r\n\r\n    this.renderer.xr.enabled = true;\r\n    this.renderer.setClearColor(0x000000, 0);\r\n    this.renderer.autoClear = false;\r\n\r\n    if (isNill(this.session)) {\r\n      const features = {requiredFeatures: ['local', 'hit-test']};\r\n      (navigator as any).xr.requestSession( 'immersive-ar' , features ).then((session) => {\r\n        this.renderer.xr.setReferenceSpaceType( 'local' );\r\n        session.updateWorldTrackingState({ planeDetectionState : { enabled : true } });\r\n\r\n        session.requestReferenceSpace('viewer').then((refSpace) => {\r\n          this.viewerSpace = refSpace;\r\n          session.requestHitTestSource({ space: this.viewerSpace }).then((hitTestSource) => {\r\n              this.hitTestSource = hitTestSource;\r\n            });\r\n        });\r\n\r\n        session.requestReferenceSpace('local').then((refSpace) => {\r\n          this.refSpace = refSpace;\r\n          this._onSessionStarted(session);\r\n        });\r\n      });\r\n    } else {\r\n      this.session.end();\r\n    }\r\n  }\r\n\r\n  public stopAr(): void {\r\n    if (!isNill(this.session)) {\r\n      this.session.end();\r\n    }\r\n    if (this.renderer) {\r\n      this.renderer.xr.enabled = false;\r\n      this.renderer.setClearColor(0xfafafa);\r\n      this.renderer.autoClear = true;\r\n    }\r\n  }\r\n\r\n  public startVr(): void {\r\n    if (this.vrSupported) {\r\n      this._mode = XrMode.VrMode;\r\n      this.renderer.xr.enabled = true;\r\n\r\n        if (isNill(this.session)) {\r\n          // Setting reference spaceType\r\n          this.renderer.xr.setReferenceSpaceType('local-floor');\r\n\r\n          // Initializing session\r\n          const sessionInit = {optionalFeatures: 'local-floor'};\r\n          (navigator as any).xr.requestSession('immersive-vr', sessionInit).then((session) => {\r\n\r\n            // Creating offset to compensate for shit scale\r\n            // this._logMessage('Creating offset for VR reference space');\r\n            // session.requestReferenceSpace('local-floor').then((refSpace) => {\r\n            //   this.refSpace = refSpace.getOffsetReferenceSpace(\r\n            //     new XRRigidTransform(new DOMPoint(0, 160, 0)));\r\n            // });\r\n\r\n            // Start session\r\n            this._onSessionStarted(session);\r\n          });\r\n        } else {\r\n          this.session.end();\r\n        }\r\n    }\r\n  }\r\n\r\n  public stopVr(): void {\r\n    if (!isNill(this.session)) {\r\n      this.session.end();\r\n    }\r\n    if (this.renderer) {\r\n      this.renderer.xr.enabled = false;\r\n      // this.renderer.vr.setDevice(null);\r\n    }\r\n    if (this.camera && this._cameraHeight) {\r\n      this.camera.position.y = this._cameraHeight;\r\n    }\r\n  }\r\n\r\n  public update(): void {\r\n    // this._updateController();\r\n  }\r\n\r\n  private _doBeforeRenderScene(renderer: WebGLRenderer, scene: Scene, camera: Camera, target: any): void {\r\n    if (this.renderer.xr.enabled && this._mode === XrMode.VrMode) {\r\n\r\n    }\r\n  }\r\n\r\n  private _logMessage(message: string): void {\r\n    this._debugService.addMessage(message);\r\n    this._messageBoard.addMessage(message);\r\n  }\r\n\r\n  private _onSessionStarted(session): void {\r\n    this.session = session;\r\n    this.session.addEventListener('end', () => this._onSessionEnded());\r\n    this.session.addEventListener('select', () => this._onUserSelect());\r\n    this.renderer.xr.setSession(this.session);\r\n    this.sessionStarted.next(this._mode);\r\n  }\r\n\r\n  private _onUserSelect(): void {\r\n    this.userSelectInAr.next(true);\r\n  }\r\n\r\n  private _onSessionEnded(): void {\r\n    if (!isNill(this.session)) {\r\n      this.session.removeEventListener('select', () => this._onUserSelect());\r\n      this.session.removeEventListener('end', () => this._onSessionEnded());\r\n      this.session = null;\r\n      this.sessionEnded.next();\r\n    }\r\n  }\r\n\r\n  private _updateController() {\r\n    if (!this._vrController) {\r\n      return;\r\n    }\r\n\r\n    this.gamepad = this._findGamepad();\r\n    if (this.gamepad !== undefined && this.gamepad.pose !== undefined) {\r\n      const pose = this.gamepad.pose;\r\n      if (pose === null) {\r\n        return; // no user action yet\r\n      }\r\n      //  orientation\r\n      if (pose.orientation !== null) {\r\n        this._vrController.quaternion.fromArray(pose.orientation);\r\n      }\r\n      this._vrController.updateMatrix();\r\n      this._vrController.visible = true;\r\n      try {\r\n        const direction = new Vector3().applyEuler(this._vrController.rotation);\r\n        const raycaster = new THREE.Raycaster(this._vrController.position, direction);\r\n        const intersections = raycaster.intersectObjects(this.scene.children, true);\r\n        if (intersections.length) {\r\n            // this.controller.setMousePosition(Scene3DUtil.Convert3DPointToScreenPoint(\r\n            //   intersections[0].point,\r\n            //   this.camera,\r\n            //   this.controller.getElement().clientWidth,\r\n            //   this.controller.getElement().clientHeight));\r\n            // this.controller.doMouseMove();\r\n        }\r\n      } catch (e) {\r\n        this._logMessage(e.message);\r\n      }\r\n\r\n      // angular velocity\r\n      if (pose.angularVelocity !== null && !this.angularVelocity.equals(pose.angularVelocity)) {\r\n        this.angularVelocity.fromArray(pose.angularVelocity);\r\n        // this.dispatchEvent({type: 'angularvelocitychanged', angularVelocity: this.angularVelocity});\r\n      }\r\n      // axes (touchpad)\r\n      if (this.axes[0] !== this.gamepad.axes[0] || this.axes[1] !== this.gamepad.axes[1]) {\r\n        this.axes[0] = this.gamepad.axes[0];\r\n        this.axes[1] = this.gamepad.axes[1];\r\n        // this._logMessage('axes moved');\r\n        // this.dispatchEvent({type: 'axischanged', axes: this.axes});\r\n      }\r\n      // button (touchpad)\r\n      if (this.touchpadIsPressed !== this.gamepad.buttons[0].pressed) {\r\n        this.touchpadIsPressed = this.gamepad.buttons[0].pressed;\r\n        // this._logMessage('touchpad pressed');\r\n        // this.dispatchEvent({type: this.touchpadIsPressed ? 'touchpaddown' : 'touchpadup', axes: this.axes});\r\n      }\r\n      // trigger\r\n      if (this.triggerIsPressed !== this.gamepad.buttons[1].pressed) {\r\n        this.triggerIsPressed = this.gamepad.buttons[1].pressed;\r\n        // this._logMessage('trigger pressed');\r\n        // this.dispatchEvent({type: this.triggerIsPressed ? 'triggerdown' : 'triggerup'});\r\n      }\r\n      // app button not available, reserved for use by the browser\r\n    } else {\r\n      this._vrController.visible = false;\r\n    }\r\n  }\r\n\r\n  private _findGamepad() {\r\n    const gamepads = navigator.getGamepads && navigator.getGamepads();\r\n    for (let i = 0; i < 4; i++) {\r\n      const gamepad = gamepads[i];\r\n      if (gamepad && (gamepad.id === 'Gear VR Controller' || gamepad.id === 'Oculus Go Controller')) {\r\n        return gamepad;\r\n      }\r\n    }\r\n  }\r\n\r\n  private _createController(): void {\r\n    this._vrController = new Object3D();\r\n    this._createMeshes();\r\n    this.scene.add(this._vrController);\r\n  }\r\n\r\n  private _createMeshes(): void {\r\n    const meshColorOff = 0xffffff,\r\n      meshColorOn = 0xF4C20D,\r\n      controllerMaterial = new MeshStandardMaterial({color: meshColorOff}),\r\n      controllerMesh = new Mesh(new CylinderGeometry(0.001, 0.003, 0.5, 16), controllerMaterial);\r\n      // handleMesh = new Mesh(new BoxGeometry(30, 10, 30), controllerMaterial);\r\n    // controllerMesh.add(new AxesHelper(50));\r\n    controllerMesh.geometry.translate(0, 0.25, 0);\r\n    controllerMaterial.flatShading = true;\r\n    controllerMesh.rotation.x = -Math.PI / 2;\r\n    // handleMesh.position.y = -5;\r\n    // controllerMesh.add(handleMesh);\r\n    this._vrController.add(controllerMesh);\r\n  }\r\n}\r\n"]}

package/esm2015/app/plugins/core3d/textures/DepthDataTexture.js

@@ -0,0 +1,17 @@
+import { DataTexture, LuminanceAlphaFormat, UnsignedByteType, LinearFilter } from 'three';
+export class DepthDataTexture extends DataTexture {
+    constructor() {
+        const width = 160;
+        const height = 90;
+        const data = new Uint8Array(width * height * 2);
+        super(data, width, height, LuminanceAlphaFormat, UnsignedByteType);
+        this.magFilter = LinearFilter;
+        this.minFilter = LinearFilter;
+    }
+    updateDepth(depthData) {
+        const dataBuffer = depthData.data;
+        this.image.data.set(new Uint8Array(dataBuffer));
+        this.needsUpdate = true;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRGVwdGhEYXRhVGV4dHVyZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9jbGllbnQvYXBwL3BsdWdpbnMvY29yZTNkL3RleHR1cmVzL0RlcHRoRGF0YVRleHR1cmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFdBQVcsRUFBRSxvQkFBb0IsRUFBRSxnQkFBZ0IsRUFBRSxZQUFZLEVBQUMsTUFBTSxPQUFPLENBQUM7QUFFeEYsTUFBTSxPQUFPLGdCQUFpQixTQUFRLFdBQVc7SUFFL0M7UUFDRSxNQUFNLEtBQUssR0FBRyxHQUFHLENBQUM7UUFDbEIsTUFBTSxNQUFNLEdBQUcsRUFBRSxDQUFDO1FBQ2xCLE1BQU0sSUFBSSxHQUFHLElBQUksVUFBVSxDQUFDLEtBQUssR0FBRyxNQUFNLEdBQUcsQ0FBQyxDQUFDLENBQUM7UUFFaEQsS0FBSyxDQUFDLElBQUksRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLG9CQUFvQixFQUFFLGdCQUFnQixDQUFDLENBQUM7UUFFbkUsSUFBSSxDQUFDLFNBQVMsR0FBRyxZQUFZLENBQUM7UUFDOUIsSUFBSSxDQUFDLFNBQVMsR0FBRyxZQUFZLENBQUM7SUFDaEMsQ0FBQztJQUVNLFdBQVcsQ0FBQyxTQUFTO1FBQzFCLE1BQU0sVUFBVSxHQUFHLFNBQVMsQ0FBQyxJQUFJLENBQUM7UUFDbEMsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLElBQUksVUFBVSxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUM7UUFDaEQsSUFBSSxDQUFDLFdBQVcsR0FBRyxJQUFJLENBQUM7SUFDMUIsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtEYXRhVGV4dHVyZSwgTHVtaW5hbmNlQWxwaGFGb3JtYXQsIFVuc2lnbmVkQnl0ZVR5cGUsIExpbmVhckZpbHRlcn0gZnJvbSAndGhyZWUnO1xyXG5cclxuZXhwb3J0IGNsYXNzIERlcHRoRGF0YVRleHR1cmUgZXh0ZW5kcyBEYXRhVGV4dHVyZSB7XHJcblxyXG4gIGNvbnN0cnVjdG9yKCkge1xyXG4gICAgY29uc3Qgd2lkdGggPSAxNjA7XHJcbiAgICBjb25zdCBoZWlnaHQgPSA5MDtcclxuICAgIGNvbnN0IGRhdGEgPSBuZXcgVWludDhBcnJheSh3aWR0aCAqIGhlaWdodCAqIDIpO1xyXG5cclxuICAgIHN1cGVyKGRhdGEsIHdpZHRoLCBoZWlnaHQsIEx1bWluYW5jZUFscGhhRm9ybWF0LCBVbnNpZ25lZEJ5dGVUeXBlKTtcclxuXHJcbiAgICB0aGlzLm1hZ0ZpbHRlciA9IExpbmVhckZpbHRlcjtcclxuICAgIHRoaXMubWluRmlsdGVyID0gTGluZWFyRmlsdGVyO1xyXG4gIH1cclxuXHJcbiAgcHVibGljIHVwZGF0ZURlcHRoKGRlcHRoRGF0YSkge1xyXG4gICAgY29uc3QgZGF0YUJ1ZmZlciA9IGRlcHRoRGF0YS5kYXRhO1xyXG4gICAgdGhpcy5pbWFnZS5kYXRhLnNldChuZXcgVWludDhBcnJheShkYXRhQnVmZmVyKSk7XHJcbiAgICB0aGlzLm5lZWRzVXBkYXRlID0gdHJ1ZTtcclxuICB9XHJcbn1cclxuIl19

package/esm2015/app/plugins/core3d/walkthrough-camera-controls/walkthrough-camera-controls.component.js

@@ -0,0 +1,54 @@
+import { Component, Input } from '@angular/core';
+import { ConfigurationKey } from '../../../core/enum/configuration-key.enum';
+import { MessageType } from '../../../core/enum/message-type.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../core/service/message-bus.service";
+import * as i2 from "../../../core/service/configuration.service";
+import * as i3 from "../../../shared/slider-input/slider-input.component";
+import * as i4 from "../../../core/pipe/localize.pipe";
+export class WalkthroughCameraControlsComponent {
+    constructor(messageService, _configurationService) {
+        this.messageService = messageService;
+        this._configurationService = _configurationService;
+    }
+    ngOnInit() {
+        this.fov = this._configurationService.getValue(ConfigurationKey.WalkThroughCameraFoV);
+        this.aspect = this._configurationService.getValue(ConfigurationKey.WalkThroughCameraAspectRatio);
+        this.focus = this._configurationService.getValue(ConfigurationKey.WalkThroughCameraFocus);
+    }
+    onFovChange(newFov) {
+        this._configurationService.setValue(ConfigurationKey.WalkThroughCameraFoV, newFov);
+        this.fov = newFov;
+        this.cameraChanged();
+    }
+    onAspectRatioChange(newAspect) {
+        this._configurationService.setValue(ConfigurationKey.WalkThroughCameraAspectRatio, newAspect);
+        this.aspect = newAspect;
+        this.cameraChanged();
+    }
+    onFocusChange(newFocus) {
+        this._configurationService.setValue(ConfigurationKey.WalkThroughCameraFocus, newFocus);
+        this.focus = newFocus;
+        this.cameraChanged();
+    }
+    cameraChanged() {
+        this.messageService.emit(MessageType.WalkThroughCameraSettingsChanged);
+    }
+}
+WalkthroughCameraControlsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: WalkthroughCameraControlsComponent, deps: [{ token: i1.MessageBusService }, { token: i2.ConfigurationService }], target: i0.ɵɵFactoryTarget.Component });
+WalkthroughCameraControlsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: WalkthroughCameraControlsComponent, selector: "rp-walkthrough-camera-controls", inputs: { fov: "fov", aspect: "aspect", focus: "focus" }, ngImport: i0, template: "<div class=\"camera-controls\">\r\n  <rp-slider-input\r\n    title=\"{{'FIELD_OF_VIEW' | localize}}\"\r\n    min=\"0\"\r\n    max=\"180\"\r\n    step=\"1\"\r\n    [value]=\"fov\"\r\n    (onChange)=\"onFovChange($event)\">\r\n  </rp-slider-input>\r\n  <rp-slider-input\r\n    title=\"{{'ASPECT_RATIO' | localize}}\"\r\n    min=\"0.1\"\r\n    max=\"10\"\r\n    step=\"0.1\"\r\n    [value]=\"aspect\"\r\n    (onChange)=\"onAspectRatioChange($event)\">\r\n  </rp-slider-input>\r\n  <rp-slider-input\r\n    title=\"{{'FOCUS' | localize}}\"\r\n    min=\"1\"\r\n    max=\"100\"\r\n    step=\"1\"\r\n    [value]=\"focus\"\r\n    (onChange)=\"onFocusChange($event)\">\r\n  </rp-slider-input>\r\n</div>\r\n", styles: [".camera-controls{position:absolute;right:20px;top:84px;display:flex;align-items:center}\n"], components: [{ type: i3.SliderInputComponent, selector: "rp-slider-input", inputs: ["title", "min", "max", "step", "value"], outputs: ["onChange"] }], pipes: { "localize": i4.LocalizePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: WalkthroughCameraControlsComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'rp-walkthrough-camera-controls',
+                    templateUrl: './walkthrough-camera-controls.component.html',
+                    styleUrls: ['./walkthrough-camera-controls.component.scss']
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MessageBusService }, { type: i2.ConfigurationService }]; }, propDecorators: { fov: [{
+                type: Input
+            }], aspect: [{
+                type: Input
+            }], focus: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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