@colijnit/configurator 261.1.0 → 261.1.1

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

@@ -0,0 +1,191 @@
+import { Injectable } from '@angular/core';
+import { BufferGeometry, Group, Line, Matrix4, PerspectiveCamera, Raycaster, Vector3 } from 'three';
+import { XRControllerModelFactory } from 'three/examples/jsm/webxr/XRControllerModelFactory';
+import * as THREE from 'three';
+import { isNill } from '@colijnit/configuratorapi/build/utils/function/is-nill.function';
+import { Reticle } from '../model/xr-reticle';
+import * as i0 from "@angular/core";
+export class VrService {
+    constructor() { }
+    init(scene, renderer) {
+        if (isNill(this._scene)) {
+            this._scene = scene;
+            this._renderer = renderer;
+            this._camera = new PerspectiveCamera(50, window.innerWidth / window.innerHeight, 0.1, 10);
+            this._raycaster = new Raycaster();
+            this._reticle = new Reticle();
+            this._tempMatrix = new Matrix4();
+            this._meshes = [];
+            this._user = new Group();
+            this._user.name = 'user-group';
+            this._user.add(this._camera);
+            this._scene.add(this._user, this._reticle);
+            this._createControllers();
+        }
+        this._initSession();
+    }
+    render() {
+        this._handleIntersections();
+        this._renderer.render(this._scene, this._camera);
+    }
+    endSession() {
+        if (this._session) {
+            this._session.end();
+        }
+    }
+    _initSession() {
+        if (!this._session) {
+            const sessionInit = { optionalFeatures: ['local-floor', 'bounded-floor'] };
+            navigator.xr.requestSession('immersive-vr', sessionInit).then((session) => {
+                this._onSessionStarted(session);
+                this.startVRSession();
+            });
+        }
+    }
+    _onSessionStarted(session) {
+        session.addEventListener('end', this._onSessionEnded.bind(this));
+        this._renderer.xr.setSession(session);
+        this._renderer.xr.enabled = true;
+        this._session = session;
+    }
+    _onSessionEnded() {
+        this._session = null;
+        // TODO create a fix for this viewModeService stuf
+        // this._viewModeService.viewMode = ViewMode.RoomPlan3D;
+        this._renderer.xr.enabled = false;
+    }
+    startVRSession() {
+        this._registerMeshes();
+    }
+    _createControllers() {
+        this._controller0 = this._renderer.xr.getController(0);
+        this._controller0.addEventListener('selectstart', (event) => this._onSelectStart(event));
+        this._controller0.addEventListener('selectend', (event) => this._onSelectEnd(event));
+        this._user.add(this._controller0);
+        this._controller1 = this._renderer.xr.getController(1);
+        this._controller1.addEventListener('selectstart', (event) => this._onSelectStart(event));
+        this._controller1.addEventListener('selectend', (event) => this._onSelectEnd(event));
+        this._user.add(this._controller1);
+        const controllerModelFactory = new XRControllerModelFactory();
+        const controllerGrip1 = this._renderer.xr.getControllerGrip(0);
+        controllerGrip1.add(controllerModelFactory.createControllerModel(controllerGrip1));
+        this._user.add(controllerGrip1);
+        const controllerGrip2 = this._renderer.xr.getControllerGrip(1);
+        controllerGrip2.add(controllerModelFactory.createControllerModel(controllerGrip2));
+        this._user.add(controllerGrip2);
+        const geometry = new BufferGeometry().setFromPoints([new Vector3(0, 0, 0), new Vector3(0, 0, -1)]);
+        const line = new Line(geometry);
+        line.name = 'line';
+        line.scale.z = 10;
+        // Only add line to controller0 when debugging with WebXR chrome extension
+        // this._controller0.add( line.clone() );
+        this._controller1.add(line.clone());
+    }
+    _onSelectStart(event) {
+        if (this._isObjectFloor(this._currentClosestIntersection.object)) {
+            this._user.position.set(this._currentClosestIntersection.point.x, 0, this._currentClosestIntersection.point.z);
+            this._controller0.updateMatrix();
+        }
+    }
+    _onSelectEnd(event) {
+        // Function can be used to clean up after _onSelectStart
+    }
+    _getIntersections(controller, group) {
+        this._tempMatrix.identity().extractRotation(controller.matrixWorld);
+        this._raycaster.ray.origin.setFromMatrixPosition(controller.matrixWorld);
+        this._raycaster.ray.direction.set(0, 0, -1).applyMatrix4(this._tempMatrix);
+        return this._raycaster.intersectObjects(group);
+    }
+    _registerMeshes() {
+        this._scene.traverse((mesh) => {
+            this._meshes.push(mesh);
+        });
+    }
+    _handleIntersections() {
+        if (this._renderer.xr.getController(1).visible) {
+            this._handleControllerIntersections(this._controller1);
+        }
+        else {
+            this._handleControllerIntersections(this._controller0);
+        }
+    }
+    _handleControllerIntersections(controller) {
+        const objectIntersections = this._getIntersections(controller, this._meshes);
+        if (objectIntersections.length > 0) {
+            const nearestIntersection = this._getNearestIntersection(objectIntersections);
+            if (nearestIntersection !== null) {
+                this._currentClosestIntersection = nearestIntersection;
+                const nearestObjectParent = this._getParentOfChild(nearestIntersection.object);
+                if (this._isObjectFloor(nearestIntersection.object)) {
+                    this._handleFloorIntersection(controller, nearestIntersection);
+                }
+                else if (nearestObjectParent) {
+                    this._updateObjectSelection(nearestObjectParent);
+                    this._handleObjectIntersection(controller, nearestIntersection);
+                }
+                else {
+                    this._handleNoIntersections(controller);
+                }
+            }
+        }
+    }
+    _getNearestIntersection(intersections) {
+        let nearest = null;
+        for (const intersection of intersections) {
+            // TODO: need a better solution for first if-statement
+            if (intersection.object.name && (intersection.object.name === 'home' || intersection.object.name === 'line')
+                || (intersection.object.parent && intersection.object.parent instanceof Reticle)) {
+                // DO NOTHING
+            }
+            else if (nearest === null || intersection.distance < nearest.distance) {
+                nearest = intersection;
+            }
+        }
+        return nearest;
+    }
+    _handleFloorIntersection(controller, intersection) {
+        this._updateControllerRay(controller, intersection.distance);
+        this._reticle.visible = true;
+        this._reticle.position.copy(intersection.point);
+    }
+    _handleObjectIntersection(controller, intersection) {
+        this._updateControllerRay(controller, intersection.distance);
+        this._reticle.visible = false;
+    }
+    _handleNoIntersections(controller) {
+        this._reticle.visible = false;
+        this._updateControllerRay(controller, 0);
+    }
+    _updateControllerRay(controller, rayLenght) {
+        const line = controller.getObjectByName('line');
+        if (line) {
+            line.scale.z = rayLenght;
+        }
+    }
+    _isObjectFloor(object) {
+        return object.name && object.name === 'floor-plane';
+    }
+    _getParentOfChild(object) {
+        // TODO: return null if object is not selectable
+        if (!object.parent || (object.parent instanceof THREE.Scene) || (object.parent instanceof Reticle)) {
+            return object;
+        }
+        else {
+            return this._getParentOfChild(object.parent);
+        }
+    }
+    _updateObjectSelection(object) {
+        if (!this._selectedObject) {
+            this._selectedObject = object;
+        }
+        // Do something with newly selected item
+        // ...
+    }
+}
+VrService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: VrService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+VrService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: VrService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: VrService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vr.service.js","sourceRoot":"","sources":["../../../../../projects/configurator/src/lib/services/vr.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EACL,cAAc,EACd,KAAK,EACL,IAAI,EACJ,OAAO,EAGP,iBAAiB,EACjB,SAAS,EAET,OAAO,EAER,MAAM,OAAO,CAAC;AACf,OAAO,EAAC,wBAAwB,EAAC,MAAM,mDAAmD,CAAC;AAC3F,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAC,MAAM,EAAC,MAAM,iEAAiE,CAAC;AAEvF,OAAO,EAAC,OAAO,EAAC,MAAM,qBAAqB,CAAC;;AAI5C,MAAM,OAAO,SAAS;IAoBpB,gBAEG,CAAC;IAEG,IAAI,CAAC,KAAY,EAAE,QAAuB;QAC/C,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE;YACvB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;YACpB,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;YAC1B,IAAI,CAAC,OAAO,GAAG,IAAI,iBAAiB,CAAC,EAAE,EAAE,MAAM,CAAC,UAAU,GAAG,MAAM,CAAC,WAAW,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC;YAC1F,IAAI,CAAC,UAAU,GAAG,IAAI,SAAS,EAAE,CAAC;YAClC,IAAI,CAAC,QAAQ,GAAG,IAAI,OAAO,EAAE,CAAC;YAC9B,IAAI,CAAC,WAAW,GAAG,IAAI,OAAO,EAAE,CAAC;YACjC,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;YAElB,IAAI,CAAC,KAAK,GAAG,IAAI,KAAK,EAAE,CAAC;YACzB,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,YAAY,CAAC;YAC/B,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC7B,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;YAE3C,IAAI,CAAC,kBAAkB,EAAE,CAAC;SAC3B;QAED,IAAI,CAAC,YAAY,EAAE,CAAC;IACtB,CAAC;IAEM,MAAM;QACX,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC5B,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IACnD,CAAC;IAEM,UAAU;QACf,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;SACrB;IACH,CAAC;IAEO,YAAY;QAClB,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;YAClB,MAAM,WAAW,GAAG,EAAE,gBAAgB,EAAE,CAAE,aAAa,EAAE,eAAe,CAAE,EAAE,CAAC;YAC5E,SAAiB,CAAC,EAAE,CAAC,cAAc,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE;gBACjF,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;gBAChC,IAAI,CAAC,cAAc,EAAE,CAAC;YACxB,CAAC,CAAC,CAAC;SACJ;IACH,CAAC;IAEO,iBAAiB,CAAC,OAAY;QACpC,OAAO,CAAC,gBAAgB,CAAC,KAAK,EAAE,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;QACjE,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,UAAU,CAAE,OAAO,CAAE,CAAC;QACxC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,OAAO,GAAG,IAAI,CAAC;QACjC,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;IAC1B,CAAC;IAEO,eAAe;QACrB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,kDAAkD;QAClD,wDAAwD;QACxD,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,OAAO,GAAG,KAAK,CAAC;IACpC,CAAC;IAEM,cAAc;QACnB,IAAI,CAAC,eAAe,EAAE,CAAC;IACzB,CAAC;IAEO,kBAAkB;QACxB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,aAAa,CAAE,CAAC,CAAE,CAAC;QACzD,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAAE,aAAa,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAE,CAAC;QAC3F,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAAE,WAAW,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAE,CAAC;QACvF,IAAI,CAAC,KAAK,CAAC,GAAG,CAAE,IAAI,CAAC,YAAY,CAAE,CAAC;QAEpC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,aAAa,CAAE,CAAC,CAAE,CAAC;QACzD,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAAE,aAAa,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAE,CAAC;QAC3F,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAAE,WAAW,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAE,CAAC;QACvF,IAAI,CAAC,KAAK,CAAC,GAAG,CAAE,IAAI,CAAC,YAAY,CAAE,CAAC;QAEpC,MAAM,sBAAsB,GAAG,IAAI,wBAAwB,EAAE,CAAC;QAE9D,MAAM,eAAe,GAAG,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,iBAAiB,CAAE,CAAC,CAAE,CAAC;QACjE,eAAe,CAAC,GAAG,CAAE,sBAAsB,CAAC,qBAAqB,CAAE,eAAe,CAAE,CAAE,CAAC;QACvF,IAAI,CAAC,KAAK,CAAC,GAAG,CAAE,eAAe,CAAE,CAAC;QAElC,MAAM,eAAe,GAAG,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,iBAAiB,CAAE,CAAC,CAAE,CAAC;QACjE,eAAe,CAAC,GAAG,CAAE,sBAAsB,CAAC,qBAAqB,CAAE,eAAe,CAAE,CAAE,CAAC;QACvF,IAAI,CAAC,KAAK,CAAC,GAAG,CAAE,eAAe,CAAE,CAAC;QAElC,MAAM,QAAQ,GAAG,IAAI,cAAc,EAAE,CAAC,aAAa,CAAE,CAAE,IAAI,OAAO,CAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAE,EAAE,IAAI,OAAO,CAAE,CAAC,EAAE,CAAC,EAAE,CAAE,CAAC,CAAE,CAAE,CAAE,CAAC;QAE5G,MAAM,IAAI,GAAG,IAAI,IAAI,CAAE,QAAQ,CAAE,CAAC;QAClC,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC;QACnB,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,CAAC;QAElB,0EAA0E;QAC1E,yCAAyC;QACzC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAE,IAAI,CAAC,KAAK,EAAE,CAAE,CAAC;IACxC,CAAC;IAEO,cAAc,CAAE,KAAK;QAC3B,IAAI,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,2BAA2B,CAAC,MAAM,CAAC,EAAE;YAChE,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,2BAA2B,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,2BAA2B,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YAC/G,IAAI,CAAC,YAAY,CAAC,YAAY,EAAE,CAAC;SAClC;IACH,CAAC;IAEO,YAAY,CAAE,KAAK;QACzB,wDAAwD;IAE1D,CAAC;IAEO,iBAAiB,CAAE,UAAe,EAAE,KAA0B;QACpE,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC,eAAe,CAAE,UAAU,CAAC,WAAW,CAAE,CAAC;QACtE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,qBAAqB,CAAE,UAAU,CAAC,WAAW,CAAE,CAAC;QAC3E,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,GAAG,CAAE,CAAC,EAAE,CAAC,EAAE,CAAE,CAAC,CAAE,CAAC,YAAY,CAAE,IAAI,CAAC,WAAW,CAAE,CAAC;QAEhF,OAAO,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAE,KAAK,CAAE,CAAC;IACnD,CAAC;IAEO,eAAe;QACrB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,IAAU,EAAE,EAAE;YAClC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC1B,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,oBAAoB;QAC1B,IAAI,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE;YAC9C,IAAI,CAAC,8BAA8B,CAAE,IAAI,CAAC,YAAY,CAAE,CAAC;SAC1D;aAAM;YACL,IAAI,CAAC,8BAA8B,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;SACxD;IACH,CAAC;IAEO,8BAA8B,CAAC,UAAe;QACpD,MAAM,mBAAmB,GAAG,IAAI,CAAC,iBAAiB,CAAC,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QAE7E,IAAI,mBAAmB,CAAC,MAAM,GAAG,CAAC,EAAE;YAClC,MAAM,mBAAmB,GAAG,IAAI,CAAC,uBAAuB,CAAC,mBAAmB,CAAC,CAAC;YAC9E,IAAI,mBAAmB,KAAK,IAAI,EAAE;gBAChC,IAAI,CAAC,2BAA2B,GAAG,mBAAmB,CAAC;gBACvD,MAAM,mBAAmB,GAAG,IAAI,CAAC,iBAAiB,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;gBAC/E,IAAI,IAAI,CAAC,cAAc,CAAC,mBAAmB,CAAC,MAAM,CAAC,EAAE;oBACnD,IAAI,CAAC,wBAAwB,CAAC,UAAU,EAAE,mBAAmB,CAAC,CAAC;iBAChE;qBAAM,IAAI,mBAAmB,EAAE;oBAC9B,IAAI,CAAC,sBAAsB,CAAC,mBAAmB,CAAC,CAAC;oBACjD,IAAI,CAAC,yBAAyB,CAAC,UAAU,EAAE,mBAAmB,CAAC,CAAC;iBACjE;qBAAM;oBACL,IAAI,CAAC,sBAAsB,CAAC,UAAU,CAAC,CAAC;iBACzC;aACF;SACF;IACH,CAAC;IAEO,uBAAuB,CAAC,aAA6B;QAC3D,IAAI,OAAO,GAAG,IAAI,CAAC;QACnB,KAAK,MAAM,YAAY,IAAI,aAAa,EAAE;YACxC,sDAAsD;YACtD,IAAI,YAAY,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,KAAK,MAAM,IAAI,YAAY,CAAC,MAAM,CAAC,IAAI,KAAK,MAAM,CAAC;mBACvG,CAAC,YAAY,CAAC,MAAM,CAAC,MAAM,IAAI,YAAY,CAAC,MAAM,CAAC,MAAM,YAAY,OAAO,CAAC,EAAE;gBAClF,aAAa;aACd;iBAAM,IAAI,OAAO,KAAK,IAAI,IAAI,YAAY,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,EAAE;gBACvE,OAAO,GAAG,YAAY,CAAC;aACxB;SACF;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAEO,wBAAwB,CAAC,UAAe,EAAE,YAA0B;QAC1E,IAAI,CAAC,oBAAoB,CAAC,UAAU,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAC;QAC7D,IAAI,CAAC,QAAQ,CAAC,OAAO,GAAG,IAAI,CAAC;QAC7B,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;IAClD,CAAC;IAEO,yBAAyB,CAAC,UAAe,EAAE,YAA0B;QAC3E,IAAI,CAAC,oBAAoB,CAAC,UAAU,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAC;QAC7D,IAAI,CAAC,QAAQ,CAAC,OAAO,GAAG,KAAK,CAAC;IAChC,CAAC;IAEO,sBAAsB,CAAC,UAAe;QAC5C,IAAI,CAAC,QAAQ,CAAC,OAAO,GAAG,KAAK,CAAC;QAC9B,IAAI,CAAC,oBAAoB,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;IAC3C,CAAC;IAEO,oBAAoB,CAAC,UAAe,EAAE,SAAiB;QAC7D,MAAM,IAAI,GAAG,UAAU,CAAC,eAAe,CAAE,MAAM,CAAE,CAAC;QAClD,IAAI,IAAI,EAAE;YACR,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,SAAS,CAAC;SAC1B;IACH,CAAC;IAEO,cAAc,CAAC,MAAgB;QACrC,OAAO,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI,KAAK,aAAa,CAAC;IACtD,CAAC;IAEO,iBAAiB,CAAC,MAAW;QACnC,gDAAgD;QAChD,IAAI,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,YAAY,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,YAAY,OAAO,CAAC,EAAE;YAClG,OAAO,MAAM,CAAC;SACf;aAAM;YACL,OAAO,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;SAC9C;IACH,CAAC;IAEO,sBAAsB,CAAC,MAAgB;QAC7C,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE;YACzB,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC;SAC/B;QAED,wCAAwC;QACxC,MAAM;IACR,CAAC;;uGApOU,SAAS;2GAAT,SAAS,cADG,MAAM;4FAClB,SAAS;kBADrB,UAAU;mBAAC,EAAC,UAAU,EAAE,MAAM,EAAC","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport {\r\n  BufferGeometry,\r\n  Group, Intersection,\r\n  Line,\r\n  Matrix4,\r\n  Mesh,\r\n  Object3D,\r\n  PerspectiveCamera,\r\n  Raycaster,\r\n  Scene,\r\n  Vector3,\r\n  WebGLRenderer\r\n} from 'three';\r\nimport {XRControllerModelFactory} from 'three/examples/jsm/webxr/XRControllerModelFactory';\r\nimport * as THREE from 'three';\r\nimport {isNill} from '@colijnit/configuratorapi/build/utils/function/is-nill.function';\r\nimport {ViewMode} from '../enum/view-mode.enum';\r\nimport {Reticle} from '../model/xr-reticle';\r\n\r\n\r\n@Injectable({providedIn: 'root'})\r\nexport class VrService {\r\n\r\n  private _scene: Scene;\r\n  private _renderer: WebGLRenderer;\r\n  private _camera: PerspectiveCamera;\r\n\r\n  private _tempMatrix: Matrix4;\r\n  private _currentClosestIntersection: Intersection;\r\n  private _meshes: Mesh[];\r\n  private _raycaster: Raycaster;\r\n  private _reticle: Reticle;\r\n\r\n  private _controller0;\r\n  private _controller1;\r\n\r\n  private _session: any;\r\n  private _user: Group;\r\n\r\n  private _selectedObject: any;\r\n\r\n  constructor(\r\n\r\n  ) {}\r\n\r\n  public init(scene: Scene, renderer: WebGLRenderer) {\r\n    if (isNill(this._scene)) {\r\n      this._scene = scene;\r\n      this._renderer = renderer;\r\n      this._camera = new PerspectiveCamera(50, window.innerWidth / window.innerHeight, 0.1, 10);\r\n      this._raycaster = new Raycaster();\r\n      this._reticle = new Reticle();\r\n      this._tempMatrix = new Matrix4();\r\n      this._meshes = [];\r\n\r\n      this._user = new Group();\r\n      this._user.name = 'user-group';\r\n      this._user.add(this._camera);\r\n      this._scene.add(this._user, this._reticle);\r\n\r\n      this._createControllers();\r\n    }\r\n\r\n    this._initSession();\r\n  }\r\n\r\n  public render() {\r\n    this._handleIntersections();\r\n    this._renderer.render(this._scene, this._camera);\r\n  }\r\n\r\n  public endSession() {\r\n    if (this._session) {\r\n      this._session.end();\r\n    }\r\n  }\r\n\r\n  private _initSession() {\r\n    if (!this._session) {\r\n      const sessionInit = { optionalFeatures: [ 'local-floor', 'bounded-floor' ] };\r\n      (navigator as any).xr.requestSession('immersive-vr', sessionInit).then((session) => {\r\n        this._onSessionStarted(session);\r\n        this.startVRSession();\r\n      });\r\n    }\r\n  }\r\n\r\n  private _onSessionStarted(session: any) {\r\n    session.addEventListener('end', this._onSessionEnded.bind(this));\r\n    this._renderer.xr.setSession( session );\r\n    this._renderer.xr.enabled = true;\r\n    this._session = session;\r\n  }\r\n\r\n  private _onSessionEnded() {\r\n    this._session = null;\r\n    // TODO create a fix for this viewModeService stuf\r\n    // this._viewModeService.viewMode = ViewMode.RoomPlan3D;\r\n    this._renderer.xr.enabled = false;\r\n  }\r\n\r\n  public startVRSession() {\r\n    this._registerMeshes();\r\n  }\r\n\r\n  private _createControllers() {\r\n    this._controller0 = this._renderer.xr.getController( 0 );\r\n    this._controller0.addEventListener( 'selectstart', (event) => this._onSelectStart(event) );\r\n    this._controller0.addEventListener( 'selectend', (event) => this._onSelectEnd(event) );\r\n    this._user.add( this._controller0 );\r\n\r\n    this._controller1 = this._renderer.xr.getController( 1 );\r\n    this._controller1.addEventListener( 'selectstart', (event) => this._onSelectStart(event) );\r\n    this._controller1.addEventListener( 'selectend', (event) => this._onSelectEnd(event) );\r\n    this._user.add( this._controller1 );\r\n\r\n    const controllerModelFactory = new XRControllerModelFactory();\r\n\r\n    const controllerGrip1 = this._renderer.xr.getControllerGrip( 0 );\r\n    controllerGrip1.add( controllerModelFactory.createControllerModel( controllerGrip1 ) );\r\n    this._user.add( controllerGrip1 );\r\n\r\n    const controllerGrip2 = this._renderer.xr.getControllerGrip( 1 );\r\n    controllerGrip2.add( controllerModelFactory.createControllerModel( controllerGrip2 ) );\r\n    this._user.add( controllerGrip2 );\r\n\r\n    const geometry = new BufferGeometry().setFromPoints( [ new Vector3( 0, 0, 0 ), new Vector3( 0, 0, - 1 ) ] );\r\n\r\n    const line = new Line( geometry );\r\n    line.name = 'line';\r\n    line.scale.z = 10;\r\n\r\n    // Only add line to controller0 when debugging with WebXR chrome extension\r\n    // this._controller0.add( line.clone() );\r\n    this._controller1.add( line.clone() );\r\n  }\r\n\r\n  private _onSelectStart( event ) {\r\n    if (this._isObjectFloor(this._currentClosestIntersection.object)) {\r\n      this._user.position.set(this._currentClosestIntersection.point.x, 0, this._currentClosestIntersection.point.z);\r\n      this._controller0.updateMatrix();\r\n    }\r\n  }\r\n\r\n  private _onSelectEnd( event ) {\r\n    // Function can be used to clean up after _onSelectStart\r\n\r\n  }\r\n\r\n  private _getIntersections( controller: any, group: Object3D[] | Mesh[] ) {\r\n    this._tempMatrix.identity().extractRotation( controller.matrixWorld );\r\n    this._raycaster.ray.origin.setFromMatrixPosition( controller.matrixWorld );\r\n    this._raycaster.ray.direction.set( 0, 0, - 1 ).applyMatrix4( this._tempMatrix );\r\n\r\n    return this._raycaster.intersectObjects( group );\r\n  }\r\n\r\n  private _registerMeshes() {\r\n    this._scene.traverse((mesh: Mesh) => {\r\n      this._meshes.push(mesh);\r\n    });\r\n  }\r\n\r\n  private _handleIntersections() {\r\n    if (this._renderer.xr.getController(1).visible) {\r\n      this._handleControllerIntersections( this._controller1 );\r\n    } else {\r\n      this._handleControllerIntersections(this._controller0);\r\n    }\r\n  }\r\n\r\n  private _handleControllerIntersections(controller: any) {\r\n    const objectIntersections = this._getIntersections(controller, this._meshes);\r\n\r\n    if (objectIntersections.length > 0) {\r\n      const nearestIntersection = this._getNearestIntersection(objectIntersections);\r\n      if (nearestIntersection !== null) {\r\n        this._currentClosestIntersection = nearestIntersection;\r\n        const nearestObjectParent = this._getParentOfChild(nearestIntersection.object);\r\n        if (this._isObjectFloor(nearestIntersection.object)) {\r\n          this._handleFloorIntersection(controller, nearestIntersection);\r\n        } else if (nearestObjectParent) {\r\n          this._updateObjectSelection(nearestObjectParent);\r\n          this._handleObjectIntersection(controller, nearestIntersection);\r\n        } else {\r\n          this._handleNoIntersections(controller);\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  private _getNearestIntersection(intersections: Intersection[]): Intersection {\r\n    let nearest = null;\r\n    for (const intersection of intersections) {\r\n      // TODO: need a better solution for first if-statement\r\n      if (intersection.object.name && (intersection.object.name === 'home' || intersection.object.name === 'line')\r\n        || (intersection.object.parent && intersection.object.parent instanceof Reticle)) {\r\n        // DO NOTHING\r\n      } else if (nearest === null || intersection.distance < nearest.distance) {\r\n        nearest = intersection;\r\n      }\r\n    }\r\n\r\n    return nearest;\r\n  }\r\n\r\n  private _handleFloorIntersection(controller: any, intersection: Intersection) {\r\n    this._updateControllerRay(controller, intersection.distance);\r\n    this._reticle.visible = true;\r\n    this._reticle.position.copy(intersection.point);\r\n  }\r\n\r\n  private _handleObjectIntersection(controller: any, intersection: Intersection) {\r\n    this._updateControllerRay(controller, intersection.distance);\r\n    this._reticle.visible = false;\r\n  }\r\n\r\n  private _handleNoIntersections(controller: any) {\r\n    this._reticle.visible = false;\r\n    this._updateControllerRay(controller, 0);\r\n  }\r\n\r\n  private _updateControllerRay(controller: any, rayLenght: number) {\r\n    const line = controller.getObjectByName( 'line' );\r\n    if (line) {\r\n      line.scale.z = rayLenght;\r\n    }\r\n  }\r\n\r\n  private _isObjectFloor(object: Object3D) {\r\n    return object.name && object.name === 'floor-plane';\r\n  }\r\n\r\n  private _getParentOfChild(object: any): any {\r\n    // TODO: return null if object is not selectable\r\n    if (!object.parent || (object.parent instanceof THREE.Scene) || (object.parent instanceof Reticle)) {\r\n      return object;\r\n    } else {\r\n      return this._getParentOfChild(object.parent);\r\n    }\r\n  }\r\n\r\n  private _updateObjectSelection(object: Object3D) {\r\n    if (!this._selectedObject) {\r\n      this._selectedObject = object;\r\n    }\r\n\r\n    // Do something with newly selected item\r\n    // ...\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,294 @@
+import { __awaiter } from "tslib";
+// 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 '../enum/xr-mode.enum';
+import { isNill } from '@colijnit/configuratorapi/build/utils/function/is-nill.function';
+import * as i0 from "@angular/core";
+import * as i1 from "./settings.service";
+import * as i2 from "./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;
+                    }
+                }
+            }
+        });
+    }
+    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) => {
+                    // 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;
+        }
+        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.SettingsService }, { 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.SettingsService }, { type: i2.DebugService }, { type: i3.MessageBoardService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"xr.service.js","sourceRoot":"","sources":["../../../../../projects/configurator/src/lib/services/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 '../enum/xr-mode.enum';\r\nimport {SettingsService} from './settings.service';\r\nimport {isNill} from '@colijnit/configuratorapi/build/utils/function/is-nill.function';\r\nimport {DebugService} from './debug.service';\r\nimport {MessageBoardService} from './message-board.service';\r\n\r\n@Injectable({providedIn: 'root'})\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: SettingsService,\r\n    private _debugService: DebugService,\r\n    private _messageBoard: MessageBoardService\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 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\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          // 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    }\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  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"]}