@colijnit/homedecorator 255.1.1

package/esm2015/app/plugins/core3d/service/scene-event.service.js

@@ -0,0 +1,1000 @@
+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 { Item } from '../items/item';
+import { Vector2, Vector3 } from 'three';
+import { SceneEventState } from '../model/scene-event.enum';
+import { Subject } from 'rxjs';
+import { fromEvent } from 'rxjs/internal/observable/fromEvent';
+import { debounceTime, delay, filter, takeUntil } from 'rxjs/operators';
+import { of } from 'rxjs/internal/observable/of';
+import { MessageType } from '../../../core/enum/message-type.enum';
+import { ViewMode } from '../../../core/enum/view-mode.enum';
+import { RelativePositionUtils } from '../../../core/utils/relative-position.utils';
+import { CustomWallFloorItem } from '../items/custom-wall-floor-item';
+import { ItemGroup } from '../items/item-group';
+import { isFloorDecoration, isFloorType, isFurnitureType, isInWallType, isOnFloorType, isWallFloorType, isWallType } from '../items/factory';
+import { InWallItem, WallItem } from '../items/wall-objects';
+import * as i0 from "@angular/core";
+import * as i1 from "./hud.service";
+import * as i2 from "../../../core/service/message-bus.service";
+import * as i3 from "./scene.service";
+import * as i4 from "./drag-and-drop.service";
+import * as i5 from "./rotation.service";
+import * as i6 from "./camera.service";
+import * as i7 from "../../room-planner/components/floorplanner/service/room.service";
+import * as i8 from "./floor.service";
+import * as i9 from "./intersection.service";
+import * as i10 from "../../../core/service/view-mode.service";
+import * as i11 from "./item-group.service";
+import * as i12 from "./item.service";
+import * as i13 from "../../../core/service/homedecorator-app.service";
+import * as i14 from "../../../core/service/homedecorator-app-event.service";
+export class SceneEventService {
+    constructor(_hudService, _messageBusService, _sceneService, _dragAndDropService, _rotationService, _cameraService, _roomService, _floorService, _intersectionService, _viewModeService, _itemGroupService, _itemService, _appService, _eventService) {
+        this._hudService = _hudService;
+        this._messageBusService = _messageBusService;
+        this._sceneService = _sceneService;
+        this._dragAndDropService = _dragAndDropService;
+        this._rotationService = _rotationService;
+        this._cameraService = _cameraService;
+        this._roomService = _roomService;
+        this._floorService = _floorService;
+        this._intersectionService = _intersectionService;
+        this._viewModeService = _viewModeService;
+        this._itemGroupService = _itemGroupService;
+        this._itemService = _itemService;
+        this._appService = _appService;
+        this._eventService = _eventService;
+        this.intersectOffsetForWalls = 20;
+        this.longTouchDuration = 600;
+        this.rotateNoDrag = false;
+        this._mousePosition = new Vector2();
+        this._oldMousePosition = new Vector2();
+        this._rotationStartPoint = null;
+        this._defaultCursorStyle = 'pointer';
+        this._explorePressed = false;
+        this._inDragOver = false;
+        this._mouseDown = false;
+        this._mouseMoved = false; // has mouse moved since down click
+        this._rotateMouseOver = false;
+        this._groupingMode = false;
+        this._state = SceneEventState.UNSELECTED;
+        this._subs = [];
+        this._debouncedSaveState = new Subject();
+    }
+    ngOnDestroy() {
+        this._subs.forEach(s => s.unsubscribe());
+        this._element = undefined;
+    }
+    init(element) {
+        this._element = element;
+        this._controls = this._cameraService.controls;
+        this._camera = this._cameraService.camera;
+        this._touchStart = fromEvent(element, 'touchstart');
+        this._touchEnd = fromEvent(element, 'touchend');
+        this._touchCancel = fromEvent(element, 'touchcancel');
+        this._touchMove = fromEvent(element, 'touchmove');
+        fromEvent(element, 'mousedown')
+            .pipe(filter((event) => event.button === 0))
+            .subscribe(event => this._leftMouseDownEvent(event));
+        fromEvent(element, 'mouseup').subscribe((event) => this._mouseUpEvent(event));
+        fromEvent(element, 'mousemove').subscribe((event) => this._mouseMoveEvent(event));
+        this._touchStart.subscribe((event) => this._touchStartEvent(event));
+        this._touchEnd.subscribe((event) => this._touchEndEvent(event));
+        this._touchCancel.subscribe((event) => this._touchEndEvent(event));
+        this._touchMove.subscribe((event) => this._touchMoveEvent(event));
+        fromEvent(window, 'keydown').subscribe((event) => this._keyDownEvent(event));
+        fromEvent(element, 'dragenter').subscribe((event) => this._dragEnterEvent(event));
+        fromEvent(element, 'dragexit').subscribe((event) => this._dragExitEvent(event));
+        fromEvent(element, 'dragover').subscribe((event) => this._dragOverEvent(event));
+        fromEvent(element, 'drop').subscribe(event => this._onDrop(event));
+        this._subs.push(this._messageBusService.subscribe(MessageType.SetDrag, (data) => {
+            if (data instanceof Item) {
+                this._dragAndDropService.draggedData = {
+                    name: data.name,
+                    type: data.metadata.itemType
+                };
+                this._dragAndDropService.draggedItem = data;
+            }
+            else {
+                this._dragAndDropService.draggedData = data;
+            }
+        }), this._messageBusService.subscribe(MessageType.StartDrag, ({ x, y, z }) => this.startDragging(x, y, z)), this._messageBusService.subscribe(MessageType.ExitDrag, () => this._dragExitEvent(event)), this._messageBusService.subscribe(MessageType.PlaceOnTouch, () => this._initPlaceOnTouchRequest()), this._debouncedSaveState.pipe(debounceTime(800)).subscribe((action) => {
+            this._messageBusService.emit(MessageType.SaveState, { action: `3D ${action}` });
+        }), this._debouncedSaveState.pipe(debounceTime(200)).subscribe(() => {
+            this._hudService.updateLabelMeasurements();
+        }), this._viewModeService.viewModeChanged.subscribe(mode => this.setExploreMode(mode === ViewMode.WalkThrough)), this._itemGroupService.objectAdded.subscribe((object) => this.setSelectedObject(object)), this._itemGroupService.grouped.subscribe((object) => this.setSelectedObject(object)), this._itemGroupService.ungrouped.subscribe(() => this.setSelectedObject(null)), this._messageBusService.subscribe(MessageType.ItemRemoved, () => this.setSelectedObject(null)), this._messageBusService.subscribe(MessageType.StartGroupObject, () => this._setGroupingMode(true)));
+    }
+    setExploreMode(on = true) {
+        if (on) {
+            this._switchState(SceneEventState.EXPLORE);
+        }
+        else {
+            this._switchState(SceneEventState.UNSELECTED);
+        }
+    }
+    setSelectedObject(object, mesh) {
+        if (this._state === SceneEventState.UNSELECTED && object) {
+            this._switchState(SceneEventState.SELECTED);
+        }
+        if (this._selectedObject != null && this._selectedObject !== object) {
+            this._selectedObject.setUnselected();
+        }
+        if (object) {
+            if (object instanceof ItemGroup) {
+                this._setSelectObject(object);
+                this._itemGroupService.selectedGroup = object;
+            }
+            else if (object.parent instanceof ItemGroup) {
+                this._setSelectObject(object.parent);
+                this._itemGroupService.selectedGroup = object.parent;
+            }
+            else {
+                this._setSelectObject(object, mesh);
+            }
+        }
+        else {
+            if (this._selectedObject) {
+                this._selectedObject.setUnselected();
+                this._messageBusService.emit(MessageType.ItemUnselected, this._selectedObject);
+                this._selectedObject = null;
+            }
+            this._prevSelectedObject = null;
+        }
+        this._markSceneToUpdate();
+    }
+    startDragging(x, y, z) {
+        const draggedData = this._getDraggedData();
+        if (!this._dragAndDropService.draggedStatus.allowedNew || !draggedData) {
+            return;
+        }
+        this._switchState(SceneEventState.DND);
+        this._dragAndDropService.draggedStatus.dragEnter();
+        const vec3 = z ? new Vector3(x, y, z) : this.intersectingVec3(new Vector2(x, y));
+        if (this._dragAndDropService.draggedItem) {
+            this._dragAndDropService.draggedStatus.objectLoaded();
+            this._dragAndDropService.updateDraggedPosition(vec3);
+        }
+        else if (isFurnitureType(draggedData.type) || isWallType(draggedData.type)) {
+            this._dragAndDropService.dragModel(vec3, this._floorIntersection(this._sceneService.positionInSceneToScreen(vec3)));
+        }
+        else if (isFloorDecoration(draggedData.type)) {
+            this._dragAndDropService.dragFloorDecoration(this._floorIntersection(this._sceneService.positionInSceneToScreen(vec3)));
+        }
+    }
+    intersectingVec3(vec2, intersection) {
+        if (!intersection) {
+            const gIntersections = this._groundIntersections(vec2);
+            return gIntersections && gIntersections[0] && gIntersections[0].point;
+        }
+        else {
+            return intersection.point;
+        }
+    }
+    _isRotating() {
+        return this._state === SceneEventState.ROTATING && (!this._appService.sku || this._viewModeService.viewMode === ViewMode.InPhotoView);
+    }
+    _keyDownEvent(event) {
+        if (event.key === 'Escape') {
+            this._cancelDragDrop();
+        }
+    }
+    _dragEnterEvent(event) {
+        event.preventDefault();
+        const mousePos = RelativePositionUtils.GetClientMousePosition(event);
+        this.startDragging(mousePos.x, mousePos.y);
+    }
+    _dragExitEvent(event) {
+        if (event) {
+            event.preventDefault();
+        }
+        const draggedData = this._getDraggedData();
+        if (draggedData) {
+            this._dragAndDropService.finishDragging();
+            this._switchState(SceneEventState.UNSELECTED);
+        }
+    }
+    _dragOverEvent(event) {
+        event.preventDefault();
+        if (this._state !== SceneEventState.DND || this._inDragOver) {
+            return;
+        }
+        this._inDragOver = true;
+        this._dragAndDropService.draggedStatus.dragOver();
+        const canvas = event.currentTarget;
+        const mousePos = RelativePositionUtils.GetClientMousePosition(event);
+        this._mousePosition.set(mousePos.x - (canvas ? canvas.offsetLeft : 0), mousePos.y - (canvas ? canvas.offsetTop : 0));
+        const draggedData = this._dragAndDropService.draggedData;
+        let intersection = this._wallIntersection(this._mousePosition);
+        const intersectedFloor = this._floorIntersection(this._mousePosition);
+        this._dragAndDropService.intersectedWall = intersection;
+        this._dragAndDropService.intersectedFloor = intersectedFloor;
+        this._intersectedWall = undefined;
+        this._intersectedFloor = undefined;
+        if (isWallType(draggedData.type) || (isWallFloorType(draggedData.type) && intersection)) {
+            if (intersection) {
+                this._intersectedWall = intersection;
+            }
+            if (intersection && !isFurnitureType(draggedData.type)) {
+                this._acceptDrop(event);
+            }
+        }
+        else if (isFloorType(draggedData.type) || isFloorDecoration(draggedData.type) || (isWallFloorType(draggedData.type) && intersectedFloor)) {
+            this._intersectedFloor = intersection = this._floorIntersection(this._mousePosition);
+        }
+        else {
+            if (event.dataTransfer) {
+                event.dataTransfer.dropEffect = 'move';
+            }
+        }
+        const intersectedPoint = this.intersectingVec3(this._mousePosition, intersection);
+        if (intersectedPoint) {
+            this._dragAndDropService.updateDraggedPosition(intersectedPoint);
+            this._acceptDrop(event);
+            this._markSceneToUpdate();
+        }
+        this._inDragOver = false;
+    }
+    _onDrop(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            event.preventDefault();
+            if (this._state !== SceneEventState.DND) {
+                return;
+            }
+            const canvas = event.currentTarget;
+            const mousePos = RelativePositionUtils.GetClientMousePosition(event);
+            this._mousePosition.set(mousePos.x - (canvas ? canvas.offsetLeft : 0), mousePos.y - (canvas ? canvas.offsetTop : 0));
+            const draggedData = this._dragAndDropService.draggedData;
+            let position = null;
+            let intersection = null;
+            if (isWallType(draggedData.type) || (isWallFloorType(draggedData.type) && this._intersectedWall)) {
+                position = this._intersectedWall && this._intersectedWall.point;
+                intersection = this._intersectedWall;
+            }
+            else if (isFloorType(draggedData.type) || isFloorDecoration(draggedData.type) || (isWallFloorType(draggedData.type) && this._intersectedFloor)) {
+                position = this._intersectedFloor && this._intersectedFloor.point;
+                intersection = this._intersectedFloor;
+            }
+            if (position) {
+                const intersectedPoint = this.intersectingVec3(this._mousePosition, intersection);
+                this._dragAndDropService.draggedPlaced(intersectedPoint, intersection);
+                this._messageBusService.emit(MessageType.SaveState, { action: 'item added' });
+            }
+            else {
+                this._cancelDragDrop();
+            }
+            if (!this._dragAndDropService.draggedStatus.isObjectLoaded) {
+                this._dragAndDropService.draggedStatus.markToCleanUp();
+                this._releaseState(draggedData);
+            }
+            else {
+                this._releaseState(draggedData);
+                this._dragAndDropService.finishDragging();
+            }
+        });
+    }
+    _cancelDragDrop() {
+        this._dragAndDropService.draggedStatus.dragCanceled();
+        this._dragAndDropService.finishDragging();
+        this._switchState(SceneEventState.SELECTED);
+        this._messageBusService.emit(MessageType.FinishedIOneFurnitureBuild);
+    }
+    _mouseUpEvent(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._mouseDown = false;
+            if (this._state === SceneEventState.DND) {
+                return this._onDrop(event);
+            }
+            switch (this._state) {
+                case SceneEventState.DRAGGING:
+                case SceneEventState.DRAGGINGCONNECTOR:
+                    this._switchState(SceneEventState.SELECTED);
+                    if (this._selectedObject) {
+                        this._dragAndDropService.clickReleased();
+                        if (this._selectedObject instanceof Item) {
+                            this._selectedObject.endDrag();
+                        }
+                    }
+                    break;
+                case SceneEventState.ROTATING:
+                    if (this._selectedObject) {
+                        this._dragAndDropService.clickReleased();
+                        this._messageBusService.emit(MessageType.SaveState, { action: 'item rotated' });
+                    }
+                    this._switchState(SceneEventState.SELECTED);
+                    break;
+                case SceneEventState.UNSELECTED:
+                    if (!this._selectedObject && !this._mouseMoved) {
+                        this._checkWallsAndFloors(event);
+                    }
+                    break;
+                case SceneEventState.SELECTED:
+                    if (!this._selectedObject && !this._mouseMoved) {
+                        this._checkWallsAndFloors(event);
+                    }
+                    if (this._intersectedObject == null && !this._mouseMoved) {
+                        this._switchState(SceneEventState.UNSELECTED);
+                    }
+                    break;
+                case SceneEventState.EXPLORE:
+                    yield this._navigateExplore();
+                    break;
+            }
+        });
+    }
+    _navigateExplore() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._overrideDefaultCursorStyle('pointer');
+            const point = this._pointOnFloor(this._mousePosition);
+            if (point) {
+                const distance = this._camera.position.distanceTo(point);
+                this._hudService.exploreFloorHover(this._mousePosition, point, distance);
+                if (!this._mouseMoved) {
+                    yield this._hudService.confirmExplore();
+                    yield this._cameraService.controls.animateMoveTo(point);
+                    this._updateExplorePoint();
+                }
+            }
+        });
+    }
+    _initPlaceOnTouchRequest() {
+        if (this._dragAndDropService.draggedStatus.allowedNew && this._getDraggedData()) {
+            this._switchState(SceneEventState.DND);
+        }
+    }
+    _touchEndEvent(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._isMouseEventAllowed(event)) {
+                this._mouseDown = false;
+                switch (this._state) {
+                    case SceneEventState.SELECTED:
+                    case SceneEventState.UNSELECTED:
+                        if (!this._mouseMoved) {
+                            this._updateIntersections();
+                            if (this._intersectedObject) {
+                                this._itemGroupService.resetObjectsToGroup();
+                                this.setSelectedObject(this._intersectedObject, this._intersectedMesh);
+                                this._addToItemGroup(this._intersectedObject);
+                            }
+                        }
+                        break;
+                    case SceneEventState.DRAGGING:
+                        if (this._selectedObject) {
+                            this._dragAndDropService.clickReleased();
+                        }
+                        this._switchState(SceneEventState.SELECTED);
+                        break;
+                    case SceneEventState.ROTATING:
+                        this._switchState(SceneEventState.SELECTED);
+                        if (this._selectedObject) {
+                            this._dragAndDropService.clickReleased();
+                            this._messageBusService.emit(MessageType.SaveState, { action: 'item rotated' });
+                        }
+                        break;
+                    case SceneEventState.EXPLORE:
+                        if (!this._mouseMoved) {
+                            yield this._navigateExplore();
+                        }
+                        break;
+                }
+            }
+        });
+    }
+    _touchMoveEvent(event) {
+        if (this._state === SceneEventState.DND) {
+            return this._dragOverEvent.bind(this)(event);
+        }
+        if (this._isMouseEventAllowed(event)) {
+            this._setMousePositionFromTouchEvent(event);
+            this._mouseMoved = true;
+            if (!this._mouseDown) {
+                this._updateIntersections();
+            }
+            switch (this._state) {
+                case SceneEventState.UNSELECTED:
+                    this._updateMouseover();
+                    break;
+                case SceneEventState.SELECTED:
+                    this._updateMouseover();
+                    this._hudService.cameraRotation();
+                    break;
+                case SceneEventState.DRAGGING:
+                case SceneEventState.ROTATING:
+                    this._clickDragged();
+                    this._markSceneToUpdate();
+                    break;
+            }
+        }
+    }
+    _clearIntersectedObject() {
+        this._intersectedMesh = null;
+        this._intersectedObject = null;
+    }
+    _toggleRotationHudIntersection(on) {
+        if (this._hudService.isMouseOver() !== on) {
+            this._rotateMouseOver = on;
+            this._hudService.setMouseOver(on);
+        }
+    }
+    _updateIntersections() {
+        const intersects = this._getIntersections(this._mousePosition, this._itemService.getObjectPlanes(), { onlyVisible: true, includeFloors: false });
+        const wallIntersect = this._wallIntersection(this._mousePosition);
+        // object intersection is prioritized
+        if (intersects.length > 0 &&
+            ((wallIntersect && wallIntersect.distance + this.intersectOffsetForWalls > intersects[0].distance) || !wallIntersect)) {
+            this._toggleRotationHudIntersection(false);
+            this._setIntersectedObject(intersects[0].object);
+        }
+        else {
+            this._clearIntersectedObject();
+            const snapperArea = this._hudService.getRotationSnapperArea();
+            if (snapperArea === null) {
+                // check if intersects with configurable floor
+                const floorIntersects = this._getIntersections(this._mousePosition, this._itemService.getObjectPlanes(), { onlyVisible: true, includeFloor: true, onlyConfigurableFloors: true });
+                if (floorIntersects.length > 0) {
+                    this._toggleRotationHudIntersection(false);
+                    this._setIntersectedObject(floorIntersects[0].object);
+                }
+                else {
+                    return;
+                }
+            }
+            const hudIntersects = this._getIntersections(this._mousePosition, [snapperArea], { recursive: true });
+            if (hudIntersects.length > 0) {
+                this._toggleRotationHudIntersection(true);
+            }
+            else {
+                this._toggleRotationHudIntersection(false);
+            }
+        }
+    }
+    // returns the first intersection object
+    _itemIntersection(vec2, item) {
+        let intersections = null;
+        if (!item.metadata) {
+            intersections = this._getIntersections(vec2, [item], { filterByNormals: true });
+        }
+        else if (isWallFloorType(item.metadata.itemType)) {
+            intersections = this._getIntersections(vec2, this._roomService.wallEdgePlanes(), { filterByNormals: true });
+            if (!intersections || intersections.length === 0) {
+                intersections = this._getIntersections(vec2, [this._floorService.groundPlane], {});
+            }
+        }
+        else if (isWallType(item.metadata.itemType)) {
+            intersections = this._getIntersections(vec2, this._roomService.wallEdgePlanes(), { filterByNormals: true });
+        }
+        else {
+            intersections = this._getIntersections(vec2, [this._floorService.groundPlane], {});
+        }
+        if (intersections && intersections.length > 0) {
+            return intersections[0];
+        }
+        else {
+            return null;
+        }
+    }
+    // filter by normals will only return objects facing the camera
+    _getIntersections(mousePos, objects, options) {
+        const mouseVector = this._mouseToVec3(mousePos);
+        return this._intersectionService.getIntersections(mouseVector, objects, options);
+    }
+    _setMousePositionFromTouchEvent(event) {
+        const touch = event.touches[0];
+        if (touch) {
+            const canvas = event.target;
+            this._mousePosition.set(touch.pageX - (canvas ? canvas.offsetLeft : 0), touch.pageY - (canvas ? canvas.offsetTop : 0));
+        }
+    }
+    _touchStartEvent(event) {
+        if (this._isMouseEventAllowed(event)) {
+            const longTouch = of(1)
+                .pipe(delay(this.longTouchDuration))
+                .pipe(takeUntil(this._touchStart))
+                .pipe(takeUntil(this._touchEnd))
+                .pipe(takeUntil(this._touchCancel));
+            longTouch.subscribe(() => {
+                this._updateIntersections();
+                if (this._intersectedObject && !this._mouseMoved) {
+                    this._addToItemGroup(this._intersectedObject, this._prevSelectedObject);
+                }
+            });
+            this._mouseMoved = false;
+            this._mouseDown = true;
+            this._setMousePositionFromTouchEvent(event);
+            switch (this._state) {
+                case SceneEventState.SELECTED:
+                    this._updateIntersections();
+                    if (this._rotateMouseOver || this.rotateNoDrag) {
+                        this._switchState(SceneEventState.ROTATING);
+                        const itemIntersection = this._itemIntersection(this._mousePosition, this._selectedObject);
+                        if (itemIntersection) {
+                            this._rotationStartPoint = itemIntersection.point;
+                        }
+                    }
+                    else if (this._intersectedObject) {
+                        this._prevSelectedObject = this._selectedObject;
+                        if (!this._intersectedObject.fixed) {
+                            this._switchState(SceneEventState.DRAGGING);
+                        }
+                    }
+                    break;
+                case SceneEventState.DND:
+                    this._onDrop(event);
+                    break;
+            }
+        }
+    }
+    _leftMouseDownEvent(event) {
+        if (this._isMouseEventAllowed(event)) {
+            if (event) {
+                event.preventDefault();
+            }
+            const canvas = event.currentTarget;
+            const mousePos = RelativePositionUtils.GetClientMousePosition(event);
+            this._oldMousePosition.set(mousePos.x - (canvas ? canvas.offsetLeft : 0), mousePos.y - (canvas ? canvas.offsetTop : 0));
+            this._mouseMoved = false;
+            this._mouseDown = true;
+            switch (this._state) {
+                case SceneEventState.SELECTED:
+                    if (this._rotateMouseOver) {
+                        if (this._selectedObject) {
+                            this._switchState(SceneEventState.ROTATING);
+                            const itemIntersection = this._itemIntersection(this._mousePosition, this._selectedObject);
+                            if (itemIntersection) {
+                                this._rotationStartPoint = itemIntersection.point;
+                            }
+                        }
+                    }
+                    else if (this._intersectedObject) {
+                        if (this._intersectedMesh && this._intersectedMesh.name && this._intersectedMesh.name.toLowerCase().startsWith('c_')) {
+                            this._switchState(SceneEventState.DRAGGINGCONNECTOR);
+                        }
+                        else {
+                            if (!event.ctrlKey) {
+                                if (this._groupingMode) {
+                                    this._addToItemGroup(this._intersectedObject, this._selectedObject);
+                                }
+                                else {
+                                    this._itemGroupService.resetObjectsToGroup();
+                                    this.setSelectedObject(this._intersectedObject, this._intersectedMesh);
+                                }
+                            }
+                            else {
+                                this._addToItemGroup(this._intersectedObject, this._selectedObject);
+                            }
+                            if (!this._intersectedObject.fixed && !this.rotateNoDrag) {
+                                this._switchState(SceneEventState.DRAGGING);
+                            }
+                        }
+                    }
+                    break;
+                case SceneEventState.UNSELECTED:
+                    const floor = this._floorIntersection(this._mousePosition);
+                    if (floor) {
+                        if (floor.object.parent && floor.object.parent instanceof Item && floor.object.parent.configurable) {
+                            this._setIntersectedObject(floor.object);
+                        }
+                    }
+                    if (this._intersectedObject) {
+                        this._itemGroupService.resetObjectsToGroup();
+                        this.setSelectedObject(this._intersectedObject, this._intersectedMesh);
+                        if (!this._intersectedObject.fixed) {
+                            if (this.rotateNoDrag) {
+                                const itemIntersection = this._itemIntersection(this._mousePosition, this._selectedObject);
+                                if (itemIntersection) {
+                                    this._rotationStartPoint = itemIntersection.point;
+                                }
+                                this._switchState(SceneEventState.ROTATING);
+                            }
+                            else {
+                                this._switchState(SceneEventState.DRAGGING);
+                            }
+                        }
+                    }
+                    break;
+            }
+        }
+    }
+    _overrideDefaultCursorStyle(style) {
+        this._defaultCursorStyle = style;
+        this._setCursorStyle(this._defaultCursorStyle);
+    }
+    _setGroupingMode(enableGrouping) {
+        this._groupingMode = enableGrouping;
+        this._addToItemGroup(this._intersectedObject, this._prevSelectedObject);
+    }
+    _getDraggedData() {
+        return this._dragAndDropService.draggedData;
+    }
+    _clickPressed(vec2) {
+        const vec = vec2 || this._mousePosition;
+        if (this._selectedObject) {
+            const intersection = this._itemIntersection(vec, this._selectedObject);
+            if (intersection) {
+                this._dragAndDropService.draggedItem = this._selectedObject;
+                this._dragAndDropService.setDragOffset(intersection.point);
+            }
+        }
+    }
+    _clickConnectorPressed(vec2) {
+        const vec = vec2 || this._mousePosition;
+        if (this._intersectedMesh) {
+            const intersections = this._getIntersections(vec, [this._intersectedMesh, this._floorService.groundPlane]);
+            if (intersections && intersections.length > 1 && intersections.find(i => i.object.name === this._intersectedMesh.name)) {
+                const groundPlane = intersections.find(i => i.object.name === 'ground-plane');
+                if (groundPlane) {
+                    this._dragAndDropService.setDragOffset(groundPlane.point, false);
+                }
+            }
+        }
+    }
+    _clickDragged() {
+        if (this._selectedObject && !this._selectedObject.locked) {
+            const intersection = this._itemIntersection(this._mousePosition, this._selectedObject);
+            if (intersection) {
+                if (this._isRotating()) {
+                    this._rotationStartPoint =
+                        this._rotationService.rotate(this._selectedObject, this._rotationStartPoint, intersection.point, !this.rotateNoDrag);
+                }
+                else {
+                    this._dragAndDropService.clickDragged(intersection);
+                    this._messageBusService.emit(MessageType.ClickDragged);
+                    this._debouncedSaveState.next('item dragged');
+                }
+                this._hudService.update();
+            }
+        }
+    }
+    _dragConnector() {
+        if (this._selectedObject && !this._selectedObject.locked) {
+            // const intersections = this._getIntersections(this._mousePosition, [this._floorService.groundPlane], {});
+            // if (intersections && intersections.length === 1) {
+            //   this._dragAndDropService.dragConnector(this._intersectedMesh, intersections[0].point);
+            // }
+            this._dragAndDropService.dragConnector(this._intersectedMesh, this._mouseToVec3(this._mousePosition));
+        }
+    }
+    _checkWallsAndFloors(event) {
+        if (this._state === SceneEventState.UNSELECTED && this._mouseoverObject == null) {
+            const wall = this._wallIntersection(this._mousePosition);
+            if (wall) {
+                const edge = wall.object.userData.edge;
+                this._roomService.selectWall(event, edge.wall, edge);
+                return;
+            }
+            const floor = this._floorIntersection(this._mousePosition);
+            if (floor) {
+                const room = floor.object.userData.room;
+                this._roomService.selectFloor(event, room);
+                return;
+            }
+        }
+    }
+    _wallIntersection(vec2) {
+        const intersections = this._wallIntersections(vec2);
+        if (intersections && intersections.length > 0) {
+            return intersections[0];
+        }
+        else {
+            return null;
+        }
+    }
+    _wallIntersections(vec2) {
+        const wallEdgePlanes = this._roomService.wallEdgePlanes();
+        return this._getIntersections(vec2, wallEdgePlanes, { filterByNormals: true });
+    }
+    _edgeIntersections(vec2) {
+        const edges = this._roomService.floorPlanes();
+        return this._getIntersections(vec2, edges, { filterByNormals: true });
+    }
+    _groundIntersections(vec2) {
+        return this._getIntersections(vec2, [this._floorService.groundPlane], { filterByNormals: true });
+    }
+    _wallEdgeIntersected(intersectedWalls, intersectedEdges) {
+        const walls = intersectedEdges.map((i) => i.object.userData.wall);
+        const filteredWalls = intersectedWalls.filter((intersectedWall) => {
+            const wall = intersectedWall.object.userData.edge && intersectedWall.object.userData.edge.wall;
+            return walls.indexOf(wall) !== -1;
+        });
+        return filteredWalls.length > 0;
+    }
+    _floorIntersection(vec2) {
+        const floorPlanes = this._roomService.floorPlanes();
+        const floorIntersects = this._getIntersections(vec2, floorPlanes, { filterByNormals: false, includeFloors: true });
+        if (floorIntersects.length > 0) {
+            return floorIntersects[0];
+        }
+        else {
+            return null;
+        }
+    }
+    _pointOnFloor(vec2) {
+        if (this._intersectedObject &&
+            !(isOnFloorType(this._intersectedObject.userData.itemType) || isInWallType(this._intersectedObject.userData.itemType))) {
+            return null;
+        }
+        const intersectedFloor = this._floorIntersection(vec2);
+        if (!intersectedFloor) {
+            return null;
+        }
+        const intersectedWalls = this._wallIntersections(vec2);
+        if (!intersectedWalls.length) {
+            return intersectedFloor.point;
+        }
+        const intersectedEdges = this._edgeIntersections(vec2);
+        if (this._wallEdgeIntersected(intersectedWalls, intersectedEdges)) {
+            return null;
+        }
+        return intersectedFloor.point;
+    }
+    _isMouseEventAllowed(event) {
+        return event ? (event.target && event.target.nodeName === 'CANVAS') : true;
+    }
+    _mouseMoveEvent(event) {
+        if (this._state === SceneEventState.DND) {
+            return this._dragOverEvent.bind(this)(event);
+        }
+        if (this._isMouseEventAllowed(event)) {
+            const mousePos = event ? RelativePositionUtils.GetClientMousePosition(event) : this._mousePosition;
+            let canvas;
+            if (event) {
+                event.preventDefault();
+                canvas = event.currentTarget;
+            }
+            this._mousePosition.set(mousePos.x - (canvas ? canvas.offsetLeft : 0), mousePos.y - (canvas ? canvas.offsetTop : 0));
+            if (this._oldMousePosition.x !== mousePos.x && this._oldMousePosition.y !== mousePos.y) {
+                this._mouseMoved = true;
+            }
+            if (!this._mouseDown) {
+                this._updateIntersections();
+            }
+            else {
+                this._dragAndDropService.intersectedWall = this._wallIntersection(this._mousePosition);
+                this._dragAndDropService.intersectedFloor = this._floorIntersection(this._mousePosition);
+            }
+            if (this.rotateNoDrag) {
+                this._controls.enabled = true;
+                return;
+            }
+            switch (this._state) {
+                case SceneEventState.UNSELECTED:
+                    this._updateMouseover();
+                    break;
+                case SceneEventState.SELECTED:
+                    if (this._mouseDown && this._mouseMoved) {
+                        this._hudService.cameraRotation();
+                    }
+                    this._updateMouseover();
+                    break;
+                case SceneEventState.EXPLORE:
+                    this._hudService.stopExplore();
+                    if (this._mouseDown) {
+                        this._setCursorStyle('move');
+                    }
+                    else {
+                        this._explorePressed = false;
+                        if (!this._mouseoverObject) {
+                            this._updateExplorePoint();
+                        }
+                    }
+                    break;
+                case SceneEventState.DRAGGING:
+                case SceneEventState.ROTATING:
+                    this._clickDragged();
+                    this._markSceneToUpdate();
+                    this._eventService.objectMovingOrRotating.next();
+                    break;
+                case SceneEventState.DRAGGINGCONNECTOR:
+                    this._dragConnector();
+                    break;
+            }
+        }
+    }
+    _updateExplorePoint() {
+        const point = this._pointOnFloor(this._mousePosition);
+        if (point) {
+            this._setCursorStyle('pointer');
+            const distance = this._camera.position.distanceTo(point);
+            this._hudService.exploreFloorHover(this._mousePosition, point, distance);
+        }
+        else {
+            this._setCursorStyle('crosshair');
+            this._hudService.stopExplore();
+        }
+    }
+    _updateExploreIndicator() {
+        this._hudService.stopExplore();
+        const point = this._pointOnFloor(this._mousePosition);
+        if (point) {
+            this._setCursorStyle('pointer');
+        }
+        else {
+            this._setCursorStyle('crosshair');
+        }
+    }
+    _acceptDrop(event) {
+        if (event.dataTransfer && event.dataTransfer.dropEffect) {
+            event.dataTransfer.dropEffect = 'copy';
+        }
+    }
+    _releaseState(draggedData) {
+        if (draggedData && draggedData.isCopy) {
+            this._switchState(SceneEventState.SELECTED);
+        }
+        else {
+            this._switchState(SceneEventState.UNSELECTED);
+        }
+    }
+    _addToItemGroup(object, prevSelectedObject) {
+        const isIntersectWithGroupMember = object instanceof ItemGroup || object.parent instanceof ItemGroup;
+        if (!isIntersectWithGroupMember && !object.configuring && this._canGroupItems(object, prevSelectedObject)) {
+            if (prevSelectedObject) {
+                this._itemGroupService.addIfNotExist(prevSelectedObject);
+            }
+            this._itemGroupService.addOrRemoveIfExist(object);
+        }
+    }
+    _canGroupFloorItem(item) {
+        return !(item instanceof WallItem) || (item instanceof CustomWallFloorItem && !item.currentWall);
+    }
+    _canGroupWallItem(item) {
+        return ((item instanceof WallItem && !(item instanceof InWallItem)) ||
+            (item instanceof CustomWallFloorItem && item.currentWall !== undefined));
+    }
+    _canGroupItems(newItem, previousItem) {
+        return this._canGroupWallItem(newItem) && this._canGroupWallItem(previousItem) &&
+            newItem.currentWall === previousItem.currentWall ||
+            this._canGroupFloorItem(newItem) && this._canGroupFloorItem(previousItem);
+    }
+    _switchState(newState) {
+        if (newState !== this._state) {
+            this._onExit(this._state);
+            this._onEntry(newState);
+        }
+        this._state = newState;
+        this._hudService.setRotating(this._isRotating());
+    }
+    _onEntry(onState) {
+        switch (onState) {
+            case SceneEventState.UNSELECTED:
+                this.setSelectedObject(null);
+                this._controls.enabled = true;
+                break;
+            case SceneEventState.SELECTED:
+                this._controls.enabled = true;
+                break;
+            case SceneEventState.ROTATING:
+                this._controls.enabled = this._appService.sku;
+                break;
+            case SceneEventState.DRAGGING:
+                this._setCursorStyle('move');
+                this._clickPressed();
+                this._controls.enabled = false;
+                break;
+            case SceneEventState.DRAGGINGCONNECTOR:
+                this._clickConnectorPressed();
+                this._controls.enabled = false;
+                break;
+            case SceneEventState.EXPLORE:
+                this._overrideDefaultCursorStyle('pointer');
+                this.setSelectedObject(null);
+                this._cameraMoveSub = this._cameraService.cameraMovementChanged.subscribe(() => this._updateExploreIndicator());
+                break;
+        }
+    }
+    _onExit(onState) {
+        switch (onState) {
+            case SceneEventState.UNSELECTED:
+            case SceneEventState.SELECTED:
+                break;
+            case SceneEventState.DRAGGING:
+                this._setCursorStyle(this._defaultCursorStyle);
+                break;
+            case SceneEventState.ROTATING:
+                break;
+            case SceneEventState.EXPLORE:
+                this._overrideDefaultCursorStyle('auto');
+                this._hudService.stopExplore();
+                if (this._cameraMoveSub) {
+                    this._cameraMoveSub.unsubscribe();
+                }
+                break;
+        }
+    }
+    _setIntersectedObject(mesh) {
+        this._intersectedMesh = mesh;
+        if (typeof mesh['getRoot'] === 'function') {
+            this._intersectedObject = mesh.getRoot();
+        }
+        else if (mesh.parent) {
+            this._setIntersectedObject(mesh.parent);
+        }
+    }
+    // Reverted changes from IONE-31399
+    _mouseToVec3(vec2) {
+        const rendererElement = this._element;
+        const mPosition = new Vector2((vec2.x / rendererElement.clientWidth) * 2 - 1, -(vec2.y / rendererElement.clientHeight) * 2 + 1);
+        const vector = new Vector3(mPosition.x, mPosition.y, 0.5);
+        vector.unproject(this._camera);
+        return vector;
+        // const rendererElement = this._element;
+        // const mPosition = new Vector2(
+        //   (vec2.x / rendererElement.clientWidth) * 2 - 1,
+        //   -(vec2.y / rendererElement.clientHeight) * 2 + 1
+        // );
+        // const vector = new Vector3(mPosition.x, mPosition.y, 0.5);
+        // vector.unproject(this._camera);
+        // return vector;
+    }
+    _setSelectObject(object, mesh) {
+        object.setSelected(mesh, this._mouseToVec3(this._mousePosition));
+        this._selectedObject = object;
+        this._messageBusService.emit(MessageType.ItemSelected, object);
+    }
+    _updateMouseover() {
+        if (this._intersectedObject != null) {
+            if (this._mouseoverObject != null) {
+                if (this._mouseoverObject !== this._intersectedObject) {
+                    this._setObjectMouseOff(this._mouseoverObject);
+                    this._mouseoverObject = this._intersectedObject;
+                    this._setObjectMouseOver(this._mouseoverObject, this._intersectedMesh);
+                    this._markSceneToUpdate();
+                }
+                else {
+                    // do nothing, mouseover already set
+                }
+            }
+            else {
+                this._mouseoverObject = this._intersectedObject;
+                this._setObjectMouseOver(this._mouseoverObject, this._intersectedMesh);
+                this._setCursorStyle('pointer');
+                this._markSceneToUpdate();
+            }
+        }
+        else if (this._mouseoverObject != null) {
+            this._setObjectMouseOff(this._mouseoverObject);
+            this._setCursorStyle(this._defaultCursorStyle);
+            this._mouseoverObject = null;
+            this._markSceneToUpdate();
+        }
+    }
+    _setObjectMouseOver(object, mesh) {
+        if (object.parent && object.parent instanceof ItemGroup) {
+            object.parent.mouseOver();
+        }
+        else {
+            object.mouseOver(mesh);
+        }
+    }
+    _setObjectMouseOff(object) {
+        if (object.parent && object.parent instanceof ItemGroup) {
+            object.parent.mouseOff();
+        }
+        else {
+            object.mouseOff();
+        }
+    }
+    _markSceneToUpdate() {
+        this._sceneService.needsRender = true;
+    }
+    _setCursorStyle(style) {
+        this._element.style.cursor = style;
+    }
+}
+SceneEventService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SceneEventService, deps: [{ token: i1.HudService }, { token: i2.MessageBusService }, { token: i3.SceneService }, { token: i4.DragAndDropService }, { token: i5.RotationService }, { token: i6.CameraService }, { token: i7.RoomService }, { token: i8.FloorService }, { token: i9.IntersectionService }, { token: i10.ViewModeService }, { token: i11.ItemGroupService }, { token: i12.ItemService }, { token: i13.HomedecoratorAppService }, { token: i14.HomedecoratorAppEventService }], target: i0.ɵɵFactoryTarget.Injectable });
+SceneEventService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SceneEventService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SceneEventService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HudService }, { type: i2.MessageBusService }, { type: i3.SceneService }, { type: i4.DragAndDropService }, { type: i5.RotationService }, { type: i6.CameraService }, { type: i7.RoomService }, { type: i8.FloorService }, { type: i9.IntersectionService }, { type: i10.ViewModeService }, { type: i11.ItemGroupService }, { type: i12.ItemService }, { type: i13.HomedecoratorAppService }, { type: i14.HomedecoratorAppEventService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scene-event.service.js","sourceRoot":"","sources":["../../../../../../../src/client/app/plugins/core3d/service/scene-event.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\r\nimport {Item} from '../items/item';\r\nimport {Camera, Intersection, Mesh, Object3D, Vector2, Vector3} from 'three';\r\nimport {SceneEventState} from '../model/scene-event.enum';\r\nimport {HudService} from './hud.service';\r\nimport {DragAndDropService} from './drag-and-drop.service';\r\nimport {CameraService} from './camera.service';\r\nimport {Observable, Subject, Subscription} from 'rxjs';\r\nimport {fromEvent} from 'rxjs/internal/observable/fromEvent';\r\nimport {debounceTime, delay, filter, takeUntil} from 'rxjs/operators';\r\nimport {of} from 'rxjs/internal/observable/of';\r\nimport {MessageBusService} from '../../../core/service/message-bus.service';\r\nimport {SceneService} from './scene.service';\r\nimport {RotationService} from './rotation.service';\r\nimport {RoomService} from '../../room-planner/components/floorplanner/service/room.service';\r\nimport {FloorService} from './floor.service';\r\nimport {IntersectionService} from './intersection.service';\r\nimport {ViewModeService} from '../../../core/service/view-mode.service';\r\nimport {ItemGroupService} from './item-group.service';\r\nimport {ItemService} from './item.service';\r\nimport {HomedecoratorAppService} from '../../../core/service/homedecorator-app.service';\r\nimport {MessageType} from '../../../core/enum/message-type.enum';\r\nimport {ViewMode} from '../../../core/enum/view-mode.enum';\r\nimport {RelativePositionUtils} from '../../../core/utils/relative-position.utils';\r\nimport {CustomWallFloorItem} from '../items/custom-wall-floor-item';\r\nimport {ItemGroup} from '../items/item-group';\r\nimport {isFloorDecoration, isFloorType, isFurnitureType, isInWallType, isOnFloorType, isWallFloorType, isWallType} from '../items/factory';\r\nimport {InWallItem, WallItem} from '../items/wall-objects';\r\nimport {CustomMesh} from '../items/custom-objects';\r\nimport {HomedecoratorAppEventService} from '../../../core/service/homedecorator-app-event.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class SceneEventService implements OnDestroy {\r\n  public readonly intersectOffsetForWalls = 20;\r\n  public readonly longTouchDuration = 600;\r\n\r\n  public rotateNoDrag: boolean = false;\r\n\r\n  private _element: HTMLElement;\r\n  private _controls: any;\r\n  private _camera: Camera;\r\n\r\n  private _mousePosition: Vector2 = new Vector2();\r\n  private _oldMousePosition: Vector2 = new Vector2();\r\n\r\n  private _rotationStartPoint: Vector3 = null;\r\n\r\n  private _intersectedObject: Item;\r\n  private _intersectedMesh: CustomMesh | Mesh;\r\n  private _mouseoverObject: Item;\r\n  private _selectedObject: any;\r\n  private _prevSelectedObject: any;\r\n  private _defaultCursorStyle = 'pointer';\r\n  private _explorePressed = false;\r\n  private _inDragOver = false;\r\n\r\n  private _mouseDown = false;\r\n  private _mouseMoved = false; // has mouse moved since down click\r\n\r\n  private _rotateMouseOver = false;\r\n  private _groupingMode: boolean = false;\r\n\r\n  private _state = SceneEventState.UNSELECTED;\r\n\r\n  private _intersectedWall: Intersection;\r\n  private _intersectedFloor: Intersection;\r\n\r\n  private _subs: Subscription[] = [];\r\n  private _cameraMoveSub: Subscription;\r\n\r\n  private _debouncedSaveState: Subject<string> = new Subject();\r\n  private _touchStart: Observable<Event>;\r\n  private _touchEnd: Observable<Event>;\r\n  private _touchCancel: Observable<Event>;\r\n  private _touchMove: Observable<Event>;\r\n\r\n  constructor(\r\n    private _hudService: HudService,\r\n    private _messageBusService: MessageBusService,\r\n    private _sceneService: SceneService,\r\n    private _dragAndDropService: DragAndDropService,\r\n    private _rotationService: RotationService,\r\n    private _cameraService: CameraService,\r\n    private _roomService: RoomService,\r\n    private _floorService: FloorService,\r\n    private _intersectionService: IntersectionService,\r\n    private _viewModeService: ViewModeService,\r\n    private _itemGroupService: ItemGroupService,\r\n    private _itemService: ItemService,\r\n    private _appService: HomedecoratorAppService,\r\n    private _eventService: HomedecoratorAppEventService\r\n  ) {\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this._subs.forEach(s => s.unsubscribe());\r\n    this._element = undefined;\r\n  }\r\n\r\n  public init(element: HTMLElement) {\r\n    this._element = element;\r\n    this._controls = this._cameraService.controls;\r\n    this._camera = this._cameraService.camera;\r\n\r\n    this._touchStart = fromEvent(element, 'touchstart');\r\n    this._touchEnd = fromEvent(element, 'touchend');\r\n    this._touchCancel = fromEvent(element, 'touchcancel');\r\n    this._touchMove = fromEvent(element, 'touchmove');\r\n\r\n    fromEvent(element, 'mousedown')\r\n      .pipe(filter((event: MouseEvent) => event.button === 0))\r\n      .subscribe(event => this._leftMouseDownEvent(event));\r\n    fromEvent(element, 'mouseup').subscribe((event: MouseEvent) => this._mouseUpEvent(event));\r\n    fromEvent(element, 'mousemove').subscribe((event: MouseEvent) => this._mouseMoveEvent(event));\r\n    this._touchStart.subscribe((event: TouchEvent) => this._touchStartEvent(event));\r\n    this._touchEnd.subscribe((event: TouchEvent) => this._touchEndEvent(event));\r\n    this._touchCancel.subscribe((event: TouchEvent) => this._touchEndEvent(event));\r\n    this._touchMove.subscribe((event: TouchEvent) => this._touchMoveEvent(event));\r\n    fromEvent(window, 'keydown').subscribe((event: KeyboardEvent) => this._keyDownEvent(event));\r\n    fromEvent(element, 'dragenter').subscribe((event: DragEvent) => this._dragEnterEvent(event));\r\n    fromEvent(element, 'dragexit').subscribe((event: DragEvent) => this._dragExitEvent(event));\r\n    fromEvent(element, 'dragover').subscribe((event: DragEvent) => this._dragOverEvent(event));\r\n    fromEvent(element, 'drop').subscribe(event => this._onDrop(event));\r\n\r\n    this._subs.push(\r\n      this._messageBusService.subscribe(MessageType.SetDrag, (data) => {\r\n        if (data instanceof Item) {\r\n          this._dragAndDropService.draggedData = {\r\n            name: data.name,\r\n            type: data.metadata.itemType\r\n          };\r\n          this._dragAndDropService.draggedItem = data;\r\n        } else {\r\n          this._dragAndDropService.draggedData = data;\r\n        }\r\n      }),\r\n      this._messageBusService.subscribe(MessageType.StartDrag, ({x, y, z}) =>\r\n        this.startDragging(x, y, z)),\r\n      this._messageBusService.subscribe(MessageType.ExitDrag, () => this._dragExitEvent(event)),\r\n      this._messageBusService.subscribe(MessageType.PlaceOnTouch, () => this._initPlaceOnTouchRequest()),\r\n      this._debouncedSaveState.pipe(debounceTime(800)).subscribe((action: string) => {\r\n        this._messageBusService.emit(MessageType.SaveState, {action: `3D ${action}`});\r\n      }),\r\n      this._debouncedSaveState.pipe(debounceTime(200)).subscribe(() => {\r\n        this._hudService.updateLabelMeasurements();\r\n      }),\r\n      this._viewModeService.viewModeChanged.subscribe(mode => this.setExploreMode(mode === ViewMode.WalkThrough)),\r\n      this._itemGroupService.objectAdded.subscribe((object) => this.setSelectedObject(object)),\r\n      this._itemGroupService.grouped.subscribe((object) => this.setSelectedObject(object)),\r\n      this._itemGroupService.ungrouped.subscribe(() => this.setSelectedObject(null)),\r\n      this._messageBusService.subscribe(MessageType.ItemRemoved, () => this.setSelectedObject(null)),\r\n      this._messageBusService.subscribe(MessageType.StartGroupObject, () => this._setGroupingMode(true))\r\n    );\r\n\r\n  }\r\n  public setExploreMode(on = true) {\r\n    if (on) {\r\n      this._switchState(SceneEventState.EXPLORE);\r\n    } else {\r\n      this._switchState(SceneEventState.UNSELECTED);\r\n    }\r\n  }\r\n\r\n  public setSelectedObject(object: Item | ItemGroup, mesh?: Mesh): void {\r\n    if (this._state === SceneEventState.UNSELECTED && object) {\r\n      this._switchState(SceneEventState.SELECTED);\r\n    }\r\n\r\n    if (this._selectedObject != null && this._selectedObject !== object) {\r\n      this._selectedObject.setUnselected();\r\n    }\r\n    if (object) {\r\n      if (object instanceof ItemGroup) {\r\n        this._setSelectObject(object);\r\n        this._itemGroupService.selectedGroup = object;\r\n      } else if (object.parent instanceof ItemGroup) {\r\n        this._setSelectObject(object.parent);\r\n        this._itemGroupService.selectedGroup = object.parent;\r\n      } else {\r\n        this._setSelectObject(object, mesh);\r\n      }\r\n    } else {\r\n      if (this._selectedObject) {\r\n        this._selectedObject.setUnselected();\r\n        this._messageBusService.emit(MessageType.ItemUnselected, this._selectedObject);\r\n        this._selectedObject = null;\r\n      }\r\n      this._prevSelectedObject = null;\r\n    }\r\n\r\n    this._markSceneToUpdate();\r\n  }\r\n\r\n  public startDragging(x: number, y: number, z?: number) {\r\n    const draggedData = this._getDraggedData();\r\n    if (!this._dragAndDropService.draggedStatus.allowedNew || !draggedData) {\r\n      return;\r\n    }\r\n    this._switchState(SceneEventState.DND);\r\n    this._dragAndDropService.draggedStatus.dragEnter();\r\n    const vec3: Vector3 = z ? new Vector3(x, y, z) : this.intersectingVec3(new Vector2(x, y));\r\n    if (this._dragAndDropService.draggedItem) {\r\n      this._dragAndDropService.draggedStatus.objectLoaded();\r\n      this._dragAndDropService.updateDraggedPosition(vec3);\r\n    } else if (isFurnitureType(draggedData.type) || isWallType(draggedData.type)) {\r\n      this._dragAndDropService.dragModel(vec3, this._floorIntersection(this._sceneService.positionInSceneToScreen(vec3)));\r\n    } else if (isFloorDecoration(draggedData.type)) {\r\n      this._dragAndDropService.dragFloorDecoration(this._floorIntersection(this._sceneService.positionInSceneToScreen(vec3)));\r\n    }\r\n  }\r\n\r\n  public intersectingVec3(vec2: Vector2, intersection?: Intersection): Vector3 {\r\n    if (!intersection) {\r\n      const gIntersections = this._groundIntersections(vec2);\r\n      return gIntersections && gIntersections[0] && gIntersections[0].point;\r\n    } else {\r\n      return intersection.point;\r\n    }\r\n  }\r\n\r\n  private _isRotating() {\r\n    return this._state === SceneEventState.ROTATING && (!this._appService.sku || this._viewModeService.viewMode === ViewMode.InPhotoView);\r\n  }\r\n\r\n  private _keyDownEvent(event: KeyboardEvent): void {\r\n    if (event.key === 'Escape') {\r\n      this._cancelDragDrop();\r\n    }\r\n  }\r\n\r\n  private _dragEnterEvent(event: DragEvent) {\r\n    event.preventDefault();\r\n    const mousePos: Vector2 = RelativePositionUtils.GetClientMousePosition(event);\r\n    this.startDragging(mousePos.x, mousePos.y);\r\n  }\r\n\r\n  private _dragExitEvent(event) {\r\n    if (event) {\r\n      event.preventDefault();\r\n    }\r\n    const draggedData = this._getDraggedData();\r\n    if (draggedData) {\r\n      this._dragAndDropService.finishDragging();\r\n      this._switchState(SceneEventState.UNSELECTED);\r\n    }\r\n  }\r\n\r\n  private _dragOverEvent(event) {\r\n    event.preventDefault();\r\n    if (this._state !== SceneEventState.DND || this._inDragOver) {\r\n      return;\r\n    }\r\n\r\n    this._inDragOver = true;\r\n    this._dragAndDropService.draggedStatus.dragOver();\r\n    const canvas: HTMLElement = event.currentTarget;\r\n    const mousePos: Vector2 = RelativePositionUtils.GetClientMousePosition(event);\r\n    this._mousePosition.set(mousePos.x - (canvas ? canvas.offsetLeft : 0), mousePos.y - (canvas ? canvas.offsetTop : 0));\r\n\r\n    const draggedData = this._dragAndDropService.draggedData;\r\n\r\n    let intersection: Intersection = this._wallIntersection(this._mousePosition);\r\n    const intersectedFloor: Intersection = this._floorIntersection(this._mousePosition);\r\n\r\n    this._dragAndDropService.intersectedWall = intersection;\r\n    this._dragAndDropService.intersectedFloor = intersectedFloor;\r\n    this._intersectedWall = undefined;\r\n    this._intersectedFloor = undefined;\r\n    if (isWallType(draggedData.type) || (isWallFloorType(draggedData.type) && intersection)) {\r\n      if (intersection) {\r\n        this._intersectedWall = intersection;\r\n      }\r\n      if (intersection && !isFurnitureType(draggedData.type)) {\r\n        this._acceptDrop(event);\r\n      }\r\n    } else if (isFloorType(draggedData.type) || isFloorDecoration(draggedData.type) || (isWallFloorType(draggedData.type) && intersectedFloor)) {\r\n      this._intersectedFloor = intersection = this._floorIntersection(this._mousePosition);\r\n    } else {\r\n      if (event.dataTransfer) {\r\n        event.dataTransfer.dropEffect = 'move';\r\n      }\r\n    }\r\n\r\n    const intersectedPoint: Vector3 = this.intersectingVec3(this._mousePosition, intersection);\r\n\r\n    if (intersectedPoint) {\r\n      this._dragAndDropService.updateDraggedPosition(intersectedPoint);\r\n      this._acceptDrop(event);\r\n      this._markSceneToUpdate();\r\n    }\r\n    this._inDragOver = false;\r\n  }\r\n\r\n  private async _onDrop(event): Promise<void> {\r\n    event.preventDefault();\r\n    if (this._state !== SceneEventState.DND) {\r\n      return;\r\n    }\r\n    const canvas: HTMLElement = event.currentTarget;\r\n    const mousePos: Vector2 = RelativePositionUtils.GetClientMousePosition(event);\r\n    this._mousePosition.set(mousePos.x - (canvas ? canvas.offsetLeft : 0), mousePos.y - (canvas ? canvas.offsetTop : 0));\r\n\r\n    const draggedData = this._dragAndDropService.draggedData;\r\n    let position: Vector3 = null;\r\n    let intersection: Intersection = null;\r\n\r\n    if (isWallType(draggedData.type) || (isWallFloorType(draggedData.type) && this._intersectedWall)) {\r\n      position = this._intersectedWall && this._intersectedWall.point;\r\n      intersection = this._intersectedWall;\r\n    } else if (isFloorType(draggedData.type) || isFloorDecoration(draggedData.type) || (isWallFloorType(draggedData.type) && this._intersectedFloor)) {\r\n      position = this._intersectedFloor && this._intersectedFloor.point;\r\n      intersection = this._intersectedFloor;\r\n    }\r\n    if (position) {\r\n      const intersectedPoint: Vector3 = this.intersectingVec3(this._mousePosition, intersection);\r\n      this._dragAndDropService.draggedPlaced(intersectedPoint, intersection);\r\n      this._messageBusService.emit(MessageType.SaveState, {action: 'item added'});\r\n    } else {\r\n      this._cancelDragDrop();\r\n    }\r\n\r\n    if (!this._dragAndDropService.draggedStatus.isObjectLoaded) {\r\n      this._dragAndDropService.draggedStatus.markToCleanUp();\r\n      this._releaseState(draggedData);\r\n    } else {\r\n      this._releaseState(draggedData);\r\n      this._dragAndDropService.finishDragging();\r\n    }\r\n  }\r\n\r\n  private _cancelDragDrop(): void {\r\n    this._dragAndDropService.draggedStatus.dragCanceled();\r\n    this._dragAndDropService.finishDragging();\r\n    this._switchState(SceneEventState.SELECTED);\r\n    this._messageBusService.emit(MessageType.FinishedIOneFurnitureBuild);\r\n  }\r\n\r\n  private async _mouseUpEvent(event?: MouseEvent): Promise<void> {\r\n    this._mouseDown = false;\r\n\r\n    if (this._state === SceneEventState.DND) {\r\n      return this._onDrop(event);\r\n    }\r\n\r\n    switch (this._state) {\r\n      case SceneEventState.DRAGGING:\r\n      case SceneEventState.DRAGGINGCONNECTOR:\r\n        this._switchState(SceneEventState.SELECTED);\r\n        if (this._selectedObject) {\r\n          this._dragAndDropService.clickReleased();\r\n          if (this._selectedObject instanceof Item) {\r\n            this._selectedObject.endDrag();\r\n          }\r\n        }\r\n        break;\r\n      case SceneEventState.ROTATING:\r\n        if (this._selectedObject) {\r\n          this._dragAndDropService.clickReleased();\r\n          this._messageBusService.emit(MessageType.SaveState, {action: 'item rotated'});\r\n        }\r\n        this._switchState(SceneEventState.SELECTED);\r\n        break;\r\n      case SceneEventState.UNSELECTED:\r\n        if (!this._selectedObject && !this._mouseMoved) {\r\n          this._checkWallsAndFloors(event);\r\n        }\r\n        break;\r\n      case SceneEventState.SELECTED:\r\n        if (!this._selectedObject && !this._mouseMoved) {\r\n          this._checkWallsAndFloors(event);\r\n        }\r\n        if (this._intersectedObject == null && !this._mouseMoved) {\r\n          this._switchState(SceneEventState.UNSELECTED);\r\n        }\r\n        break;\r\n      case SceneEventState.EXPLORE:\r\n        await this._navigateExplore();\r\n        break;\r\n    }\r\n  }\r\n\r\n  private async _navigateExplore(): Promise<void> {\r\n    this._overrideDefaultCursorStyle('pointer');\r\n    const point = this._pointOnFloor(this._mousePosition);\r\n    if (point) {\r\n      const distance = this._camera.position.distanceTo(point);\r\n      this._hudService.exploreFloorHover(this._mousePosition, point, distance);\r\n      if (!this._mouseMoved) {\r\n        await this._hudService.confirmExplore();\r\n        await this._cameraService.controls.animateMoveTo(point);\r\n        this._updateExplorePoint();\r\n      }\r\n    }\r\n  }\r\n\r\n  private _initPlaceOnTouchRequest(): void {\r\n    if (this._dragAndDropService.draggedStatus.allowedNew && this._getDraggedData()) {\r\n      this._switchState(SceneEventState.DND);\r\n    }\r\n  }\r\n\r\n  private async _touchEndEvent(event: TouchEvent): Promise<void> {\r\n    if (this._isMouseEventAllowed(event)) {\r\n      this._mouseDown = false;\r\n      switch (this._state) {\r\n        case SceneEventState.SELECTED:\r\n        case SceneEventState.UNSELECTED:\r\n          if (!this._mouseMoved) {\r\n            this._updateIntersections();\r\n            if (this._intersectedObject) {\r\n              this._itemGroupService.resetObjectsToGroup();\r\n              this.setSelectedObject(this._intersectedObject, this._intersectedMesh);\r\n              this._addToItemGroup(this._intersectedObject);\r\n            }\r\n          }\r\n          break;\r\n        case SceneEventState.DRAGGING:\r\n          if (this._selectedObject) {\r\n            this._dragAndDropService.clickReleased();\r\n          }\r\n          this._switchState(SceneEventState.SELECTED);\r\n          break;\r\n        case SceneEventState.ROTATING:\r\n          this._switchState(SceneEventState.SELECTED);\r\n          if (this._selectedObject) {\r\n            this._dragAndDropService.clickReleased();\r\n            this._messageBusService.emit(MessageType.SaveState, {action: 'item rotated'});\r\n          }\r\n          break;\r\n        case SceneEventState.EXPLORE:\r\n          if (!this._mouseMoved) {\r\n            await this._navigateExplore();\r\n          }\r\n          break;\r\n      }\r\n    }\r\n  }\r\n\r\n  private _touchMoveEvent(event: TouchEvent): void {\r\n    if (this._state === SceneEventState.DND) {\r\n      return this._dragOverEvent.bind(this)(event);\r\n    }\r\n    if (this._isMouseEventAllowed(event)) {\r\n      this._setMousePositionFromTouchEvent(event);\r\n\r\n      this._mouseMoved = true;\r\n      if (!this._mouseDown) {\r\n        this._updateIntersections();\r\n      }\r\n\r\n      switch (this._state) {\r\n        case SceneEventState.UNSELECTED:\r\n          this._updateMouseover();\r\n          break;\r\n        case SceneEventState.SELECTED:\r\n          this._updateMouseover();\r\n          this._hudService.cameraRotation();\r\n          break;\r\n        case SceneEventState.DRAGGING:\r\n        case SceneEventState.ROTATING:\r\n          this._clickDragged();\r\n          this._markSceneToUpdate();\r\n          break;\r\n      }\r\n    }\r\n  }\r\n\r\n  private _clearIntersectedObject(): void {\r\n    this._intersectedMesh = null;\r\n    this._intersectedObject = null;\r\n  }\r\n\r\n  private _toggleRotationHudIntersection(on: boolean): void {\r\n    if (this._hudService.isMouseOver() !== on) {\r\n      this._rotateMouseOver = on;\r\n      this._hudService.setMouseOver(on);\r\n    }\r\n  }\r\n\r\n  private _updateIntersections(): void {\r\n    const intersects = this._getIntersections(\r\n      this._mousePosition,\r\n      this._itemService.getObjectPlanes(),\r\n      {onlyVisible: true, includeFloors: false}\r\n    );\r\n\r\n    const wallIntersect = this._wallIntersection(this._mousePosition);\r\n\r\n    // object intersection is prioritized\r\n    if (intersects.length > 0 &&\r\n      ((wallIntersect && wallIntersect.distance + this.intersectOffsetForWalls > intersects[0].distance) || !wallIntersect)) {\r\n      this._toggleRotationHudIntersection(false);\r\n      this._setIntersectedObject(intersects[0].object);\r\n    } else {\r\n      this._clearIntersectedObject();\r\n      const snapperArea = this._hudService.getRotationSnapperArea();\r\n      if (snapperArea === null) {\r\n        // check if intersects with configurable floor\r\n        const floorIntersects = this._getIntersections(\r\n          this._mousePosition,\r\n          this._itemService.getObjectPlanes(),\r\n          {onlyVisible: true, includeFloor: true, onlyConfigurableFloors: true}\r\n        );\r\n        if (floorIntersects.length > 0) {\r\n          this._toggleRotationHudIntersection(false);\r\n          this._setIntersectedObject(floorIntersects[0].object);\r\n        } else {\r\n          return;\r\n        }\r\n      }\r\n\r\n      const hudIntersects = this._getIntersections(\r\n        this._mousePosition,\r\n        [snapperArea],\r\n        {recursive: true}\r\n      );\r\n      if (hudIntersects.length > 0) {\r\n        this._toggleRotationHudIntersection(true);\r\n      } else {\r\n        this._toggleRotationHudIntersection(false);\r\n      }\r\n    }\r\n  }\r\n\r\n  // returns the first intersection object\r\n  private _itemIntersection(vec2, item): any {\r\n    let intersections = null;\r\n    if (!item.metadata) {\r\n      intersections = this._getIntersections(vec2, [item], {filterByNormals: true});\r\n    } else if (isWallFloorType(item.metadata.itemType)) {\r\n      intersections = this._getIntersections(vec2, this._roomService.wallEdgePlanes(), {filterByNormals: true});\r\n      if (!intersections || intersections.length === 0) {\r\n        intersections = this._getIntersections(vec2, [this._floorService.groundPlane], {});\r\n      }\r\n    } else if (isWallType(item.metadata.itemType)) {\r\n      intersections = this._getIntersections(vec2, this._roomService.wallEdgePlanes(), {filterByNormals: true});\r\n    } else {\r\n      intersections = this._getIntersections(vec2, [this._floorService.groundPlane], {});\r\n    }\r\n    if (intersections && intersections.length > 0) {\r\n      return intersections[0];\r\n    } else {\r\n      return null;\r\n    }\r\n  }\r\n\r\n  // filter by normals will only return objects facing the camera\r\n  private _getIntersections(mousePos: Vector2, objects: Object3D[], options?): Intersection[] {\r\n    const mouseVector = this._mouseToVec3(mousePos);\r\n    return this._intersectionService.getIntersections(mouseVector, objects, options);\r\n  }\r\n  private _setMousePositionFromTouchEvent(event: TouchEvent) {\r\n    const touch = event.touches[0];\r\n    if (touch) {\r\n      const canvas: any = event.target;\r\n      this._mousePosition.set(touch.pageX - (canvas ? canvas.offsetLeft : 0), touch.pageY - (canvas ? canvas.offsetTop : 0));\r\n    }\r\n  }\r\n\r\n  private _touchStartEvent(event: TouchEvent): void {\r\n    if (this._isMouseEventAllowed(event)) {\r\n\r\n      const longTouch = of(1)\r\n        .pipe(delay(this.longTouchDuration))\r\n        .pipe(takeUntil(this._touchStart))\r\n        .pipe(takeUntil(this._touchEnd))\r\n        .pipe(takeUntil(this._touchCancel));\r\n      longTouch.subscribe(() => {\r\n        this._updateIntersections();\r\n        if (this._intersectedObject && !this._mouseMoved) {\r\n          this._addToItemGroup(this._intersectedObject, this._prevSelectedObject);\r\n        }\r\n      });\r\n\r\n      this._mouseMoved = false;\r\n      this._mouseDown = true;\r\n\r\n      this._setMousePositionFromTouchEvent(event);\r\n      switch (this._state) {\r\n        case SceneEventState.SELECTED:\r\n          this._updateIntersections();\r\n          if (this._rotateMouseOver || this.rotateNoDrag) {\r\n            this._switchState(SceneEventState.ROTATING);\r\n            const itemIntersection: any = this._itemIntersection(this._mousePosition, this._selectedObject);\r\n            if (itemIntersection) {\r\n              this._rotationStartPoint = itemIntersection.point;\r\n            }\r\n          } else if (this._intersectedObject) {\r\n            this._prevSelectedObject = this._selectedObject;\r\n            if (!this._intersectedObject.fixed) {\r\n              this._switchState(SceneEventState.DRAGGING);\r\n            }\r\n          }\r\n          break;\r\n        case SceneEventState.DND:\r\n          this._onDrop(event);\r\n          break;\r\n      }\r\n    }\r\n  }\r\n\r\n  private _leftMouseDownEvent(event?): void {\r\n    if (this._isMouseEventAllowed(event)) {\r\n      if (event) {\r\n        event.preventDefault();\r\n      }\r\n\r\n      const canvas: HTMLElement = event.currentTarget;\r\n      const mousePos: Vector2 = RelativePositionUtils.GetClientMousePosition(event);\r\n      this._oldMousePosition.set(mousePos.x - (canvas ? canvas.offsetLeft : 0), mousePos.y - (canvas ? canvas.offsetTop : 0));\r\n\r\n      this._mouseMoved = false;\r\n      this._mouseDown = true;\r\n\r\n      switch (this._state) {\r\n        case SceneEventState.SELECTED:\r\n          if (this._rotateMouseOver) {\r\n            if (this._selectedObject) {\r\n              this._switchState(SceneEventState.ROTATING);\r\n              const itemIntersection: any = this._itemIntersection(this._mousePosition, this._selectedObject);\r\n              if (itemIntersection) {\r\n                this._rotationStartPoint = itemIntersection.point;\r\n              }\r\n            }\r\n          } else if (this._intersectedObject) {\r\n            if (this._intersectedMesh && this._intersectedMesh.name && this._intersectedMesh.name.toLowerCase().startsWith('c_')) {\r\n              this._switchState(SceneEventState.DRAGGINGCONNECTOR);\r\n            } else {\r\n              if (!event.ctrlKey) {\r\n                if (this._groupingMode) {\r\n                  this._addToItemGroup(this._intersectedObject, this._selectedObject);\r\n                } else {\r\n                  this._itemGroupService.resetObjectsToGroup();\r\n                  this.setSelectedObject(this._intersectedObject, this._intersectedMesh);\r\n                }\r\n              } else {\r\n                this._addToItemGroup(this._intersectedObject, this._selectedObject);\r\n              }\r\n              if (!this._intersectedObject.fixed && !this.rotateNoDrag) {\r\n                this._switchState(SceneEventState.DRAGGING);\r\n              }\r\n            }\r\n          }\r\n          break;\r\n        case SceneEventState.UNSELECTED:\r\n          const floor = this._floorIntersection(this._mousePosition);\r\n          if (floor) {\r\n            if (floor.object.parent && floor.object.parent instanceof Item && floor.object.parent.configurable) {\r\n              this._setIntersectedObject(floor.object);\r\n            }\r\n          }\r\n          if (this._intersectedObject) {\r\n            this._itemGroupService.resetObjectsToGroup();\r\n            this.setSelectedObject(this._intersectedObject, this._intersectedMesh);\r\n            if (!this._intersectedObject.fixed) {\r\n              if (this.rotateNoDrag) {\r\n                const itemIntersection: any = this._itemIntersection(this._mousePosition, this._selectedObject);\r\n                if (itemIntersection) {\r\n                  this._rotationStartPoint = itemIntersection.point;\r\n                }\r\n                this._switchState(SceneEventState.ROTATING);\r\n              } else {\r\n                this._switchState(SceneEventState.DRAGGING);\r\n              }\r\n            }\r\n          }\r\n          break;\r\n      }\r\n    }\r\n  }\r\n\r\n  private _overrideDefaultCursorStyle(style: string): void {\r\n    this._defaultCursorStyle = style;\r\n    this._setCursorStyle(this._defaultCursorStyle);\r\n  }\r\n\r\n  private _setGroupingMode(enableGrouping: boolean): void {\r\n    this._groupingMode = enableGrouping;\r\n    this._addToItemGroup(this._intersectedObject, this._prevSelectedObject);\r\n  }\r\n\r\n  private _getDraggedData(): any {\r\n    return this._dragAndDropService.draggedData;\r\n  }\r\n\r\n  private _clickPressed(vec2?: Vector2): void {\r\n    const vec = vec2 || this._mousePosition;\r\n    if (this._selectedObject) {\r\n      const intersection = this._itemIntersection(vec, this._selectedObject);\r\n      if (intersection) {\r\n        this._dragAndDropService.draggedItem = this._selectedObject;\r\n        this._dragAndDropService.setDragOffset(intersection.point);\r\n      }\r\n    }\r\n  }\r\n\r\n  private _clickConnectorPressed(vec2?: Vector2): void {\r\n    const vec = vec2 || this._mousePosition;\r\n    if (this._intersectedMesh) {\r\n      const intersections = this._getIntersections(vec, [this._intersectedMesh, this._floorService.groundPlane]);\r\n      if (intersections && intersections.length > 1 && intersections.find(i => i.object.name === this._intersectedMesh.name)) {\r\n        const groundPlane = intersections.find(i => i.object.name === 'ground-plane');\r\n        if (groundPlane) {\r\n          this._dragAndDropService.setDragOffset(groundPlane.point, false);\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  private _clickDragged(): void {\r\n    if (this._selectedObject && !this._selectedObject.locked) {\r\n      const intersection = this._itemIntersection(this._mousePosition, this._selectedObject);\r\n      if (intersection) {\r\n        if (this._isRotating()) {\r\n          this._rotationStartPoint =\r\n            this._rotationService.rotate(this._selectedObject, this._rotationStartPoint, intersection.point, !this.rotateNoDrag);\r\n        } else {\r\n          this._dragAndDropService.clickDragged(intersection);\r\n          this._messageBusService.emit(MessageType.ClickDragged);\r\n          this._debouncedSaveState.next('item dragged');\r\n        }\r\n        this._hudService.update();\r\n      }\r\n    }\r\n  }\r\n\r\n  private _dragConnector(): void {\r\n    if (this._selectedObject && !this._selectedObject.locked) {\r\n      // const intersections = this._getIntersections(this._mousePosition, [this._floorService.groundPlane], {});\r\n      // if (intersections && intersections.length === 1) {\r\n      //   this._dragAndDropService.dragConnector(this._intersectedMesh, intersections[0].point);\r\n      // }\r\n      this._dragAndDropService.dragConnector(this._intersectedMesh, this._mouseToVec3(this._mousePosition));\r\n    }\r\n  }\r\n\r\n  private _checkWallsAndFloors(event): void {\r\n    if (this._state === SceneEventState.UNSELECTED && this._mouseoverObject == null) {\r\n      const wall = this._wallIntersection(this._mousePosition);\r\n      if (wall) {\r\n        const edge = wall.object.userData.edge;\r\n        this._roomService.selectWall(event, edge.wall, edge);\r\n        return;\r\n      }\r\n\r\n      const floor = this._floorIntersection(this._mousePosition);\r\n      if (floor) {\r\n        const room = floor.object.userData.room;\r\n        this._roomService.selectFloor(event, room);\r\n        return;\r\n      }\r\n    }\r\n  }\r\n\r\n  private _wallIntersection(vec2: Vector2): Intersection {\r\n    const intersections = this._wallIntersections(vec2);\r\n    if (intersections && intersections.length > 0) {\r\n      return intersections[0];\r\n    } else {\r\n      return null;\r\n    }\r\n  }\r\n\r\n  private _wallIntersections(vec2: Vector2): Intersection[] {\r\n    const wallEdgePlanes = this._roomService.wallEdgePlanes();\r\n    return this._getIntersections(\r\n      vec2, wallEdgePlanes, {filterByNormals: true});\r\n  }\r\n\r\n  private _edgeIntersections(vec2: Vector2): Intersection[] {\r\n    const edges = this._roomService.floorPlanes();\r\n    return this._getIntersections(\r\n      vec2, edges, {filterByNormals: true});\r\n  }\r\n\r\n  private _groundIntersections(vec2: Vector2): Intersection[] {\r\n    return this._getIntersections(vec2, [this._floorService.groundPlane], {filterByNormals: true});\r\n  }\r\n\r\n  private _wallEdgeIntersected(intersectedWalls: Intersection[], intersectedEdges: Intersection[]): boolean {\r\n    const walls = intersectedEdges.map((i: Intersection) => i.object.userData.wall);\r\n    const filteredWalls = intersectedWalls.filter((intersectedWall: Intersection) => {\r\n      const wall = intersectedWall.object.userData.edge && intersectedWall.object.userData.edge.wall;\r\n      return walls.indexOf(wall) !== -1;\r\n    });\r\n    return filteredWalls.length > 0;\r\n  }\r\n\r\n  private _floorIntersection(vec2: Vector2): Intersection {\r\n    const floorPlanes = this._roomService.floorPlanes();\r\n    const floorIntersects = this._getIntersections(\r\n      vec2, floorPlanes, {filterByNormals: false, includeFloors: true});\r\n    if (floorIntersects.length > 0) {\r\n      return floorIntersects[0];\r\n    } else {\r\n      return null;\r\n    }\r\n  }\r\n\r\n  private _pointOnFloor(vec2: Vector2): Vector3 {\r\n    if (this._intersectedObject &&\r\n      !(isOnFloorType(this._intersectedObject.userData.itemType) || isInWallType(this._intersectedObject.userData.itemType))) {\r\n      return null;\r\n    }\r\n    const intersectedFloor = this._floorIntersection(vec2);\r\n    if (!intersectedFloor) {\r\n      return null;\r\n    }\r\n\r\n    const intersectedWalls = this._wallIntersections(vec2);\r\n    if (!intersectedWalls.length) {\r\n      return intersectedFloor.point;\r\n    }\r\n    const intersectedEdges = this._edgeIntersections(vec2);\r\n    if (this._wallEdgeIntersected(intersectedWalls, intersectedEdges)) {\r\n      return null;\r\n    }\r\n    return intersectedFloor.point;\r\n  }\r\n\r\n  private _isMouseEventAllowed(event?: Event): boolean {\r\n    return event ? (event.target && (event.target as Element).nodeName === 'CANVAS') : true;\r\n  }\r\n\r\n  private _mouseMoveEvent(event?: MouseEvent): void {\r\n    if (this._state === SceneEventState.DND) {\r\n      return this._dragOverEvent.bind(this)(event);\r\n    }\r\n    if (this._isMouseEventAllowed(event)) {\r\n      const mousePos: Vector2 = event ? RelativePositionUtils.GetClientMousePosition(event) : this._mousePosition;\r\n      let canvas: HTMLElement;\r\n      if (event) {\r\n        event.preventDefault();\r\n        canvas = event.currentTarget as HTMLElement;\r\n      }\r\n      this._mousePosition.set(mousePos.x - (canvas ? canvas.offsetLeft : 0), mousePos.y - (canvas ? canvas.offsetTop : 0));\r\n\r\n      if (this._oldMousePosition.x !== mousePos.x && this._oldMousePosition.y !== mousePos.y) {\r\n        this._mouseMoved = true;\r\n      }\r\n\r\n      if (!this._mouseDown) {\r\n        this._updateIntersections();\r\n      } else {\r\n        this._dragAndDropService.intersectedWall = this._wallIntersection(this._mousePosition);\r\n        this._dragAndDropService.intersectedFloor = this._floorIntersection(this._mousePosition);\r\n      }\r\n\r\n      if (this.rotateNoDrag) {\r\n        this._controls.enabled = true;\r\n        return;\r\n      }\r\n      switch (this._state) {\r\n        case SceneEventState.UNSELECTED:\r\n          this._updateMouseover();\r\n          break;\r\n        case SceneEventState.SELECTED:\r\n          if (this._mouseDown && this._mouseMoved) {\r\n            this._hudService.cameraRotation();\r\n          }\r\n          this._updateMouseover();\r\n          break;\r\n        case SceneEventState.EXPLORE:\r\n          this._hudService.stopExplore();\r\n          if (this._mouseDown) {\r\n            this._setCursorStyle('move');\r\n          } else {\r\n            this._explorePressed = false;\r\n            if (!this._mouseoverObject) {\r\n              this._updateExplorePoint();\r\n            }\r\n          }\r\n          break;\r\n        case SceneEventState.DRAGGING:\r\n        case SceneEventState.ROTATING:\r\n          this._clickDragged();\r\n          this._markSceneToUpdate();\r\n          this._eventService.objectMovingOrRotating.next();\r\n          break;\r\n        case SceneEventState.DRAGGINGCONNECTOR:\r\n          this._dragConnector();\r\n          break;\r\n      }\r\n    }\r\n  }\r\n\r\n  private _updateExplorePoint(): void {\r\n    const point = this._pointOnFloor(this._mousePosition);\r\n    if (point) {\r\n      this._setCursorStyle('pointer');\r\n      const distance = this._camera.position.distanceTo(point);\r\n      this._hudService.exploreFloorHover(this._mousePosition, point, distance);\r\n    } else {\r\n      this._setCursorStyle('crosshair');\r\n      this._hudService.stopExplore();\r\n    }\r\n  }\r\n\r\n  private _updateExploreIndicator(): void {\r\n    this._hudService.stopExplore();\r\n    const point = this._pointOnFloor(this._mousePosition);\r\n    if (point) {\r\n      this._setCursorStyle('pointer');\r\n    } else {\r\n      this._setCursorStyle('crosshair');\r\n    }\r\n  }\r\n\r\n  private _acceptDrop(event): void {\r\n    if (event.dataTransfer && event.dataTransfer.dropEffect) {\r\n      event.dataTransfer.dropEffect = 'copy';\r\n    }\r\n  }\r\n\r\n  private _releaseState(draggedData): void {\r\n    if (draggedData && draggedData.isCopy) {\r\n      this._switchState(SceneEventState.SELECTED);\r\n    } else {\r\n      this._switchState(SceneEventState.UNSELECTED);\r\n    }\r\n  }\r\n\r\n  private _addToItemGroup(object: Item, prevSelectedObject?: any) {\r\n    const isIntersectWithGroupMember = object instanceof ItemGroup || object.parent instanceof ItemGroup;\r\n    if (!isIntersectWithGroupMember && !object.configuring && this._canGroupItems(object, prevSelectedObject)) {\r\n      if (prevSelectedObject) {\r\n        this._itemGroupService.addIfNotExist(prevSelectedObject);\r\n      }\r\n      this._itemGroupService.addOrRemoveIfExist(object);\r\n    }\r\n  }\r\n\r\n  private _canGroupFloorItem(item: Item): boolean {\r\n    return !(item instanceof WallItem) || (item instanceof CustomWallFloorItem && !(item as CustomWallFloorItem).currentWall);\r\n  }\r\n\r\n  private _canGroupWallItem(item: Item): boolean {\r\n    return ((item instanceof WallItem && !(item instanceof InWallItem)) ||\r\n      (item instanceof CustomWallFloorItem && (item as CustomWallFloorItem).currentWall !== undefined));\r\n  }\r\n\r\n  private _canGroupItems(newItem: Item, previousItem: Item): boolean {\r\n    return this._canGroupWallItem(newItem) && this._canGroupWallItem(previousItem) &&\r\n      (newItem as WallItem).currentWall === (previousItem as WallItem).currentWall ||\r\n      this._canGroupFloorItem(newItem) && this._canGroupFloorItem(previousItem);\r\n  }\r\n\r\n  private _switchState(newState: SceneEventState): void {\r\n    if (newState !== this._state) {\r\n      this._onExit(this._state);\r\n      this._onEntry(newState);\r\n    }\r\n    this._state = newState;\r\n    this._hudService.setRotating(this._isRotating());\r\n  }\r\n\r\n  private _onEntry(onState: SceneEventState): void {\r\n    switch (onState) {\r\n      case SceneEventState.UNSELECTED:\r\n        this.setSelectedObject(null);\r\n        this._controls.enabled = true;\r\n        break;\r\n      case SceneEventState.SELECTED:\r\n        this._controls.enabled = true;\r\n        break;\r\n      case SceneEventState.ROTATING:\r\n        this._controls.enabled = this._appService.sku;\r\n        break;\r\n      case SceneEventState.DRAGGING:\r\n        this._setCursorStyle('move');\r\n        this._clickPressed();\r\n        this._controls.enabled = false;\r\n        break;\r\n      case SceneEventState.DRAGGINGCONNECTOR:\r\n        this._clickConnectorPressed();\r\n        this._controls.enabled = false;\r\n        break;\r\n      case SceneEventState.EXPLORE:\r\n        this._overrideDefaultCursorStyle('pointer');\r\n        this.setSelectedObject(null);\r\n        this._cameraMoveSub = this._cameraService.cameraMovementChanged.subscribe(() => this._updateExploreIndicator());\r\n        break;\r\n    }\r\n  }\r\n\r\n  private _onExit(onState: SceneEventState): void {\r\n    switch (onState) {\r\n      case SceneEventState.UNSELECTED:\r\n      case SceneEventState.SELECTED:\r\n        break;\r\n      case SceneEventState.DRAGGING:\r\n        this._setCursorStyle(this._defaultCursorStyle);\r\n        break;\r\n      case SceneEventState.ROTATING:\r\n        break;\r\n      case SceneEventState.EXPLORE:\r\n        this._overrideDefaultCursorStyle('auto');\r\n        this._hudService.stopExplore();\r\n        if (this._cameraMoveSub) {\r\n          this._cameraMoveSub.unsubscribe();\r\n        }\r\n        break;\r\n    }\r\n  }\r\n\r\n  private _setIntersectedObject(mesh: any): void {\r\n    this._intersectedMesh = mesh;\r\n    if (typeof mesh['getRoot'] === 'function') {\r\n      this._intersectedObject = mesh.getRoot();\r\n    } else if (mesh.parent) {\r\n      this._setIntersectedObject(mesh.parent as Item);\r\n    }\r\n  }\r\n\r\n  // Reverted changes from IONE-31399\r\n  private _mouseToVec3(vec2: Vector2): Vector3 {\r\n    const rendererElement = this._element;\r\n    const mPosition = new Vector2(\r\n      (vec2.x / rendererElement.clientWidth) * 2 - 1,\r\n      -(vec2.y / rendererElement.clientHeight) * 2 + 1\r\n    );\r\n    const vector = new Vector3(mPosition.x, mPosition.y, 0.5);\r\n    vector.unproject(this._camera);\r\n    return vector;\r\n\r\n    // const rendererElement = this._element;\r\n    // const mPosition = new Vector2(\r\n    //   (vec2.x / rendererElement.clientWidth) * 2 - 1,\r\n    //   -(vec2.y / rendererElement.clientHeight) * 2 + 1\r\n    // );\r\n    // const vector = new Vector3(mPosition.x, mPosition.y, 0.5);\r\n    // vector.unproject(this._camera);\r\n    // return vector;\r\n  }\r\n\r\n  private _setSelectObject(object: Item | ItemGroup, mesh?: Mesh): void {\r\n    object.setSelected(mesh, this._mouseToVec3(this._mousePosition));\r\n    this._selectedObject = object;\r\n    this._messageBusService.emit(MessageType.ItemSelected, object);\r\n  }\r\n\r\n  private _updateMouseover(): void {\r\n    if (this._intersectedObject != null) {\r\n      if (this._mouseoverObject != null) {\r\n        if (this._mouseoverObject !== this._intersectedObject) {\r\n          this._setObjectMouseOff(this._mouseoverObject);\r\n          this._mouseoverObject = this._intersectedObject;\r\n          this._setObjectMouseOver(this._mouseoverObject, this._intersectedMesh);\r\n          this._markSceneToUpdate();\r\n        } else {\r\n          // do nothing, mouseover already set\r\n        }\r\n      } else {\r\n        this._mouseoverObject = this._intersectedObject;\r\n        this._setObjectMouseOver(this._mouseoverObject, this._intersectedMesh);\r\n        this._setCursorStyle('pointer');\r\n        this._markSceneToUpdate();\r\n      }\r\n    } else if (this._mouseoverObject != null) {\r\n      this._setObjectMouseOff(this._mouseoverObject);\r\n      this._setCursorStyle(this._defaultCursorStyle);\r\n      this._mouseoverObject = null;\r\n      this._markSceneToUpdate();\r\n    }\r\n  }\r\n\r\n  private _setObjectMouseOver(object: ItemGroup | Item, mesh: Mesh): void {\r\n    if (object.parent && object.parent instanceof ItemGroup) {\r\n      object.parent.mouseOver();\r\n    } else {\r\n      object.mouseOver(mesh);\r\n    }\r\n  }\r\n\r\n  private _setObjectMouseOff(object: ItemGroup | Item): void {\r\n    if (object.parent && object.parent instanceof ItemGroup) {\r\n      object.parent.mouseOff();\r\n    } else {\r\n      object.mouseOff();\r\n    }\r\n  }\r\n\r\n  private _markSceneToUpdate(): void {\r\n    this._sceneService.needsRender = true;\r\n  }\r\n\r\n  private _setCursorStyle(style: string): void {\r\n    this._element.style.cursor = style;\r\n  }\r\n}\r\n"]}