@colijnit/homedecorator 255.1.1

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

@@ -0,0 +1,844 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Injectable } from '@angular/core';
+import * as THREE from 'three';
+import { Box3, DirectionalLight, DoubleSide, LightProbe, Matrix4, Mesh, MeshBasicMaterial, MeshPhongMaterial, PCFSoftShadowMap, PlaneGeometry, Raycaster, Scene, ShadowMaterial, SphereGeometry, SRGBColorSpace, Texture, Vector3 } from 'three';
+import * as TWEEN from '@tweenjs/tween.js';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { ArFeature } from '../enum/ar-feature.enum';
+import { Reticle } from '../../../core/model/xr-reticle';
+import { DepthDataTexture } from '../textures/DepthDataTexture';
+import { ArPositionIndicator } from '../../../core/model/ar-position-indicator';
+import { Utils } from '../core/utils';
+import { MaterialUtils } from '../../../core/utils/material.utils';
+import { ViewMode } from '../../../core/enum/view-mode.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../core/service/view-mode.service";
+import * as i2 from "./camera.service";
+import * as i3 from "../../../core/service/homedecorator-settings.service";
+import * as i4 from "../../../core/service/homedecorator-connector.service";
+export class ArService {
+    constructor(_viewModeService, _cameraService, _settingsService, _iOne) {
+        this._viewModeService = _viewModeService;
+        this._cameraService = _cameraService;
+        this._settingsService = _settingsService;
+        this._iOne = _iOne;
+        this.updateContextMenu = new BehaviorSubject(null);
+        this.shouldAddObjectToScene = new Subject();
+        this.showConfigurator = false;
+        this.userInSelectionMenu = false;
+        this.showContextMenu = false;
+        this._arFeatures = [];
+        this._debug = false;
+        this._surfaceFoundOnce = false;
+        this._aRModelRotationStartingValue = 0;
+        this._vertexList = [];
+        this._detectedPlanes = [];
+        this._rawPlanes = new Set();
+        this._doubleTapTimeframe = 500;
+        this._holdingTouch = false;
+        this._cleanup = true;
+        this._animating = false;
+        this._pointRepresentation = new Mesh(new SphereGeometry(0.02, 12, 12), new MeshBasicMaterial({
+            color: 0x4ccaed,
+            transparent: true,
+            opacity: 0.2
+        }));
+        window.onbeforeunload = () => this.ngOnDestroy();
+    }
+    ngOnDestroy() {
+        Utils.DisposeObject(this._reticle);
+        Utils.DisposeObject(this._sunLight);
+        Utils.DisposeObject(this._pointRepresentation);
+    }
+    resetPlaneDetection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._reticle.visible = false;
+            this._activeARModel.visible = false;
+            this._vertexList = [];
+            this._detectedPlanes.forEach((plane) => this.scene.remove(plane));
+            this._detectedPlanes = [];
+            this.scene.remove(this._positionIndicator);
+            this._rawPlanes = new Set();
+            this._cleanup = false;
+            yield this._session.end();
+            this._cleanup = true;
+            this._session = null;
+            this._initSession();
+        });
+    }
+    endSessionEvent() {
+        this._session.end();
+    }
+    arSupported() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (navigator.xr) {
+                return yield navigator.xr.isSessionSupported('immersive-ar');
+            }
+            else {
+                return false;
+            }
+        });
+    }
+    addObjectToARScene(object) {
+        this._activeARModel = object;
+        this._activeARModel.visible = false;
+        this._activeARModel.castShadow = true;
+        this._activeARModel.receiveShadow = true;
+        this._positionIndicator = new ArPositionIndicator(new Box3().setFromObject(object));
+        this.scene.add(this._activeARModel, this._positionIndicator);
+    }
+    modelLoading() {
+        return !this._activeARModel;
+    }
+    modelPlaced() {
+        return this._activeARModel && this._activeARModel.visible && !this._holdingTouch;
+    }
+    handleFrame(xrFrame) {
+        if (this._session && this._activeARModel) {
+            this._iOne.shouldShowLoader = false;
+            this._checkAvailableFeatures(xrFrame);
+            this._checkHitTestMethod(xrFrame);
+            this._checkExtraFeatures(xrFrame);
+            this._handleHoldMoveEvent();
+            this._handleMultiTouchEvent();
+            if (this._activeARModel.visible) {
+                this.updateContextMenu.next();
+            }
+        }
+        TWEEN.update();
+        this._renderer.render(this.scene, this._cameraService.camera);
+    }
+    init(renderer) {
+        this._iOne.shouldShowLoader = true;
+        if (!this._renderer) {
+            this._renderer = renderer;
+            this._renderer.outputColorSpace = SRGBColorSpace;
+            this._initScene();
+            this._initLighting();
+            this._initController();
+            this._reticle = new Reticle();
+            this.scene.add(this._reticle);
+        }
+        this._initRenderer();
+        this._initSession();
+    }
+    savePreSelectionPosition() {
+        this._aRModelBackupPosition = this._activeARModel.position.clone();
+    }
+    updateChangedModel() {
+        if (this._aRModelBackupPosition) {
+            this._activeARModel.position.set(this._aRModelBackupPosition.x, this._aRModelBackupPosition.y, this._aRModelBackupPosition.z);
+        }
+        if (this._arFeatures.includes(ArFeature.CPUDepthOcclusion)) {
+            this._updateMeshMaterials();
+        }
+    }
+    arModeHasBeenActive() {
+        return this.scene !== undefined;
+    }
+    showMovePhoneAnimation() {
+        return this._activeARModel && !this._reticle.visible && !this._surfaceFoundOnce;
+    }
+    getActiveModel() {
+        return this._activeARModel;
+    }
+    _initSession() {
+        if (!this._session) {
+            const features = {
+                requiredFeatures: ['local-floor', 'hit-test'],
+                optionalFeatures: ['light-estimation', 'depth-sensing', 'plane-detection', 'anchors', 'dom-overlay'],
+                domOverlay: { root: document.getElementById('ar-root') },
+                depthSensing: {
+                    usagePreference: ['cpu-optimized'],
+                    dataFormatPreference: ['luminance-alpha']
+                }
+            };
+            navigator.xr.requestSession('immersive-ar', features).then((session) => {
+                this._renderer.xr.setReferenceSpaceType('local');
+                session.requestReferenceSpace('viewer').then((refSpace) => {
+                    session.requestHitTestSource({ space: refSpace }).then((hitTestSource) => {
+                        this.hitTestSource = hitTestSource;
+                    });
+                });
+                session.requestReferenceSpace('local').then((refSpace) => {
+                    this.refSpace = refSpace;
+                    this._onSessionStarted(session);
+                });
+            });
+        }
+    }
+    _checkAvailableFeatures(xrFrame) {
+        if (this._settingsService.settings.arParameters.depthOcclusion && this._settingsService.settings.arParameters.depthHitTest &&
+            !(this._arFeatures.includes(ArFeature.CPUDepthOcclusion)) && this._session.depthUsage) {
+            this._arFeatures.push(ArFeature.CPUDepthOcclusion, ArFeature.CPUDepthHitTest);
+            this._initCPUDepthOcclusion();
+        }
+        if (this._settingsService.settings.arParameters.anchoredHitTest &&
+            !(this._arFeatures.includes(ArFeature.AnchoredHitTest)) && xrFrame.trackedAnchors) {
+            this._arFeatures.push(ArFeature.AnchoredHitTest);
+            this._initAnchoredHitTest();
+        }
+        if (this._settingsService.settings.arParameters.lightEstimation &&
+            !(this._arFeatures.includes(ArFeature.LightEstimation))) {
+            this._session.requestLightProbe().then((lightProbe) => {
+                if (lightProbe) {
+                    this._arFeatures.push(ArFeature.LightEstimation);
+                    this._initLightEstimation(lightProbe);
+                }
+            });
+        }
+        if (this._settingsService.settings.arParameters.reflectionEstimation &&
+            !(this._arFeatures.includes(ArFeature.ReflectionCubeMap)) && this._lightProbe
+            && this._glBinding.getReflectionCubeMap(this._lightProbe)) {
+            this._arFeatures.push(ArFeature.ReflectionCubeMap);
+            this._initReflectionCubeMap();
+        }
+        if (this._settingsService.settings.arParameters.planeDetection && this._settingsService.settings.arParameters.planeHitTest &&
+            !(this._arFeatures.includes(ArFeature.PlaneDetection)) && xrFrame.worldInformation) {
+            this._arFeatures.push(ArFeature.PlaneDetection, ArFeature.PlaneDetectionHitTest);
+            this._initPlaneDetection();
+        }
+    }
+    _initRenderer() {
+        this._renderer.xr.enabled = true;
+        this._renderer.shadowMap.type = PCFSoftShadowMap;
+        this._renderer.setClearColor(0x000000, 0);
+        this._renderer.autoClear = false;
+    }
+    _initController() {
+        this._tempMatrix = new Matrix4();
+        this._raycaster = new Raycaster();
+        this._controller = this._renderer.xr.getController(0);
+        this.scene.add(this._controller);
+    }
+    _initScene() {
+        this.scene = new Scene();
+        const planeGeometry = new PlaneGeometry(100, 100);
+        const material = new ShadowMaterial({ opacity: 0.2 });
+        this._shadowPlane = new Mesh(planeGeometry, material);
+        this._shadowPlane.name = 'shadowPlane';
+        this._shadowPlane.rotation.x -= Math.PI / 2;
+        this._shadowPlane.receiveShadow = true;
+        this._shadowPlane.visible = false;
+        this.scene.add(this._shadowPlane);
+    }
+    _initLightEstimation(lightProbe) {
+        this._threeLightProbe = new LightProbe();
+        this.scene.add(this._threeLightProbe);
+        this._lightProbe = lightProbe;
+        // @ts-ignore
+        this._glBinding = new XRWebGLBinding(this._session, this._renderer.getContext());
+    }
+    _initReflectionCubeMap() {
+        this._cubeMapTexture = new Texture();
+        this._renderer.initTexture(this._cubeMapTexture);
+        this.scene.environment = this._cubeMapTexture;
+        this._lightProbe.addEventListener('reflectionchange', () => {
+            const rawData = this._glBinding.getReflectionCubeMap(this._lightProbe);
+            const texProps = this._renderer.properties.get(this._cubeMapTexture);
+            texProps.__webglTexture = rawData;
+        });
+    }
+    _initCPUDepthOcclusion() {
+        this._depthDataTexture = new DepthDataTexture();
+        this._updateMeshMaterials();
+    }
+    _initAnchoredHitTest() {
+        this._anchoredObjects = [];
+    }
+    _initPlaneDetection() {
+        this._createPlaneMaterial();
+    }
+    _initLighting() {
+        const ambientLight = new THREE.AmbientLight(0xffffff, 0.1);
+        ambientLight.color.setHex(0xffffff).convertSRGBToLinear();
+        ambientLight.name = 'ambientLight';
+        this._sunLight = new DirectionalLight('black', 0.3);
+        this._sunLight.castShadow = true;
+        this._sunLight.shadow.mapSize.width = 4096;
+        this._sunLight.shadow.mapSize.height = 4096;
+        this._sunLight.shadow.camera.left = -10;
+        this._sunLight.shadow.camera.right = 10;
+        this._sunLight.shadow.camera.top = 10;
+        this._sunLight.shadow.camera.bottom = -10;
+        this._sunLight.shadow.camera.near = 0.1;
+        this._sunLight.shadow.camera.far = 30;
+        this._sunLight.visible = true;
+        this._sunLight.target.visible = true;
+        this._sunLight.name = 'sunLight';
+        this.scene.add(/*ambientLight, */ this._sunLight.target, this._sunLight);
+    }
+    _checkHitTestMethod(xrFrame) {
+        if (this._arFeatures.includes(ArFeature.CPUDepthOcclusion) && this._arFeatures.includes(ArFeature.AnchoredHitTest)) {
+            this._executeDepthAnchorHitTest(xrFrame);
+        }
+        else if (this._arFeatures.includes(ArFeature.AnchoredHitTest)) {
+            this._executeAnchoredHitTest(xrFrame);
+        }
+        else if (this._arFeatures.includes(ArFeature.CPUDepthHitTest)) {
+            this._executeCPUDepthHitTest(xrFrame);
+        }
+        else {
+            this._executeDefaultHitTest(xrFrame);
+        }
+    }
+    _executeDepthAnchorHitTest(xrFrame) {
+        const xrViewerPose = xrFrame.getViewerPose(this.refSpace);
+        const xrCamera = this._renderer.xr.getCamera( /*this._cameraService.camera*/); // todo: due to threejs update parameter not needed anymore, check this!
+        this._reticle.visible = false;
+        if (this.hitTestSource && xrViewerPose) {
+            const hitTestResults = xrFrame.getHitTestResults(this.hitTestSource);
+            if (hitTestResults.length === 0) {
+                if (xrViewerPose.views.length > 0 && xrCamera) {
+                    for (const view of xrViewerPose.views) {
+                        if (!this._activeARModel.visible) {
+                            const depthData = xrFrame.getDepthInformation(view);
+                            // Place object as soon as depth data is available and distance is within reasonable values
+                            if (depthData && depthData.getDepthInMeters(0.5, 0.5) > 0.1 && depthData.getDepthInMeters(0.5, 0.5) < 2.5) {
+                                this._activeARModel.position.set(xrCamera.position.x, xrCamera.position.y, xrCamera.position.z);
+                                this._activeARModel.rotation.setFromQuaternion(xrCamera.quaternion);
+                                this._activeARModel.translateZ(-depthData.getDepthInMeters(0.5, 0.5));
+                                this._activeARModel.position.y += 0.02;
+                                this._activeARModel.rotation.set(0, 0, 0);
+                                this._activeARModel.visible = true;
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                // When hit test results are available we switch to the anchored hit test method and place the model accordingly
+                this._executeAnchoredHitTest(xrFrame);
+                if (this._anchoredObjects.length === 0) {
+                    this._handleTouchEvent(false);
+                }
+            }
+        }
+    }
+    _executeAnchoredHitTest(xrFrame) {
+        this._executeDefaultHitTest(xrFrame);
+        for (const { anchoredObject, anchor } of this._anchoredObjects) {
+            if (!xrFrame.trackedAnchors.has(anchor)) {
+                continue;
+            }
+            const anchorPose = xrFrame.getPose(anchor.anchorSpace, this.refSpace);
+            if (anchorPose) {
+                const hitMatrix = new Matrix4().fromArray(anchorPose.transform.matrix);
+                anchoredObject.position.setFromMatrixPosition(hitMatrix);
+            }
+        }
+    }
+    _executeCPUDepthHitTest(xrFrame) {
+        const xrViewerPose = xrFrame.getViewerPose(this.refSpace);
+        const xrCamera = this._renderer.xr.getCamera( /*this._cameraService.camera*/); // todo: due to threejs update parameter not needed anymore, check this!
+        this._reticle.visible = false;
+        if (xrViewerPose && xrViewerPose.views.length > 0 && xrCamera) {
+            for (const view of xrViewerPose.views) {
+                if (!this._activeARModel.visible) {
+                    this._reticle.visible = true;
+                    this._surfaceFoundOnce = true;
+                }
+                const depthData = xrFrame.getDepthInformation(view);
+                if (depthData) {
+                    this._reticle.position.set(xrCamera.position.x, xrCamera.position.y, xrCamera.position.z);
+                    this._reticle.rotation.setFromQuaternion(xrCamera.quaternion);
+                    this._reticle.translateZ(-depthData.getDepthInMeters(0.5, 0.5));
+                    this._reticle.position.y += 0.02;
+                    this._reticle.rotation.set(0, 0, 0);
+                }
+            }
+        }
+    }
+    _executeDefaultHitTest(xrFrame) {
+        const xrViewerPose = xrFrame.getViewerPose(this.refSpace);
+        this._reticle.visible = false;
+        if (this.hitTestSource && xrViewerPose) {
+            const hitTestResults = xrFrame.getHitTestResults(this.hitTestSource);
+            if (hitTestResults.length > 0) {
+                const pose = hitTestResults[0].getPose(this.refSpace);
+                if (!this._activeARModel.visible) {
+                    this._reticle.visible = true;
+                    this._surfaceFoundOnce = true;
+                }
+                const hitMatrix = new Matrix4().fromArray(pose.transform.matrix);
+                this._hitTestResult = hitMatrix;
+                this._reticle.position.setFromMatrixPosition(hitMatrix);
+                this._reticle.position.y += 0.02; // Prevents z-fighting
+                this._reticleHitTestResult = hitTestResults[0];
+            }
+        }
+    }
+    _checkExtraFeatures(xrFrame) {
+        if (this._arFeatures.includes(ArFeature.LightEstimation)) {
+            this._adjustLighting(xrFrame);
+        }
+        if (this._arFeatures.includes(ArFeature.CPUDepthOcclusion)) {
+            this._hideOccludedMeshes(xrFrame);
+        }
+        // if (this._arFeatures.includes(ArFeature.PlaneDetection)) {
+        //   this._drawPlanes(xrFrame);
+        // }
+    }
+    _hideOccludedMeshes(xrFrame) {
+        const xrViewerPose = xrFrame.getViewerPose(this.refSpace);
+        if (xrViewerPose && xrViewerPose.views.length > 0) {
+            for (const view of xrViewerPose.views) {
+                const depthData = xrFrame.getDepthInformation(view);
+                if (depthData) {
+                    this._depthDataTexture.updateDepth(depthData);
+                    this._updateAugmentedMaterialUniforms(depthData.normDepthBufferFromNormView.matrix);
+                }
+            }
+        }
+    }
+    _createPlaneMaterial() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pm = new MeshPhongMaterial({ transparent: true, side: DoubleSide });
+            pm.map = yield MaterialUtils.FromUrl('assets/textures/Floor/Tiles/ar_floor_texture.png', false, 1, 2, 2);
+            pm.map.flipY = false;
+            pm.needsUpdate = true;
+            this._planeMaterial = pm;
+        });
+    }
+    _onSessionStarted(session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const domOverlay = document.getElementById('ar-root');
+            session.addEventListener('end', this._onSessionEnded.bind(this));
+            session.addEventListener('select', () => this._handleTouchEvent());
+            session.addEventListener('selectstart', ($event) => this._handleHoldStartEvent($event));
+            session.addEventListener('selectend', ($event) => this._handleHoldEndEvent($event));
+            domOverlay.addEventListener('beforexrselect', ($event) => this._checkingInterfaceInteraction($event));
+            yield this._renderer.getContext().makeXRCompatible();
+            this._renderer.xr.setSession(session);
+            this._session = session;
+        });
+    }
+    _onSessionEnded() {
+        if (this._cleanup) {
+            this._session = null;
+            this._surfaceFoundOnce = false;
+            this._reticle.visible = false;
+            this.scene.remove(this._positionIndicator);
+            this._activeARModel.visible = true;
+            this._activeARModel.position.set(0, 0, 0);
+            this._removeMaterialShaders();
+            this.shouldAddObjectToScene.next(this._activeARModel);
+            this._activeARModel = null;
+            this._holdingTouch = false;
+            this._arFeatures = [];
+            this._lightProbe = null;
+            this._vertexList = [];
+            this._detectedPlanes = [];
+            this._rawPlanes = new Set();
+            this._renderer.xr.enabled = false;
+            this._renderer.shadowMap.type = PCFSoftShadowMap;
+            this._renderer.setClearColor(0xfafafa);
+            this._renderer.autoClear = true;
+            this._viewModeService.viewMode = ViewMode.RoomPlan3D;
+        }
+    }
+    _setArModelShadows() {
+        if (this._activeARModel) {
+            this._activeARModel.traverse((node) => {
+                if (node instanceof Mesh) {
+                    node.castShadow = true;
+                    node.receiveShadow = true;
+                }
+            });
+        }
+    }
+    _handleTouchEvent(manualTouch = true) {
+        this._handleDoubleTapEvent();
+        if (manualTouch) {
+            if (this._reticle.visible && !this._activeARModel.visible) {
+                if (this._arFeatures.includes(ArFeature.AnchoredHitTest)) {
+                    this._activeARModel.position.copy(this._reticle.position);
+                    this._reticleHitTestResult.createAnchor().then((anchor) => {
+                        this._anchoredObjects.push({
+                            anchoredObject: this._shadowPlane,
+                            anchor: anchor
+                        });
+                    }).catch((e) => {
+                        // Unable to create anchor
+                    });
+                }
+                else {
+                    this._activeARModel.position.copy(this._reticle.position);
+                    this._aRModelBackupYPosition = this._reticle.position.y;
+                    this._shadowPlane.position.copy(this._reticle.position);
+                    this._positionIndicator.position.copy(this._reticle.position);
+                }
+            }
+        }
+        else {
+            if (this._arFeatures.includes(ArFeature.AnchoredHitTest)) {
+                this._activeARModel.position.copy(this._reticle.position);
+                this._reticleHitTestResult.createAnchor().then((anchor) => {
+                    this._anchoredObjects.push({
+                        anchoredObject: this._shadowPlane,
+                        anchor: anchor
+                    });
+                }).catch((e) => {
+                    // Unable to create anchor
+                });
+            }
+            else {
+                this._activeARModel.position.copy(this._reticle.position);
+                this._aRModelBackupYPosition = this._reticle.position.y;
+                this._shadowPlane.position.copy(this._reticle.position);
+                this._positionIndicator.position.copy(this._reticle.position);
+            }
+        }
+        this._activeARModel.visible = true;
+        this._shadowPlane.visible = true;
+        this._positionIndicator.visible = true;
+        this._setArModelShadows();
+        this._setPlanesVisibilty(false);
+    }
+    _handleMultiTouchEvent() {
+        const inputSources = this._session.inputSources;
+        if (inputSources.length === 2 && this._activeARModel.visible && !this._holdingTouch) {
+            this._aRModelBackupYRotation = this._aRModelBackupYRotation === 0 ? this._activeARModel.rotation.y / 2 : this._aRModelBackupYRotation;
+            const dx = inputSources[1].gamepad.axes[0] - inputSources[0].gamepad.axes[0];
+            const dy = inputSources[1].gamepad.axes[1] - inputSources[0].gamepad.axes[1];
+            const angle = Math.atan2(dy, dx);
+            this._aRModelRotationStartingValue = this._aRModelRotationStartingValue === 0 ? angle : this._aRModelRotationStartingValue;
+            const difference = this._aRModelBackupYRotation - (angle - this._aRModelRotationStartingValue);
+            this._activeARModel.rotation.y = this._aRModelBackupYRotation + difference;
+        }
+        else {
+            this._aRModelBackupYRotation = 0;
+            this._aRModelRotationStartingValue = 0;
+        }
+    }
+    _handleDoubleTapEvent() {
+        const intersections = this._getObjectIntersections([this._activeARModel]);
+        if (intersections.length > 0) {
+            const currentTimestamp = Date.now();
+            this.showContextMenu = this._lastObjectTouchTimestamp && currentTimestamp - this._lastObjectTouchTimestamp < this._doubleTapTimeframe;
+            this._lastObjectTouchTimestamp = currentTimestamp;
+        }
+        else {
+            this.showContextMenu = false;
+        }
+    }
+    _checkIfHoldTouchEvent($event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            setTimeout(() => {
+                if (!this.userInSelectionMenu && this._lastEventTimestamp === $event.timeStamp && this._session.inputSources.length === 1) {
+                    this._holdingTouch = true;
+                    this._toggleHoldTouchEvent();
+                }
+            }, 200);
+        });
+    }
+    _handleHoldStartEvent($event) {
+        this._lastEventTimestamp = $event.timeStamp;
+        this._checkIfHoldTouchEvent($event);
+    }
+    _handleHoldEndEvent($event) {
+        this._lastEventTimestamp = $event.timeStamp;
+        if (this._holdingTouch) {
+            this._holdingTouch = false;
+            this._toggleHoldTouchEvent();
+        }
+    }
+    _toggleHoldTouchEvent() {
+        if (this._holdingTouch) {
+            // this._setPlanesVisibilty(true);
+            this._callLiftAnimation();
+        }
+        else {
+            this._callDropAnimation();
+            this._setPlanesVisibilty(false);
+            this._activeARModel.position.y = this._aRModelBackupYPosition;
+        }
+        this._toggleARModelTransparency();
+    }
+    _handleHoldMoveEvent() {
+        if (this._holdingTouch && !this.userInSelectionMenu) {
+            const intersections = this._getObjectIntersections([this._shadowPlane]);
+            if (intersections.length > 0) {
+                const movePosition = !this._animating ? new Vector3(intersections[0].point.x, intersections[0].point.y + 0.2, intersections[0].point.z) :
+                    new Vector3(intersections[0].point.x, this._activeARModel.position.y, intersections[0].point.z);
+                this._activeARModel.position.copy(movePosition);
+                this._aRModelBackupYPosition = intersections[0].point.y;
+                this._positionIndicator.position.copy(intersections[0].point);
+                this._updateShadows(intersections[0].point);
+            }
+        }
+    }
+    _updateShadows(centerPosition) {
+        this._shadowPlane.position.copy(centerPosition);
+        this.scene.traverse((node) => {
+            if (node instanceof DirectionalLight) {
+                node.target.position.copy(centerPosition);
+                node.shadow.camera.updateProjectionMatrix();
+            }
+        });
+    }
+    _adjustLighting(frame) {
+        const lightEstimate = frame.getLightEstimate(this._lightProbe);
+        if (lightEstimate) {
+            this._threeLightProbe.sh.fromArray(lightEstimate.sphericalHarmonicsCoefficients);
+            const intensity = Math.max(1.0, Math.max(lightEstimate.primaryLightIntensity.x, Math.max(lightEstimate.primaryLightIntensity.y, lightEstimate.primaryLightIntensity.z)));
+            this._sunLight.position.set(lightEstimate.primaryLightDirection.x, lightEstimate.primaryLightDirection.y, lightEstimate.primaryLightDirection.z);
+            this._sunLight.color.setRGB(lightEstimate.primaryLightIntensity.x / intensity, lightEstimate.primaryLightIntensity.y / intensity, lightEstimate.primaryLightIntensity.z / intensity);
+            this._sunLight.intensity = intensity;
+        }
+    }
+    _toggleARModelTransparency() {
+        this._activeARModel.traverse((node) => {
+            if (node instanceof Mesh) {
+                const materials = !Array.isArray(node.material) ? [node.material] : node.material;
+                materials.forEach(material => {
+                    material.transparent = this._holdingTouch;
+                    material.opacity = this._holdingTouch ? 0.5 : 1;
+                    material.needsUpdate = true;
+                });
+            }
+        });
+    }
+    _setPlanesVisibilty(visible) {
+        this._detectedPlanes.forEach((plane) => plane.visible = visible);
+    }
+    _getObjectIntersections(objects) {
+        this._tempMatrix.identity().extractRotation(this._controller.matrixWorld);
+        this._raycaster.ray.origin.setFromMatrixPosition(this._controller.matrixWorld);
+        this._raycaster.ray.direction.set(0, 0, -1).applyMatrix4(this._tempMatrix);
+        return this._raycaster.intersectObjects(objects);
+    }
+    // TODO: Needs to be made compatible with BufferGeometry if we want to keep plane detection visualization
+    _drawPlane(vertices, planePose) {
+        // const hitMatrix = new Matrix4().fromArray(planePose.transform.matrix);
+        // const pointGroup = new Group();
+        //
+        // // Create vertices
+        // vertices.forEach((vertex) => {
+        //   if (this._debug) {
+        //     const point = this._pointRepresentation.clone();
+        //     point.position.set(vertex.x, 0, vertex.z);
+        //     pointGroup.add(point);
+        //   }
+        //   this._vertexList.push(new DOMPoint(vertex.x, vertex.z));
+        // });
+        //
+        // if (this._debug) {
+        //   pointGroup.position.setFromMatrixPosition(hitMatrix);
+        //   this.scene.add(pointGroup);
+        // }
+        //
+        // // Generate polygon from vertices
+        // const hull = makeHull(this._vertexList);
+        // const geometry = new BufferGeometry();
+        // const vectorTwoList = hull.map((point) => new Vector2(point.x, point.y));
+        // const vectorThreeList = hull.map((point) => new Vector3(point.x, this._detectedPlanes.length > 0 ? this._detectedPlanes[0].position.y : 0, point.y));
+        // const faceArray = ShapeUtils.triangulateShape(vectorTwoList, []);
+        // geometry.vertices.push(...vectorThreeList);
+        //
+        // // Generate faces
+        // for (let i = 0; i < faceArray.length; i++) {
+        //   geometry.faces.push(new THREE.Face3(faceArray[i][0], faceArray[i][1], faceArray[i][2]));
+        // }
+        // geometry.computeVertexNormals();
+        // geometry.normalize();
+        //
+        // // Generate UV's
+        // geometry.computeBoundingBox();
+        // const max = geometry.boundingBox.max, min = geometry.boundingBox.min;
+        // const offset = new THREE.Vector2(0 - min.x, 0 - min.z);
+        // const range = new THREE.Vector2(max.x - min.x, max.z - min.z);
+        // const faces = geometry.faces;
+        // geometry.faceVertexUvs[0] = [];
+        //
+        // for (let i = 0; i < faces.length; i++) {
+        //   const v1 = geometry.vertices[faces[i].a],
+        //     v2 = geometry.vertices[faces[i].b],
+        //     v3 = geometry.vertices[faces[i].c];
+        //
+        //   geometry.faceVertexUvs[0].push([
+        //     new THREE.Vector2((v1.x + offset.x) / range.x, (v1.z + offset.y) / range.y),
+        //     new THREE.Vector2((v2.x + offset.x) / range.x, (v2.z + offset.y) / range.y),
+        //     new THREE.Vector2((v3.x + offset.x) / range.x, (v3.z + offset.y) / range.y)
+        //   ]);
+        // }
+        // geometry.uvsNeedUpdate = true;
+        //
+        // // Create and set plane
+        // const mesh = new Mesh(geometry, this._planeMaterial);
+        // mesh.position.setFromMatrixPosition(hitMatrix);
+        // this._detectedPlanes.push(mesh);
+        // this.scene.add(mesh);
+    }
+    _drawPlanes(xrFrame) {
+        if (!this._activeARModel.visible) {
+            const planesDetected = xrFrame.worldInformation.detectedPlanes;
+            if (planesDetected.size > 0) {
+                planesDetected.forEach(plane => {
+                    if (!this._rawPlanes.has(plane)) {
+                        const planePose = xrFrame.getPose(plane.planeSpace, this.refSpace);
+                        if (planePose) {
+                            this._rawPlanes.add(plane);
+                            const planeVertices = plane.polygon;
+                            this._drawPlane(planeVertices, planePose);
+                        }
+                    }
+                });
+            }
+        }
+    }
+    _callLiftAnimation() {
+        this._animating = true;
+        const position = this._activeARModel.position.clone();
+        const targetPosition = new Vector3(this._activeARModel.position.x, this._activeARModel.position.y + 0.2, this._activeARModel.position.z);
+        this._liftAnimation = new TWEEN.Tween(position)
+            .to(targetPosition, 500)
+            .easing(TWEEN.Easing.Quadratic.Out)
+            .onUpdate(() => this._activeARModel.position.copy(new Vector3(this._activeARModel.position.x, position.y, this._activeARModel.position.z)))
+            .onComplete(() => this._animating = false);
+        this._liftAnimation.start();
+    }
+    _callDropAnimation() {
+        this._animating = true;
+        const position = this._activeARModel.position.clone();
+        const targetPosition = new Vector3(this._activeARModel.position.x, this._activeARModel.position.y - 0.2, this._activeARModel.position.z);
+        this._dropAnimation = new TWEEN.Tween(position)
+            .to(targetPosition, 500)
+            .easing(TWEEN.Easing.Quadratic.Out)
+            .onUpdate(() => this._activeARModel.position.copy(new Vector3(this._activeARModel.position.x, position.y, this._activeARModel.position.z)))
+            .onComplete(() => this._animating = false);
+        this._dropAnimation.start();
+    }
+    _createAugmentedMaterial(material, depthMap) {
+        material.userData = {
+            uDepthTexture: { value: depthMap },
+            uWidth: { value: 1.0 },
+            uHeight: { value: 1.0 },
+            uUvTransform: { value: new Matrix4() },
+            uOcclusionEnabled: { value: true }
+        };
+        material.userData.isAgumentedMaterial = true;
+        material.onBeforeCompile = (shader) => {
+            // Pass uniforms from userData to the
+            for (const i in material.userData) {
+                shader.uniforms[i] = material.userData[i];
+            }
+            // Fragment variables
+            shader.fragmentShader = `
+			uniform sampler2D uDepthTexture;
+			uniform float uWidth;
+			uniform float uHeight;
+			uniform mat4 uUvTransform;
+			uniform bool uOcclusionEnabled;
+			varying float vDepth;
+			` + shader.fragmentShader;
+            let fragmentEntryPoint = '#include <clipping_planes_fragment>';
+            if (material instanceof ShadowMaterial) {
+                fragmentEntryPoint = '#include <fog_fragment>';
+            }
+            // Fragment depth logic
+            shader.fragmentShader = shader.fragmentShader.replace('void main', `float getDepthInMillimeters(in sampler2D depthText, in vec2 uv)
+			{
+				vec2 packedDepth = texture2D(depthText, uv).ra;
+				return dot(packedDepth, vec2(255.0, 65280.0));
+			}
+			void main`);
+            shader.fragmentShader = shader.fragmentShader.replace(fragmentEntryPoint, `
+			${fragmentEntryPoint}
+				// Normalize x, y to range [0, 1]
+				float x = gl_FragCoord.x / uWidth;
+				float y = gl_FragCoord.y / uHeight;
+				vec2 texCoord = (uUvTransform * vec4(x, 1.0 - y, 0.0, 1.0)).xy;
+				float depth = getDepthInMillimeters(uDepthTexture, texCoord) / 1000.0;
+				if (depth < vDepth)
+				{
+					discard;
+				}
+			`);
+            // Vertex variables
+            shader.vertexShader = `
+			varying float vDepth;
+			` + shader.vertexShader;
+            // Vertex depth logic
+            shader.vertexShader = shader.vertexShader.replace('#include <fog_vertex>', `
+			#include <fog_vertex>
+			vDepth = gl_Position.z;
+			`);
+        };
+        return material;
+    }
+    _updateAugmentedMaterialUniforms(normTextureFromNormViewMatrix) {
+        this.scene.traverse((child) => {
+            if (child instanceof Mesh && child.material) {
+                if (child.material instanceof Array) {
+                    for (const material of child.material) {
+                        if (material.userData.isAgumentedMaterial) {
+                            material.userData.uWidth.value = Math.floor(window.devicePixelRatio * window.innerWidth);
+                            material.userData.uHeight.value = Math.floor(window.devicePixelRatio * window.innerHeight);
+                            material.userData.uUvTransform.value.fromArray(normTextureFromNormViewMatrix);
+                            material.needsUpdate = true;
+                        }
+                    }
+                }
+                else if (child.userData.isAgumentedMaterial) {
+                    child.material.userData.uWidth.value = Math.floor(window.devicePixelRatio * window.innerWidth);
+                    child.material.userData.uHeight.value = Math.floor(window.devicePixelRatio * window.innerHeight);
+                    child.material.userData.uUvTransform.value.fromArray(normTextureFromNormViewMatrix);
+                    child.material.needsUpdate = true;
+                }
+            }
+        });
+    }
+    _updateMeshMaterials() {
+        this.scene.traverse((object) => {
+            if (object instanceof Mesh) {
+                if (object.material instanceof Array) {
+                    for (let material of object.material) {
+                        material = this._createAugmentedMaterial(material, this._depthDataTexture);
+                    }
+                }
+                else {
+                    object.material = this._createAugmentedMaterial(object.material, this._depthDataTexture);
+                }
+            }
+        });
+    }
+    _removeMaterialShaders() {
+        this.scene.traverse((object) => {
+            if (object instanceof Mesh) {
+                if (object.material instanceof Array) {
+                    for (const material of object.material) {
+                        material.onBeforeCompile = (shader) => {
+                            shader = null;
+                        };
+                    }
+                }
+                else {
+                    object.material.onBeforeCompile = (shader) => {
+                        shader = null;
+                    };
+                }
+            }
+        });
+    }
+    _checkingInterfaceInteraction(event) {
+        this.userInSelectionMenu = event.path.filter((entry) => entry.localName === 'ar-gui-configurator').length > 0;
+    }
+}
+ArService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ArService, deps: [{ token: i1.ViewModeService }, { token: i2.CameraService }, { token: i3.HomedecoratorSettingsService }, { token: i4.HomedecoratorConnectorService }], target: i0.ɵɵFactoryTarget.Injectable });
+ArService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ArService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ArService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ViewModeService }, { type: i2.CameraService }, { type: i3.HomedecoratorSettingsService }, { type: i4.HomedecoratorConnectorService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ar.service.js","sourceRoot":"","sources":["../../../../../../../src/client/app/plugins/core3d/service/ar.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\r\nimport * as THREE from 'three';\r\nimport {\r\n  Box3,\r\n  DirectionalLight,\r\n  DoubleSide,\r\n  Intersection,\r\n  LightProbe,\r\n  Material,\r\n  Matrix4,\r\n  Mesh,\r\n  MeshBasicMaterial,\r\n  MeshPhongMaterial,\r\n  Object3D,\r\n  PCFSoftShadowMap,\r\n  PlaneGeometry,\r\n  Raycaster,\r\n  Scene,\r\n  ShadowMaterial,\r\n  SphereGeometry,\r\n  SpotLight,\r\n  SRGBColorSpace,\r\n  Texture,\r\n  Vector3,\r\n  WebGLRenderer\r\n} from 'three';\r\nimport * as TWEEN from '@tweenjs/tween.js';\r\nimport {BehaviorSubject, Subject} from 'rxjs';\r\nimport {ArFeature} from '../enum/ar-feature.enum';\r\nimport {Reticle} from '../../../core/model/xr-reticle';\r\nimport {DepthDataTexture} from '../textures/DepthDataTexture';\r\nimport {ArPositionIndicator} from '../../../core/model/ar-position-indicator';\r\nimport {ViewModeService} from '../../../core/service/view-mode.service';\r\nimport {CameraService} from './camera.service';\r\nimport {HomedecoratorSettingsService} from '../../../core/service/homedecorator-settings.service';\r\nimport {HomedecoratorConnectorService} from '../../../core/service/homedecorator-connector.service';\r\nimport {Utils} from '../core/utils';\r\nimport {MaterialUtils} from '../../../core/utils/material.utils';\r\nimport {ViewMode} from '../../../core/enum/view-mode.enum';\r\n\r\ninterface Point {\r\n  x: number;\r\n  y: number;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ArService implements OnDestroy {\r\n\r\n  public updateContextMenu: BehaviorSubject<void> = new BehaviorSubject<void>(null);\r\n\r\n  public shouldAddObjectToScene: Subject<Object3D> = new Subject<Object3D>();\r\n  public showConfigurator: boolean = false;\r\n\r\n  public refSpace: any;\r\n  public hitTestSource: any;\r\n  public scene: Scene;\r\n  public userInSelectionMenu: boolean = false;\r\n  public showContextMenu: boolean = false;\r\n\r\n  private _arFeatures: ArFeature[] = [];\r\n  private _renderer: WebGLRenderer;\r\n  private _glBinding: any;\r\n  private _session: any;\r\n  private _debug: boolean = false;\r\n  private _surfaceFoundOnce = false;\r\n\r\n  private _reticle: Reticle;\r\n  private _hitTestResult: Matrix4;\r\n  private _reticleHitTestResult: any;\r\n  private _anchoredObjects: {anchoredObject: Object3D, anchor: any}[];\r\n  private _activeARModel: Object3D;\r\n  private _aRModelBackupYPosition: number;\r\n  private _aRModelBackupPosition: Vector3;\r\n  private _aRModelBackupYRotation: number;\r\n  private _aRModelRotationStartingValue: number = 0;\r\n  private _vertexList: Array<Point> = [];\r\n  private _detectedPlanes: Mesh[] = [];\r\n  private _rawPlanes: Set<any> = new Set();\r\n  private _planeMaterial: MeshPhongMaterial;\r\n  private _shadowPlane: Mesh;\r\n\r\n  private _lastEventTimestamp: number;\r\n  private _lastObjectTouchTimestamp: number;\r\n  private _doubleTapTimeframe: number = 500;\r\n  private _holdingTouch: boolean = false;\r\n  private _controller: any;\r\n  private _raycaster: Raycaster;\r\n  private _tempMatrix: Matrix4;\r\n  private _cleanup: boolean = true;\r\n\r\n  private _animating: boolean = false;\r\n  private _liftAnimation: TWEEN.Tween;\r\n  private _dropAnimation: TWEEN.Tween;\r\n\r\n  private _lightProbe: any;\r\n  private _threeLightProbe: LightProbe;\r\n  private _cubeMapTexture: Texture;\r\n  private _depthDataTexture: DepthDataTexture;\r\n  private _sunLight: SpotLight | DirectionalLight;\r\n\r\n  private _positionIndicator: ArPositionIndicator;\r\n\r\n  private _pointRepresentation = new Mesh(\r\n    new SphereGeometry(0.02, 12, 12),\r\n    new MeshBasicMaterial({\r\n      color: 0x4ccaed,\r\n      transparent: true,\r\n      opacity: 0.2\r\n    })\r\n  );\r\n\r\n  constructor(\r\n    private _viewModeService: ViewModeService,\r\n    private _cameraService: CameraService,\r\n    private _settingsService: HomedecoratorSettingsService,\r\n    private _iOne: HomedecoratorConnectorService) {\r\n    window.onbeforeunload = () => this.ngOnDestroy();\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    Utils.DisposeObject(this._reticle);\r\n    Utils.DisposeObject(this._sunLight);\r\n    Utils.DisposeObject(this._pointRepresentation);\r\n  }\r\n\r\n  public async resetPlaneDetection() {\r\n    this._reticle.visible = false;\r\n    this._activeARModel.visible = false;\r\n    this._vertexList = [];\r\n    this._detectedPlanes.forEach((plane) => this.scene.remove(plane));\r\n    this._detectedPlanes = [];\r\n    this.scene.remove(this._positionIndicator);\r\n    this._rawPlanes = new Set<any>();\r\n    this._cleanup = false;\r\n    await this._session.end();\r\n    this._cleanup = true;\r\n    this._session = null;\r\n    this._initSession();\r\n  }\r\n\r\n  public endSessionEvent(): void {\r\n    this._session.end();\r\n  }\r\n\r\n  public async arSupported() {\r\n    if ((navigator as any).xr) {\r\n      return await (navigator as any).xr.isSessionSupported('immersive-ar');\r\n    } else {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  public addObjectToARScene(object: Object3D): void {\r\n    this._activeARModel = object;\r\n    this._activeARModel.visible = false;\r\n    this._activeARModel.castShadow = true;\r\n    this._activeARModel.receiveShadow = true;\r\n    this._positionIndicator = new ArPositionIndicator(new Box3().setFromObject(object));\r\n    this.scene.add(this._activeARModel, this._positionIndicator);\r\n  }\r\n\r\n  public modelLoading(): boolean {\r\n    return !this._activeARModel;\r\n  }\r\n\r\n  public modelPlaced(): boolean {\r\n    return this._activeARModel && this._activeARModel.visible && !this._holdingTouch;\r\n  }\r\n\r\n  public handleFrame(xrFrame): void {\r\n    if (this._session && this._activeARModel) {\r\n      this._iOne.shouldShowLoader = false;\r\n      this._checkAvailableFeatures(xrFrame);\r\n      this._checkHitTestMethod(xrFrame);\r\n      this._checkExtraFeatures(xrFrame);\r\n      this._handleHoldMoveEvent();\r\n      this._handleMultiTouchEvent();\r\n\r\n      if (this._activeARModel.visible) {\r\n        this.updateContextMenu.next();\r\n      }\r\n    }\r\n    TWEEN.update();\r\n    this._renderer.render(this.scene, this._cameraService.camera);\r\n  }\r\n\r\n  public init(renderer: WebGLRenderer): void {\r\n    this._iOne.shouldShowLoader = true;\r\n    if (!this._renderer) {\r\n      this._renderer = renderer;\r\n      this._renderer.outputColorSpace = SRGBColorSpace;\r\n      this._initScene();\r\n      this._initLighting();\r\n      this._initController();\r\n\r\n      this._reticle = new Reticle();\r\n      this.scene.add(this._reticle);\r\n    }\r\n    this._initRenderer();\r\n    this._initSession();\r\n  }\r\n\r\n  public savePreSelectionPosition() {\r\n    this._aRModelBackupPosition = this._activeARModel.position.clone();\r\n  }\r\n\r\n  public updateChangedModel() {\r\n    if (this._aRModelBackupPosition) {\r\n      this._activeARModel.position.set(this._aRModelBackupPosition.x, this._aRModelBackupPosition.y, this._aRModelBackupPosition.z);\r\n    }\r\n    if (this._arFeatures.includes(ArFeature.CPUDepthOcclusion)) {\r\n      this._updateMeshMaterials();\r\n    }\r\n  }\r\n\r\n  public arModeHasBeenActive(): boolean {\r\n    return this.scene !== undefined;\r\n  }\r\n\r\n  public showMovePhoneAnimation(): boolean {\r\n    return this._activeARModel && !this._reticle.visible && !this._surfaceFoundOnce;\r\n  }\r\n\r\n  public getActiveModel(): any {\r\n    return this._activeARModel;\r\n  }\r\n\r\n  private _initSession(): void {\r\n    if (!this._session) {\r\n      const features = {\r\n        requiredFeatures: ['local-floor', 'hit-test'],\r\n        optionalFeatures: ['light-estimation', 'depth-sensing', 'plane-detection', 'anchors', 'dom-overlay']\r\n        , domOverlay: {root: document.getElementById('ar-root')}\r\n        , depthSensing: {\r\n          usagePreference: ['cpu-optimized'],\r\n          dataFormatPreference: ['luminance-alpha']\r\n        }\r\n      };\r\n\r\n      (navigator as any).xr.requestSession('immersive-ar', features).then((session) => {\r\n        this._renderer.xr.setReferenceSpaceType('local');\r\n\r\n        session.requestReferenceSpace('viewer').then((refSpace) => {\r\n          session.requestHitTestSource({space: refSpace}).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    }\r\n  }\r\n\r\n  private _checkAvailableFeatures(xrFrame: any) {\r\n    if (this._settingsService.settings.arParameters.depthOcclusion && this._settingsService.settings.arParameters.depthHitTest &&\r\n      !(this._arFeatures.includes(ArFeature.CPUDepthOcclusion)) && this._session.depthUsage) {\r\n      this._arFeatures.push(ArFeature.CPUDepthOcclusion, ArFeature.CPUDepthHitTest);\r\n      this._initCPUDepthOcclusion();\r\n    }\r\n\r\n    if (this._settingsService.settings.arParameters.anchoredHitTest &&\r\n      !(this._arFeatures.includes(ArFeature.AnchoredHitTest)) && xrFrame.trackedAnchors) {\r\n      this._arFeatures.push(ArFeature.AnchoredHitTest);\r\n      this._initAnchoredHitTest();\r\n    }\r\n\r\n    if (this._settingsService.settings.arParameters.lightEstimation &&\r\n      !(this._arFeatures.includes(ArFeature.LightEstimation))) {\r\n      this._session.requestLightProbe().then((lightProbe: any) => {\r\n        if (lightProbe) {\r\n          this._arFeatures.push(ArFeature.LightEstimation);\r\n          this._initLightEstimation(lightProbe);\r\n        }\r\n      });\r\n    }\r\n\r\n    if (this._settingsService.settings.arParameters.reflectionEstimation &&\r\n      !(this._arFeatures.includes(ArFeature.ReflectionCubeMap)) && this._lightProbe\r\n      && this._glBinding.getReflectionCubeMap(this._lightProbe)) {\r\n      this._arFeatures.push(ArFeature.ReflectionCubeMap);\r\n      this._initReflectionCubeMap();\r\n    }\r\n\r\n    if (this._settingsService.settings.arParameters.planeDetection && this._settingsService.settings.arParameters.planeHitTest &&\r\n      !(this._arFeatures.includes(ArFeature.PlaneDetection)) && xrFrame.worldInformation) {\r\n      this._arFeatures.push(ArFeature.PlaneDetection, ArFeature.PlaneDetectionHitTest);\r\n      this._initPlaneDetection();\r\n    }\r\n  }\r\n\r\n  private _initRenderer(): void {\r\n    this._renderer.xr.enabled = true;\r\n    this._renderer.shadowMap.type = PCFSoftShadowMap;\r\n    this._renderer.setClearColor(0x000000, 0);\r\n    this._renderer.autoClear = false;\r\n  }\r\n\r\n  private _initController(): void {\r\n    this._tempMatrix = new Matrix4();\r\n    this._raycaster = new Raycaster();\r\n    this._controller = this._renderer.xr.getController(0);\r\n    this.scene.add(this._controller);\r\n  }\r\n\r\n  private _initScene(): void {\r\n    this.scene = new Scene();\r\n    const planeGeometry = new PlaneGeometry(100, 100);\r\n    const material = new ShadowMaterial({opacity: 0.2});\r\n    this._shadowPlane = new Mesh(planeGeometry, material);\r\n    this._shadowPlane.name = 'shadowPlane';\r\n    this._shadowPlane.rotation.x -= Math.PI / 2;\r\n    this._shadowPlane.receiveShadow = true;\r\n    this._shadowPlane.visible = false;\r\n    this.scene.add(this._shadowPlane);\r\n  }\r\n\r\n  private _initLightEstimation(lightProbe: any) {\r\n    this._threeLightProbe =  new LightProbe();\r\n    this.scene.add(this._threeLightProbe);\r\n    this._lightProbe = lightProbe;\r\n\r\n    // @ts-ignore\r\n    this._glBinding = new XRWebGLBinding(this._session, this._renderer.getContext());\r\n  }\r\n\r\n  private _initReflectionCubeMap() {\r\n    this._cubeMapTexture = new Texture();\r\n    this._renderer.initTexture(this._cubeMapTexture);\r\n    this.scene.environment = this._cubeMapTexture;\r\n\r\n    this._lightProbe.addEventListener('reflectionchange', () => {\r\n      const rawData = this._glBinding.getReflectionCubeMap(this._lightProbe);\r\n      const texProps = this._renderer.properties.get(this._cubeMapTexture);\r\n      texProps.__webglTexture = rawData;\r\n    });\r\n  }\r\n\r\n  private _initCPUDepthOcclusion() {\r\n    this._depthDataTexture = new DepthDataTexture();\r\n    this._updateMeshMaterials();\r\n  }\r\n\r\n  private _initAnchoredHitTest() {\r\n    this._anchoredObjects = [];\r\n  }\r\n\r\n  private _initPlaneDetection() {\r\n    this._createPlaneMaterial();\r\n  }\r\n\r\n  private _initLighting() {\r\n    const ambientLight = new THREE.AmbientLight(0xffffff, 0.1);\r\n    ambientLight.color.setHex(0xffffff).convertSRGBToLinear();\r\n    ambientLight.name = 'ambientLight';\r\n\r\n    this._sunLight = new DirectionalLight('black', 0.3);\r\n    this._sunLight.castShadow = true;\r\n    this._sunLight.shadow.mapSize.width = 4096;\r\n    this._sunLight.shadow.mapSize.height = 4096;\r\n    this._sunLight.shadow.camera.left = -10;\r\n    this._sunLight.shadow.camera.right = 10;\r\n    this._sunLight.shadow.camera.top = 10;\r\n    this._sunLight.shadow.camera.bottom = -10;\r\n    this._sunLight.shadow.camera.near = 0.1;\r\n    this._sunLight.shadow.camera.far = 30;\r\n    this._sunLight.visible = true;\r\n    this._sunLight.target.visible = true;\r\n    this._sunLight.name = 'sunLight';\r\n    this.scene.add(/*ambientLight, */this._sunLight.target, this._sunLight);\r\n  }\r\n\r\n  private _checkHitTestMethod(xrFrame: any) {\r\n    if (this._arFeatures.includes(ArFeature.CPUDepthOcclusion) && this._arFeatures.includes(ArFeature.AnchoredHitTest)) {\r\n      this._executeDepthAnchorHitTest(xrFrame);\r\n    } else if (this._arFeatures.includes(ArFeature.AnchoredHitTest)) {\r\n      this._executeAnchoredHitTest(xrFrame);\r\n    } else if (this._arFeatures.includes(ArFeature.CPUDepthHitTest)) {\r\n      this._executeCPUDepthHitTest(xrFrame);\r\n    } else {\r\n      this._executeDefaultHitTest(xrFrame);\r\n    }\r\n  }\r\n\r\n  private _executeDepthAnchorHitTest(xrFrame) {\r\n    const xrViewerPose: any = xrFrame.getViewerPose(this.refSpace);\r\n    const xrCamera: any = this._renderer.xr.getCamera(/*this._cameraService.camera*/); // todo: due to threejs update parameter not needed anymore, check this!\r\n    this._reticle.visible = false;\r\n\r\n    if (this.hitTestSource && xrViewerPose) {\r\n      const hitTestResults = xrFrame.getHitTestResults(this.hitTestSource);\r\n      if (hitTestResults.length === 0) {\r\n        if (xrViewerPose.views.length > 0 && xrCamera) {\r\n          for (const view of xrViewerPose.views) {\r\n            if (!this._activeARModel.visible) {\r\n              const depthData: any = xrFrame.getDepthInformation(view);\r\n              // Place object as soon as depth data is available and distance is within reasonable values\r\n              if (depthData && depthData.getDepthInMeters(0.5, 0.5) > 0.1 && depthData.getDepthInMeters(0.5, 0.5) < 2.5) {\r\n                this._activeARModel.position.set(xrCamera.position.x, xrCamera.position.y, xrCamera.position.z);\r\n                this._activeARModel.rotation.setFromQuaternion(xrCamera.quaternion);\r\n                this._activeARModel.translateZ(-depthData.getDepthInMeters(0.5, 0.5));\r\n                this._activeARModel.position.y += 0.02;\r\n                this._activeARModel.rotation.set(0, 0, 0);\r\n                this._activeARModel.visible = true;\r\n              }\r\n            }\r\n          }\r\n        }\r\n      } else {\r\n        // When hit test results are available we switch to the anchored hit test method and place the model accordingly\r\n        this._executeAnchoredHitTest(xrFrame);\r\n        if (this._anchoredObjects.length === 0) {\r\n          this._handleTouchEvent(false);\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  private _executeAnchoredHitTest(xrFrame: any) {\r\n    this._executeDefaultHitTest(xrFrame);\r\n\r\n    for (const {anchoredObject, anchor} of this._anchoredObjects) {\r\n      if (!xrFrame.trackedAnchors.has(anchor)) {\r\n        continue;\r\n      }\r\n      const anchorPose = xrFrame.getPose(anchor.anchorSpace, this.refSpace);\r\n      if (anchorPose) {\r\n        const hitMatrix = new Matrix4().fromArray(anchorPose.transform.matrix);\r\n        anchoredObject.position.setFromMatrixPosition(hitMatrix);\r\n      }\r\n    }\r\n  }\r\n\r\n  private _executeCPUDepthHitTest(xrFrame: any) {\r\n    const xrViewerPose: any = xrFrame.getViewerPose(this.refSpace);\r\n    const xrCamera: any = this._renderer.xr.getCamera(/*this._cameraService.camera*/); // todo: due to threejs update parameter not needed anymore, check this!\r\n    this._reticle.visible = false;\r\n\r\n    if (xrViewerPose && xrViewerPose.views.length > 0 && xrCamera) {\r\n      for (const view of xrViewerPose.views) {\r\n        if (!this._activeARModel.visible) {\r\n          this._reticle.visible = true;\r\n          this._surfaceFoundOnce = true;\r\n        }\r\n\r\n        const depthData: any = xrFrame.getDepthInformation(view);\r\n        if (depthData) {\r\n          this._reticle.position.set(xrCamera.position.x, xrCamera.position.y, xrCamera.position.z);\r\n          this._reticle.rotation.setFromQuaternion(xrCamera.quaternion);\r\n          this._reticle.translateZ(-depthData.getDepthInMeters(0.5, 0.5));\r\n          this._reticle.position.y += 0.02;\r\n          this._reticle.rotation.set(0, 0, 0);\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  private _executeDefaultHitTest(xrFrame: any) {\r\n    const xrViewerPose = xrFrame.getViewerPose(this.refSpace);\r\n    this._reticle.visible = false;\r\n\r\n    if (this.hitTestSource && xrViewerPose) {\r\n      const hitTestResults = xrFrame.getHitTestResults(this.hitTestSource);\r\n      if (hitTestResults.length > 0) {\r\n        const pose = hitTestResults[0].getPose(this.refSpace);\r\n        if (!this._activeARModel.visible) {\r\n          this._reticle.visible = true;\r\n          this._surfaceFoundOnce = true;\r\n        }\r\n        const hitMatrix = new Matrix4().fromArray(pose.transform.matrix);\r\n        this._hitTestResult = hitMatrix;\r\n        this._reticle.position.setFromMatrixPosition(hitMatrix);\r\n        this._reticle.position.y += 0.02; // Prevents z-fighting\r\n        this._reticleHitTestResult = hitTestResults[0];\r\n      }\r\n    }\r\n  }\r\n\r\n  private _checkExtraFeatures(xrFrame: any) {\r\n    if (this._arFeatures.includes(ArFeature.LightEstimation)) {\r\n      this._adjustLighting(xrFrame);\r\n    }\r\n    if (this._arFeatures.includes(ArFeature.CPUDepthOcclusion)) {\r\n      this._hideOccludedMeshes(xrFrame);\r\n    }\r\n    // if (this._arFeatures.includes(ArFeature.PlaneDetection)) {\r\n    //   this._drawPlanes(xrFrame);\r\n    // }\r\n  }\r\n\r\n  private _hideOccludedMeshes(xrFrame: any) {\r\n    const xrViewerPose: any = xrFrame.getViewerPose(this.refSpace);\r\n    if (xrViewerPose && xrViewerPose.views.length > 0) {\r\n      for (const view of xrViewerPose.views) {\r\n        const depthData: any = xrFrame.getDepthInformation(view);\r\n        if (depthData) {\r\n          this._depthDataTexture.updateDepth(depthData);\r\n          this._updateAugmentedMaterialUniforms(depthData.normDepthBufferFromNormView.matrix);\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  private async _createPlaneMaterial() {\r\n    const pm = new MeshPhongMaterial({transparent: true, side: DoubleSide});\r\n    pm.map = await MaterialUtils.FromUrl('assets/textures/Floor/Tiles/ar_floor_texture.png',\r\n      false, 1, 2, 2);\r\n    pm.map.flipY = false;\r\n    pm.needsUpdate = true;\r\n    this._planeMaterial = pm;\r\n  }\r\n\r\n  private async _onSessionStarted(session: any): Promise<void> {\r\n    const domOverlay = document.getElementById('ar-root');\r\n    session.addEventListener('end', this._onSessionEnded.bind(this));\r\n    session.addEventListener('select', () => this._handleTouchEvent());\r\n    session.addEventListener('selectstart', ($event) => this._handleHoldStartEvent($event));\r\n    session.addEventListener('selectend', ($event) => this._handleHoldEndEvent($event));\r\n    domOverlay.addEventListener('beforexrselect', ($event) => this._checkingInterfaceInteraction($event));\r\n    await (<any>this._renderer.getContext()).makeXRCompatible();\r\n    this._renderer.xr.setSession(session);\r\n    this._session = session;\r\n  }\r\n\r\n  private _onSessionEnded() {\r\n    if (this._cleanup) {\r\n      this._session = null;\r\n      this._surfaceFoundOnce = false;\r\n      this._reticle.visible = false;\r\n      this.scene.remove(this._positionIndicator);\r\n      this._activeARModel.visible = true;\r\n      this._activeARModel.position.set(0, 0, 0);\r\n      this._removeMaterialShaders();\r\n      this.shouldAddObjectToScene.next(this._activeARModel);\r\n      this._activeARModel = null;\r\n      this._holdingTouch = false;\r\n      this._arFeatures = [];\r\n      this._lightProbe = null;\r\n\r\n      this._vertexList = [];\r\n      this._detectedPlanes = [];\r\n      this._rawPlanes = new Set<any>();\r\n\r\n      this._renderer.xr.enabled = false;\r\n      this._renderer.shadowMap.type = PCFSoftShadowMap;\r\n      this._renderer.setClearColor(0xfafafa);\r\n      this._renderer.autoClear = true;\r\n\r\n      this._viewModeService.viewMode = ViewMode.RoomPlan3D;\r\n    }\r\n  }\r\n\r\n  private _setArModelShadows(): void {\r\n    if (this._activeARModel) {\r\n      this._activeARModel.traverse((node) => {\r\n        if (node instanceof Mesh) {\r\n          node.castShadow = true;\r\n          node.receiveShadow = true;\r\n        }\r\n      });\r\n    }\r\n  }\r\n\r\n  private _handleTouchEvent(manualTouch: boolean = true): void {\r\n    this._handleDoubleTapEvent();\r\n\r\n    if (manualTouch) {\r\n      if (this._reticle.visible && !this._activeARModel.visible) {\r\n        if (this._arFeatures.includes(ArFeature.AnchoredHitTest)) {\r\n          this._activeARModel.position.copy(this._reticle.position);\r\n          this._reticleHitTestResult.createAnchor().then((anchor) => {\r\n            this._anchoredObjects.push({\r\n              anchoredObject: this._shadowPlane,\r\n              anchor: anchor});\r\n          }).catch((e) => {\r\n            // Unable to create anchor\r\n          });\r\n        } else {\r\n          this._activeARModel.position.copy(this._reticle.position);\r\n          this._aRModelBackupYPosition = this._reticle.position.y;\r\n          this._shadowPlane.position.copy(this._reticle.position);\r\n          this._positionIndicator.position.copy(this._reticle.position);\r\n        }\r\n      }\r\n    } else {\r\n      if (this._arFeatures.includes(ArFeature.AnchoredHitTest)) {\r\n        this._activeARModel.position.copy(this._reticle.position);\r\n        this._reticleHitTestResult.createAnchor().then((anchor) => {\r\n          this._anchoredObjects.push({\r\n            anchoredObject: this._shadowPlane,\r\n            anchor: anchor\r\n          });\r\n        }).catch((e) => {\r\n          // Unable to create anchor\r\n        });\r\n      } else {\r\n        this._activeARModel.position.copy(this._reticle.position);\r\n        this._aRModelBackupYPosition = this._reticle.position.y;\r\n        this._shadowPlane.position.copy(this._reticle.position);\r\n        this._positionIndicator.position.copy(this._reticle.position);\r\n      }\r\n    }\r\n\r\n    this._activeARModel.visible = true;\r\n    this._shadowPlane.visible = true;\r\n    this._positionIndicator.visible = true;\r\n    this._setArModelShadows();\r\n    this._setPlanesVisibilty(false);\r\n  }\r\n\r\n  private _handleMultiTouchEvent(): void {\r\n    const inputSources = this._session.inputSources;\r\n    if (inputSources.length === 2 && this._activeARModel.visible && !this._holdingTouch) {\r\n      this._aRModelBackupYRotation = this._aRModelBackupYRotation === 0 ? this._activeARModel.rotation.y / 2 : this._aRModelBackupYRotation;\r\n      const dx = inputSources[1].gamepad.axes[0] - inputSources[0].gamepad.axes[0];\r\n      const dy = inputSources[1].gamepad.axes[1] - inputSources[0].gamepad.axes[1];\r\n      const angle = Math.atan2(dy, dx);\r\n      this._aRModelRotationStartingValue = this._aRModelRotationStartingValue === 0 ? angle : this._aRModelRotationStartingValue;\r\n      const difference = this._aRModelBackupYRotation - (angle - this._aRModelRotationStartingValue);\r\n      this._activeARModel.rotation.y = this._aRModelBackupYRotation + difference;\r\n    } else {\r\n      this._aRModelBackupYRotation = 0;\r\n      this._aRModelRotationStartingValue = 0;\r\n    }\r\n  }\r\n\r\n  private _handleDoubleTapEvent(): void {\r\n    const intersections: Intersection[] = this._getObjectIntersections([this._activeARModel]);\r\n    if (intersections.length > 0) {\r\n      const currentTimestamp: number = Date.now();\r\n      this.showContextMenu = this._lastObjectTouchTimestamp && currentTimestamp - this._lastObjectTouchTimestamp < this._doubleTapTimeframe;\r\n      this._lastObjectTouchTimestamp = currentTimestamp;\r\n    } else {\r\n      this.showContextMenu = false;\r\n    }\r\n  }\r\n\r\n  private async _checkIfHoldTouchEvent($event) {\r\n    setTimeout(() => {\r\n      if (!this.userInSelectionMenu && this._lastEventTimestamp === $event.timeStamp && this._session.inputSources.length === 1) {\r\n        this._holdingTouch = true;\r\n        this._toggleHoldTouchEvent();\r\n      }\r\n    }, 200);\r\n  }\r\n\r\n  private _handleHoldStartEvent($event: any): void {\r\n    this._lastEventTimestamp = $event.timeStamp;\r\n    this._checkIfHoldTouchEvent($event);\r\n  }\r\n\r\n  private _handleHoldEndEvent($event: any): void {\r\n    this._lastEventTimestamp = $event.timeStamp;\r\n    if (this._holdingTouch) {\r\n      this._holdingTouch = false;\r\n      this._toggleHoldTouchEvent();\r\n    }\r\n  }\r\n\r\n  private _toggleHoldTouchEvent(): void {\r\n    if (this._holdingTouch) {\r\n      // this._setPlanesVisibilty(true);\r\n      this._callLiftAnimation();\r\n    } else {\r\n      this._callDropAnimation();\r\n      this._setPlanesVisibilty(false);\r\n      this._activeARModel.position.y = this._aRModelBackupYPosition;\r\n    }\r\n    this._toggleARModelTransparency();\r\n  }\r\n\r\n  private _handleHoldMoveEvent(): void {\r\n    if (this._holdingTouch && !this.userInSelectionMenu) {\r\n      const intersections: Intersection[] = this._getObjectIntersections([this._shadowPlane]);\r\n      if (intersections.length > 0) {\r\n        const movePosition = !this._animating ? new Vector3(intersections[0].point.x, intersections[0].point.y + 0.2, intersections[0].point.z) :\r\n          new Vector3(intersections[0].point.x, this._activeARModel.position.y, intersections[0].point.z);\r\n        this._activeARModel.position.copy(movePosition);\r\n        this._aRModelBackupYPosition = intersections[0].point.y;\r\n        this._positionIndicator.position.copy(intersections[0].point);\r\n        this._updateShadows(intersections[0].point);\r\n      }\r\n    }\r\n  }\r\n\r\n  private _updateShadows(centerPosition: Vector3): void {\r\n    this._shadowPlane.position.copy(centerPosition);\r\n    this.scene.traverse((node) => {\r\n      if (node instanceof DirectionalLight) {\r\n        node.target.position.copy(centerPosition);\r\n        node.shadow.camera.updateProjectionMatrix();\r\n      }\r\n    });\r\n  }\r\n\r\n  private _adjustLighting(frame): void {\r\n    const lightEstimate = frame.getLightEstimate(this._lightProbe);\r\n\r\n    if (lightEstimate) {\r\n      this._threeLightProbe.sh.fromArray(lightEstimate.sphericalHarmonicsCoefficients);\r\n\r\n      const intensity = Math.max(1.0,\r\n        Math.max(lightEstimate.primaryLightIntensity.x,\r\n          Math.max(lightEstimate.primaryLightIntensity.y,\r\n            lightEstimate.primaryLightIntensity.z)));\r\n\r\n      this._sunLight.position.set(lightEstimate.primaryLightDirection.x,\r\n        lightEstimate.primaryLightDirection.y,\r\n        lightEstimate.primaryLightDirection.z);\r\n      this._sunLight.color.setRGB(lightEstimate.primaryLightIntensity.x / intensity,\r\n        lightEstimate.primaryLightIntensity.y / intensity,\r\n        lightEstimate.primaryLightIntensity.z / intensity);\r\n      this._sunLight.intensity = intensity;\r\n    }\r\n  }\r\n\r\n  private _toggleARModelTransparency(): void {\r\n    this._activeARModel.traverse((node) => {\r\n      if (node instanceof Mesh) {\r\n        const materials: any = !Array.isArray(node.material) ? [node.material] : node.material;\r\n        materials.forEach(material => {\r\n          material.transparent = this._holdingTouch;\r\n          material.opacity = this._holdingTouch ? 0.5 : 1;\r\n          material.needsUpdate = true;\r\n        });\r\n      }\r\n    });\r\n  }\r\n\r\n  private _setPlanesVisibilty(visible: boolean): void {\r\n    this._detectedPlanes.forEach((plane) => plane.visible = visible);\r\n  }\r\n\r\n  private _getObjectIntersections(objects: Object3D[]) {\r\n    this._tempMatrix.identity().extractRotation(this._controller.matrixWorld);\r\n    this._raycaster.ray.origin.setFromMatrixPosition(this._controller.matrixWorld);\r\n    this._raycaster.ray.direction.set(0, 0, -1).applyMatrix4(this._tempMatrix);\r\n    return this._raycaster.intersectObjects(objects);\r\n  }\r\n\r\n  // TODO: Needs to be made compatible with BufferGeometry if we want to keep plane detection visualization\r\n  private _drawPlane(vertices: Array<DOMPointReadOnly>, planePose) {\r\n    // const hitMatrix = new Matrix4().fromArray(planePose.transform.matrix);\r\n    // const pointGroup = new Group();\r\n    //\r\n    // // Create vertices\r\n    // vertices.forEach((vertex) => {\r\n    //   if (this._debug) {\r\n    //     const point = this._pointRepresentation.clone();\r\n    //     point.position.set(vertex.x, 0, vertex.z);\r\n    //     pointGroup.add(point);\r\n    //   }\r\n    //   this._vertexList.push(new DOMPoint(vertex.x, vertex.z));\r\n    // });\r\n    //\r\n    // if (this._debug) {\r\n    //   pointGroup.position.setFromMatrixPosition(hitMatrix);\r\n    //   this.scene.add(pointGroup);\r\n    // }\r\n    //\r\n    // // Generate polygon from vertices\r\n    // const hull = makeHull(this._vertexList);\r\n    // const geometry = new BufferGeometry();\r\n    // const vectorTwoList = hull.map((point) => new Vector2(point.x, point.y));\r\n    // const vectorThreeList = hull.map((point) => new Vector3(point.x, this._detectedPlanes.length > 0 ? this._detectedPlanes[0].position.y : 0, point.y));\r\n    // const faceArray = ShapeUtils.triangulateShape(vectorTwoList, []);\r\n    // geometry.vertices.push(...vectorThreeList);\r\n    //\r\n    // // Generate faces\r\n    // for (let i = 0; i < faceArray.length; i++) {\r\n    //   geometry.faces.push(new THREE.Face3(faceArray[i][0], faceArray[i][1], faceArray[i][2]));\r\n    // }\r\n    // geometry.computeVertexNormals();\r\n    // geometry.normalize();\r\n    //\r\n    // // Generate UV's\r\n    // geometry.computeBoundingBox();\r\n    // const max = geometry.boundingBox.max, min = geometry.boundingBox.min;\r\n    // const offset = new THREE.Vector2(0 - min.x, 0 - min.z);\r\n    // const range = new THREE.Vector2(max.x - min.x, max.z - min.z);\r\n    // const faces = geometry.faces;\r\n    // geometry.faceVertexUvs[0] = [];\r\n    //\r\n    // for (let i = 0; i < faces.length; i++) {\r\n    //   const v1 = geometry.vertices[faces[i].a],\r\n    //     v2 = geometry.vertices[faces[i].b],\r\n    //     v3 = geometry.vertices[faces[i].c];\r\n    //\r\n    //   geometry.faceVertexUvs[0].push([\r\n    //     new THREE.Vector2((v1.x + offset.x) / range.x, (v1.z + offset.y) / range.y),\r\n    //     new THREE.Vector2((v2.x + offset.x) / range.x, (v2.z + offset.y) / range.y),\r\n    //     new THREE.Vector2((v3.x + offset.x) / range.x, (v3.z + offset.y) / range.y)\r\n    //   ]);\r\n    // }\r\n    // geometry.uvsNeedUpdate = true;\r\n    //\r\n    // // Create and set plane\r\n    // const mesh = new Mesh(geometry, this._planeMaterial);\r\n    // mesh.position.setFromMatrixPosition(hitMatrix);\r\n    // this._detectedPlanes.push(mesh);\r\n    // this.scene.add(mesh);\r\n  }\r\n\r\n  private _drawPlanes(xrFrame): void {\r\n    if (!this._activeARModel.visible) {\r\n      const planesDetected = xrFrame.worldInformation.detectedPlanes;\r\n      if (planesDetected.size > 0) {\r\n        planesDetected.forEach(plane => {\r\n          if (!this._rawPlanes.has(plane)) {\r\n            const planePose = xrFrame.getPose(plane.planeSpace, this.refSpace);\r\n            if (planePose) {\r\n              this._rawPlanes.add(plane);\r\n              const planeVertices = plane.polygon;\r\n              this._drawPlane(planeVertices, planePose);\r\n            }\r\n          }\r\n        });\r\n      }\r\n    }\r\n  }\r\n\r\n  private _callLiftAnimation(): void {\r\n    this._animating = true;\r\n    const position = this._activeARModel.position.clone();\r\n    const targetPosition = new Vector3(this._activeARModel.position.x, this._activeARModel.position.y + 0.2, this._activeARModel.position.z);\r\n    this._liftAnimation = new TWEEN.Tween(position)\r\n      .to(targetPosition, 500)\r\n      .easing(TWEEN.Easing.Quadratic.Out)\r\n      .onUpdate(() => this._activeARModel.position.copy(new Vector3(this._activeARModel.position.x, position.y, this._activeARModel.position.z)))\r\n      .onComplete(() => this._animating = false);\r\n    this._liftAnimation.start();\r\n  }\r\n\r\n  private _callDropAnimation(): void {\r\n    this._animating = true;\r\n    const position = this._activeARModel.position.clone();\r\n    const targetPosition = new Vector3(this._activeARModel.position.x, this._activeARModel.position.y - 0.2, this._activeARModel.position.z);\r\n    this._dropAnimation = new TWEEN.Tween(position)\r\n      .to(targetPosition, 500)\r\n      .easing(TWEEN.Easing.Quadratic.Out)\r\n      .onUpdate(() => this._activeARModel.position.copy(new Vector3(this._activeARModel.position.x, position.y, this._activeARModel.position.z)))\r\n      .onComplete(() => this._animating = false);\r\n    this._dropAnimation.start();\r\n  }\r\n\r\n  private _createAugmentedMaterial(material: Material | ShadowMaterial, depthMap) {\r\n    material.userData = {\r\n      uDepthTexture: {value: depthMap},\r\n      uWidth: {value: 1.0},\r\n      uHeight: {value: 1.0},\r\n      uUvTransform: {value: new Matrix4()},\r\n      uOcclusionEnabled: {value: true}\r\n    };\r\n\r\n    material.userData.isAgumentedMaterial = true;\r\n\r\n    material.onBeforeCompile = (shader) => {\r\n      // Pass uniforms from userData to the\r\n      for (const i in material.userData) {\r\n        shader.uniforms[i] = material.userData[i];\r\n      }\r\n\r\n      // Fragment variables\r\n      shader.fragmentShader = `\r\n\t\t\tuniform sampler2D uDepthTexture;\r\n\t\t\tuniform float uWidth;\r\n\t\t\tuniform float uHeight;\r\n\t\t\tuniform mat4 uUvTransform;\r\n\t\t\tuniform bool uOcclusionEnabled;\r\n\t\t\tvarying float vDepth;\r\n\t\t\t` + shader.fragmentShader;\r\n\r\n\r\n      let fragmentEntryPoint = '#include <clipping_planes_fragment>';\r\n      if (material instanceof ShadowMaterial) {\r\n        fragmentEntryPoint = '#include <fog_fragment>';\r\n      }\r\n\r\n      // Fragment depth logic\r\n      shader.fragmentShader = shader.fragmentShader.replace('void main',\r\n        `float getDepthInMillimeters(in sampler2D depthText, in vec2 uv)\r\n\t\t\t{\r\n\t\t\t\tvec2 packedDepth = texture2D(depthText, uv).ra;\r\n\t\t\t\treturn dot(packedDepth, vec2(255.0, 65280.0));\r\n\t\t\t}\r\n\t\t\tvoid main`);\r\n\r\n\r\n      shader.fragmentShader = shader.fragmentShader.replace(fragmentEntryPoint, `\r\n\t\t\t${fragmentEntryPoint}\r\n\t\t\t\t// Normalize x, y to range [0, 1]\r\n\t\t\t\tfloat x = gl_FragCoord.x / uWidth;\r\n\t\t\t\tfloat y = gl_FragCoord.y / uHeight;\r\n\t\t\t\tvec2 texCoord = (uUvTransform * vec4(x, 1.0 - y, 0.0, 1.0)).xy;\r\n\t\t\t\tfloat depth = getDepthInMillimeters(uDepthTexture, texCoord) / 1000.0;\r\n\t\t\t\tif (depth < vDepth)\r\n\t\t\t\t{\r\n\t\t\t\t\tdiscard;\r\n\t\t\t\t}\r\n\t\t\t`);\r\n\r\n      // Vertex variables\r\n      shader.vertexShader = `\r\n\t\t\tvarying float vDepth;\r\n\t\t\t` + shader.vertexShader;\r\n\r\n      // Vertex depth logic\r\n      shader.vertexShader = shader.vertexShader.replace('#include <fog_vertex>', `\r\n\t\t\t#include <fog_vertex>\r\n\t\t\tvDepth = gl_Position.z;\r\n\t\t\t`);\r\n    };\r\n\r\n    return material;\r\n  }\r\n\r\n  private _updateAugmentedMaterialUniforms(normTextureFromNormViewMatrix) {\r\n    this.scene.traverse((child) => {\r\n      if (child instanceof Mesh && child.material) {\r\n        if (child.material instanceof Array) {\r\n          for (const material of child.material) {\r\n            if (material.userData.isAgumentedMaterial) {\r\n              material.userData.uWidth.value = Math.floor(window.devicePixelRatio * window.innerWidth);\r\n              material.userData.uHeight.value = Math.floor(window.devicePixelRatio * window.innerHeight);\r\n              material.userData.uUvTransform.value.fromArray(normTextureFromNormViewMatrix);\r\n              material.needsUpdate = true;\r\n            }\r\n          }\r\n        } else if (child.userData.isAgumentedMaterial) {\r\n          child.material.userData.uWidth.value = Math.floor(window.devicePixelRatio * window.innerWidth);\r\n          child.material.userData.uHeight.value = Math.floor(window.devicePixelRatio * window.innerHeight);\r\n          child.material.userData.uUvTransform.value.fromArray(normTextureFromNormViewMatrix);\r\n          child.material.needsUpdate = true;\r\n        }\r\n      }\r\n    });\r\n  }\r\n\r\n  private _updateMeshMaterials(): void {\r\n    this.scene.traverse((object) => {\r\n      if (object instanceof Mesh) {\r\n        if (object.material instanceof Array) {\r\n          for (let material of object.material) {\r\n            material = this._createAugmentedMaterial(material, this._depthDataTexture);\r\n          }\r\n        } else {\r\n          object.material = this._createAugmentedMaterial(object.material, this._depthDataTexture);\r\n        }\r\n      }\r\n    });\r\n  }\r\n\r\n  private _removeMaterialShaders(): void {\r\n    this.scene.traverse((object) => {\r\n      if (object instanceof Mesh) {\r\n        if (object.material instanceof Array) {\r\n          for (const material of object.material) {\r\n            material.onBeforeCompile = (shader) => {\r\n              shader = null;\r\n            };\r\n          }\r\n        } else {\r\n          object.material.onBeforeCompile = (shader) => {\r\n            shader = null;\r\n          };\r\n        }\r\n      }\r\n    });\r\n  }\r\n\r\n  private _checkingInterfaceInteraction(event: any): void {\r\n    this.userInSelectionMenu = event.path.filter((entry) => entry.localName === 'ar-gui-configurator').length > 0;\r\n  }\r\n}\r\n"]}