@colijnit/homedecorator 255.1.1

package/esm2015/app/plugins/core3d/collision-manager/snapping-collision.service.js

@@ -0,0 +1,234 @@
+import { Injectable } from '@angular/core';
+import { Box3, BoxGeometry, Mesh, MeshBasicMaterial, Vector2, Vector3 } from 'three';
+import { Subject } from 'rxjs';
+import { debounceTime } from 'rxjs/operators';
+import { Direction } from '../enum/direction.enum';
+import { Utils } from '../core/utils';
+import { ItemGroup } from '../items/item-group';
+import * as i0 from "@angular/core";
+import * as i1 from "../../room-planner/components/floorplanner/service/room.service";
+import * as i2 from "../service/hud.service";
+import * as i3 from "../service/item.service";
+import * as i4 from "../service/scene.service";
+import * as i5 from "../../../core/service/homedecorator-settings.service";
+export class SnappingCollisionService {
+    constructor(_roomService, _hudService, _itemService, _sceneService, _settingsService) {
+        this._roomService = _roomService;
+        this._hudService = _hudService;
+        this._itemService = _itemService;
+        this._sceneService = _sceneService;
+        this._settingsService = _settingsService;
+        this._wallSnappingDistance = 0.7;
+        this._objectSnappingDistance = 0.15;
+        this._snapPreviewDisappearTimeInMs = 800;
+        this._itemSnappedToPosition = false;
+        this._lastCheckedPosition = new Vector3();
+        this._tempPositionVector = new Vector3();
+        this._hideBoundingBoxMesh = new Subject();
+        this._hideBoundingBoxMesh.pipe(debounceTime(this._snapPreviewDisappearTimeInMs)).subscribe(() => {
+            this._previewPlacementMesh.visible = false;
+            this._sceneService.needsRender = true;
+        });
+    }
+    ngOnDestroy() {
+        this._hideBoundingBoxMesh.unsubscribe();
+    }
+    handleSnapping(item, moveToPosition) {
+        if (item instanceof ItemGroup) {
+            return;
+        }
+        if (moveToPosition !== this._lastCheckedPosition) {
+            this._itemSnappedToPosition = false;
+            this._lastCheckedPosition = moveToPosition.clone();
+            this._currentItem = item;
+            this._createSnappingPreviewMesh(item);
+            // if (item.canSnapToWall) {
+            this._handleWallSnapping(item, moveToPosition);
+            // }
+            // if (item.canSnapToObject) {
+            this._handleObjectSnapping(item, moveToPosition);
+            // }
+            this._checkIfSnapped(item, moveToPosition);
+        }
+    }
+    handleEndOfDragging() {
+        if (this._previewPlacementMesh && this._previewPlacementMesh.visible) {
+            this._previewPlacementMesh.visible = false;
+            this._currentItem.position.copy(this._previewPlacementMesh.position.sub(new Vector3(0, this._currentItem.halfSize.y, 0)));
+            this._hudService.updateSelectedItemHud();
+            this._sceneService.needsRender = true;
+        }
+    }
+    itemHasSnapped() {
+        const hasSnapped = this._itemSnappedToPosition;
+        this._itemSnappedToPosition = false;
+        return hasSnapped;
+    }
+    _handleWallSnapping(item, moveToPosition) {
+        const closestEdge = this._closestWallPositionFromItem(item);
+        if (closestEdge.distance < this._wallSnappingDistance) {
+            moveToPosition.y = item.getFloorY();
+            this._tempPositionVector.set(closestEdge.position.x, moveToPosition.y, closestEdge.position.y);
+            this._hideBoundingBoxMesh.next();
+            this._itemSnappedToPosition = true;
+        }
+    }
+    _handleObjectSnapping(item, moveToPosition) {
+        const intersectedObjects = this._getIntersectedFurnitureSortedByDistance(item);
+        if (intersectedObjects.length > 0) {
+            // @ts-ignore
+            const snapVector = this._closestSnapPositionToItem(intersectedObjects[0], item);
+            if (snapVector) {
+                this._tempPositionVector.set(snapVector.x, moveToPosition.y, snapVector.y);
+                this._hideBoundingBoxMesh.next();
+                this._itemSnappedToPosition = true;
+            }
+        }
+    }
+    _checkIfSnapped(item, moveToPosition) {
+        if (this._itemSnappedToPosition) {
+            item.position.copy(moveToPosition);
+            this._previewPlacementMesh.position.copy(this._tempPositionVector.add(new Vector3(0, item.halfSize.y, 0)));
+            this._previewPlacementMesh.visible = true;
+        }
+        else {
+            this._previewPlacementMesh.visible = false;
+        }
+    }
+    _closestWallPositionFromItem(item) {
+        let closestEdge;
+        const positionsToCheck = [
+            { position: new Vector2(item.position.x + this._lastSnappedItemHalfSize.x, item.position.z), direction: Direction.PositiveX },
+            { position: new Vector2(item.position.x - this._lastSnappedItemHalfSize.x, item.position.z), direction: Direction.NegativeX },
+            { position: new Vector2(item.position.x, item.position.z + this._lastSnappedItemHalfSize.z), direction: Direction.PositiveZ },
+            { position: new Vector2(item.position.x, item.position.z - this._lastSnappedItemHalfSize.z), direction: Direction.NegativeZ }
+        ];
+        for (const check of positionsToCheck) {
+            const closestEdgeFromPosition = this._roomService.getClosestWallEdge(check.position.x, check.position.y);
+            const distanceToEdge = closestEdgeFromPosition.distanceTo(check.position.x, check.position.y);
+            if (!closestEdge || distanceToEdge < closestEdge.distance) {
+                switch (check.direction) {
+                    case Direction.PositiveX:
+                        check.position.x -= this._lastSnappedItemHalfSize.x - distanceToEdge;
+                        break;
+                    case Direction.NegativeX:
+                        check.position.x += this._lastSnappedItemHalfSize.x - distanceToEdge;
+                        break;
+                    case Direction.PositiveZ:
+                        check.position.y -= this._lastSnappedItemHalfSize.z - distanceToEdge;
+                        break;
+                    case Direction.NegativeZ:
+                        check.position.y += this._lastSnappedItemHalfSize.z - distanceToEdge;
+                        break;
+                }
+                closestEdge = { distance: distanceToEdge, position: check.position };
+            }
+        }
+        return closestEdge;
+    }
+    _closestSnapPositionToItem(itemToSnapTo, itemToSnap) {
+        let closestSnapPoint;
+        this._updateItemToSnapToHalfSize(itemToSnapTo);
+        const positionsToCheck = this._generateSnapPositionsToCheck(itemToSnapTo);
+        for (const position of positionsToCheck) {
+            const distanceToSnapPoint = Utils.distance(position.x, position.y, itemToSnap.position.x, itemToSnap.position.z);
+            //// Check for collision when placed in snap position
+            // const intersectedFurniture: Furniture[] = this._getIntersectedFurniture(
+            //   this._previewPlacementMesh, new Vector3(position.x, itemToSnap.position.y, position.y), 0)
+            //   .filter((o) => o !== itemToSnapTo && o !== itemToSnap);
+            // if (intersectedFurniture.length === 0) {
+            if (!closestSnapPoint || distanceToSnapPoint < closestSnapPoint.distance) {
+                closestSnapPoint = { distance: distanceToSnapPoint, position: position };
+            }
+            // }
+        }
+        return closestSnapPoint.position;
+    }
+    _createSnappingPreviewMesh(item) {
+        if (!this._lastSnappedItemHalfSize || !this._itemHalfSizeEqual(this._lastSnappedItemHalfSize, item)) {
+            const box = new Box3().setFromObject(item);
+            this._lastSnappedItemHalfSize = box.max.clone().sub(box.min).divideScalar(2);
+            const dimensions = new Vector3().subVectors(box.max, box.min);
+            const boxGeometry = new BoxGeometry(dimensions.x, dimensions.y, dimensions.z);
+            if (this._previewPlacementMesh) {
+                this._sceneService.removeObject(this._previewPlacementMesh, false);
+            }
+            this._previewPlacementMesh = new Mesh(boxGeometry, new MeshBasicMaterial({ color: 'green', opacity: 0.2, transparent: true, depthTest: false }));
+            this._previewPlacementMesh.name = 'snapping-preview-mesh';
+            this._sceneService.addObject(this._previewPlacementMesh);
+        }
+    }
+    _getIntersectedFurniture(item, position, expandScalar) {
+        const originalPosition = item.position.clone();
+        item.position.copy(position);
+        const itemBoundingBox = new Box3().setFromObject(item).expandByScalar(expandScalar);
+        const intersectedItems = this._itemService.getFurniture().filter((furniture) => {
+            if (furniture !== item) {
+                const furnitureBoundingBox = new Box3().setFromObject(furniture);
+                return furnitureBoundingBox.intersectsBox(itemBoundingBox);
+            }
+        });
+        item.position.copy(originalPosition);
+        return intersectedItems;
+    }
+    _getIntersectedFurnitureSortedByDistance(item) {
+        return this._getIntersectedFurniture(item, item.position, this._objectSnappingDistance * 2)
+            .sort((a, b) => {
+            if (Utils.distance(a.position.x, a.position.z, item.position.x, item.position.z) >
+                Utils.distance(b.position.x, b.position.z, item.position.x, item.position.z)) {
+                return 1;
+            }
+            else if (Utils.distance(a.position.x, a.position.z, item.position.x, item.position.z) <
+                Utils.distance(b.position.x, b.position.z, item.position.x, item.position.z)) {
+                return -1;
+            }
+            else {
+                return 0;
+            }
+        });
+    }
+    _updateItemToSnapToHalfSize(itemToSnapTo) {
+        // @ts-ignore
+        if (!this._lastSnappedToItemHalfSize || !this._itemHalfSizeEqual(this._lastSnappedToItemHalfSize, itemToSnapTo)) {
+            const box = new Box3().setFromObject(itemToSnapTo);
+            this._lastSnappedToItemHalfSize = box.max.clone().sub(box.min).divideScalar(2);
+        }
+    }
+    _itemHalfSizeEqual(vector, item) {
+        const box = new Box3().setFromObject(item);
+        const itemHalfSize = box.max.clone().sub(box.min).divideScalar(2);
+        return this._vector3ValuesEqual(vector, itemHalfSize);
+    }
+    _vector3ValuesEqual(v1, v2) {
+        return v1.x.toFixed(8) === v2.x.toFixed(8) && v1.y.toFixed(8) === v2.y.toFixed(8) && v1.z.toFixed(8) === v2.z.toFixed(8);
+    }
+    _generateSnapPositionsToCheck(itemToSnapTo) {
+        return [
+            // Positive X
+            new Vector2(itemToSnapTo.position.x + this._lastSnappedToItemHalfSize.x + this._lastSnappedItemHalfSize.x, itemToSnapTo.position.z + (this._lastSnappedToItemHalfSize.z - this._lastSnappedItemHalfSize.z)),
+            new Vector2(itemToSnapTo.position.x + this._lastSnappedToItemHalfSize.x + this._lastSnappedItemHalfSize.x, itemToSnapTo.position.z - (this._lastSnappedToItemHalfSize.z - this._lastSnappedItemHalfSize.z)),
+            new Vector2(itemToSnapTo.position.x + this._lastSnappedToItemHalfSize.x + this._lastSnappedItemHalfSize.x, itemToSnapTo.position.z),
+            // Negative X
+            new Vector2(itemToSnapTo.position.x - this._lastSnappedToItemHalfSize.x - this._lastSnappedItemHalfSize.x, itemToSnapTo.position.z + (this._lastSnappedToItemHalfSize.z - this._lastSnappedItemHalfSize.z)),
+            new Vector2(itemToSnapTo.position.x - this._lastSnappedToItemHalfSize.x - this._lastSnappedItemHalfSize.x, itemToSnapTo.position.z - (this._lastSnappedToItemHalfSize.z - this._lastSnappedItemHalfSize.z)),
+            new Vector2(itemToSnapTo.position.x - this._lastSnappedToItemHalfSize.x - this._lastSnappedItemHalfSize.x, itemToSnapTo.position.z),
+            // Positive Z
+            new Vector2(itemToSnapTo.position.x + (this._lastSnappedToItemHalfSize.x - this._lastSnappedItemHalfSize.x), itemToSnapTo.position.z + this._lastSnappedToItemHalfSize.z + this._lastSnappedItemHalfSize.z),
+            new Vector2(itemToSnapTo.position.x - (this._lastSnappedToItemHalfSize.x - this._lastSnappedItemHalfSize.x), itemToSnapTo.position.z + this._lastSnappedToItemHalfSize.z + this._lastSnappedItemHalfSize.z),
+            new Vector2(itemToSnapTo.position.x, itemToSnapTo.position.z + this._lastSnappedToItemHalfSize.z + this._lastSnappedItemHalfSize.z),
+            // Negative Z
+            new Vector2(itemToSnapTo.position.x + (this._lastSnappedToItemHalfSize.x - this._lastSnappedItemHalfSize.x), itemToSnapTo.position.z - this._lastSnappedToItemHalfSize.z - this._lastSnappedItemHalfSize.z),
+            new Vector2(itemToSnapTo.position.x - (this._lastSnappedToItemHalfSize.x - this._lastSnappedItemHalfSize.x), itemToSnapTo.position.z - this._lastSnappedToItemHalfSize.z - this._lastSnappedItemHalfSize.z),
+            new Vector2(itemToSnapTo.position.x, itemToSnapTo.position.z - this._lastSnappedToItemHalfSize.z - this._lastSnappedItemHalfSize.z),
+        ];
+    }
+}
+SnappingCollisionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SnappingCollisionService, deps: [{ token: i1.RoomService }, { token: i2.HudService }, { token: i3.ItemService }, { token: i4.SceneService }, { token: i5.HomedecoratorSettingsService }], target: i0.ɵɵFactoryTarget.Injectable });
+SnappingCollisionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SnappingCollisionService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SnappingCollisionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.RoomService }, { type: i2.HudService }, { type: i3.ItemService }, { type: i4.SceneService }, { type: i5.HomedecoratorSettingsService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"snapping-collision.service.js","sourceRoot":"","sources":["../../../../../../../src/client/app/plugins/core3d/collision-manager/snapping-collision.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\r\nimport {Box3, BoxGeometry, Mesh, MeshBasicMaterial, Object3D, Vector2, Vector3} from 'three';\r\nimport {Subject} from 'rxjs';\r\nimport {debounceTime} from 'rxjs/operators';\r\nimport {HalfEdge} from '../items/wall-objects';\r\nimport {Item} from '../items/item';\r\nimport {RoomService} from '../../room-planner/components/floorplanner/service/room.service';\r\nimport {HudService} from '../service/hud.service';\r\nimport {ItemService} from '../service/item.service';\r\nimport {SceneService} from '../service/scene.service';\r\nimport {HomedecoratorSettingsService} from '../../../core/service/homedecorator-settings.service';\r\nimport {Direction} from '../enum/direction.enum';\r\nimport {Utils} from '../core/utils';\r\nimport {Furniture} from '../items/furniture';\r\nimport {ItemGroup} from '../items/item-group';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class SnappingCollisionService implements OnDestroy {\r\n\r\n  private readonly _wallSnappingDistance: number = 0.7;\r\n  private readonly _objectSnappingDistance: number = 0.15;\r\n  private readonly _snapPreviewDisappearTimeInMs: number = 800;\r\n\r\n  private _previewPlacementMesh: Mesh;\r\n  private _lastSnappedItemHalfSize: Vector3;\r\n  private _lastSnappedToItemHalfSize: Vector3;\r\n  private _itemSnappedToPosition: boolean = false;\r\n  private _lastCheckedPosition: Vector3 = new Vector3();\r\n  private _tempPositionVector: Vector3 = new Vector3();\r\n  private _currentItem: Item;\r\n\r\n  private _hideBoundingBoxMesh: Subject<any> = new Subject();\r\n\r\n  constructor(\r\n    private _roomService: RoomService,\r\n    private _hudService: HudService,\r\n    private _itemService: ItemService,\r\n    private _sceneService: SceneService,\r\n    private _settingsService: HomedecoratorSettingsService\r\n  ) {\r\n    this._hideBoundingBoxMesh.pipe(debounceTime(this._snapPreviewDisappearTimeInMs)).subscribe(() => {\r\n      this._previewPlacementMesh.visible = false;\r\n      this._sceneService.needsRender = true;\r\n    });\r\n  }\r\n\r\n  public ngOnDestroy(): void {\r\n    this._hideBoundingBoxMesh.unsubscribe();\r\n  }\r\n\r\n  public handleSnapping(item: Item | ItemGroup, moveToPosition: Vector3): void {\r\n    if (item instanceof ItemGroup) {\r\n      return;\r\n    }\r\n    if (moveToPosition !== this._lastCheckedPosition) {\r\n      this._itemSnappedToPosition = false;\r\n      this._lastCheckedPosition = moveToPosition.clone();\r\n      this._currentItem = item;\r\n      this._createSnappingPreviewMesh(item);\r\n\r\n      // if (item.canSnapToWall) {\r\n        this._handleWallSnapping(item, moveToPosition);\r\n      // }\r\n\r\n      // if (item.canSnapToObject) {\r\n        this._handleObjectSnapping(item, moveToPosition);\r\n      // }\r\n\r\n      this._checkIfSnapped(item, moveToPosition);\r\n    }\r\n  }\r\n\r\n  public handleEndOfDragging(): void {\r\n    if (this._previewPlacementMesh && this._previewPlacementMesh.visible) {\r\n      this._previewPlacementMesh.visible = false;\r\n      this._currentItem.position.copy(this._previewPlacementMesh.position.sub(new Vector3(0, this._currentItem.halfSize.y, 0)));\r\n      this._hudService.updateSelectedItemHud();\r\n      this._sceneService.needsRender = true;\r\n    }\r\n  }\r\n\r\n  public itemHasSnapped(): boolean {\r\n    const hasSnapped = this._itemSnappedToPosition;\r\n    this._itemSnappedToPosition = false;\r\n    return hasSnapped;\r\n  }\r\n\r\n  private _handleWallSnapping(item: Item, moveToPosition: Vector3): void {\r\n    const closestEdge: {distance: number, position: Vector2} = this._closestWallPositionFromItem(item);\r\n    if (closestEdge.distance < this._wallSnappingDistance) {\r\n      moveToPosition.y = item.getFloorY();\r\n      this._tempPositionVector.set(closestEdge.position.x, moveToPosition.y, closestEdge.position.y);\r\n      this._hideBoundingBoxMesh.next();\r\n      this._itemSnappedToPosition = true;\r\n    }\r\n  }\r\n\r\n  private _handleObjectSnapping(item: Item, moveToPosition: Vector3): void {\r\n    const intersectedObjects: Furniture[] = this._getIntersectedFurnitureSortedByDistance(item);\r\n\r\n    if (intersectedObjects.length > 0) {\r\n      // @ts-ignore\r\n      const snapVector: Vector2 = this._closestSnapPositionToItem(intersectedObjects[0], item);\r\n      if (snapVector) {\r\n        this._tempPositionVector.set(snapVector.x, moveToPosition.y, snapVector.y);\r\n        this._hideBoundingBoxMesh.next();\r\n        this._itemSnappedToPosition = true;\r\n      }\r\n    }\r\n  }\r\n\r\n  private _checkIfSnapped(item: Item, moveToPosition: Vector3): void {\r\n    if (this._itemSnappedToPosition) {\r\n      item.position.copy(moveToPosition);\r\n      this._previewPlacementMesh.position.copy(this._tempPositionVector.add(new Vector3(0, item.halfSize.y, 0)));\r\n      this._previewPlacementMesh.visible = true;\r\n    } else {\r\n      this._previewPlacementMesh.visible = false;\r\n    }\r\n  }\r\n\r\n  private _closestWallPositionFromItem(item: Item): {distance: number, position: Vector2} {\r\n    let closestEdge: {distance: number, position: Vector2};\r\n\r\n    const positionsToCheck: {position: Vector2, direction: Direction}[] = [\r\n      {position: new Vector2(item.position.x + this._lastSnappedItemHalfSize.x, item.position.z), direction: Direction.PositiveX},\r\n      {position: new Vector2(item.position.x - this._lastSnappedItemHalfSize.x, item.position.z), direction: Direction.NegativeX},\r\n      {position: new Vector2(item.position.x, item.position.z + this._lastSnappedItemHalfSize.z), direction: Direction.PositiveZ},\r\n      {position: new Vector2(item.position.x, item.position.z - this._lastSnappedItemHalfSize.z), direction: Direction.NegativeZ}\r\n    ];\r\n\r\n    for (const check of positionsToCheck) {\r\n      const closestEdgeFromPosition: HalfEdge = this._roomService.getClosestWallEdge(check.position.x, check.position.y);\r\n      const distanceToEdge: number = closestEdgeFromPosition.distanceTo(check.position.x, check.position.y);\r\n      if (!closestEdge || distanceToEdge < closestEdge.distance) {\r\n        switch (check.direction) {\r\n          case Direction.PositiveX:\r\n            check.position.x -= this._lastSnappedItemHalfSize.x - distanceToEdge;\r\n            break;\r\n          case Direction.NegativeX:\r\n            check.position.x += this._lastSnappedItemHalfSize.x - distanceToEdge;\r\n            break;\r\n          case Direction.PositiveZ:\r\n            check.position.y -= this._lastSnappedItemHalfSize.z - distanceToEdge;\r\n            break;\r\n          case Direction.NegativeZ:\r\n            check.position.y += this._lastSnappedItemHalfSize.z - distanceToEdge;\r\n            break;\r\n        }\r\n        closestEdge = {distance: distanceToEdge, position: check.position};\r\n      }\r\n    }\r\n\r\n    return closestEdge;\r\n  }\r\n\r\n  private _closestSnapPositionToItem(itemToSnapTo: Item, itemToSnap: Item): Vector2 {\r\n    let closestSnapPoint: {distance: number, position: Vector2};\r\n    this._updateItemToSnapToHalfSize(itemToSnapTo);\r\n\r\n    const positionsToCheck: Vector2[] = this._generateSnapPositionsToCheck(itemToSnapTo);\r\n\r\n    for (const position of positionsToCheck) {\r\n      const distanceToSnapPoint: number = Utils.distance(position.x, position.y, itemToSnap.position.x, itemToSnap.position.z);\r\n      //// Check for collision when placed in snap position\r\n      // const intersectedFurniture: Furniture[] = this._getIntersectedFurniture(\r\n      //   this._previewPlacementMesh, new Vector3(position.x, itemToSnap.position.y, position.y), 0)\r\n      //   .filter((o) => o !== itemToSnapTo && o !== itemToSnap);\r\n      // if (intersectedFurniture.length === 0) {\r\n        if (!closestSnapPoint || distanceToSnapPoint < closestSnapPoint.distance) {\r\n          closestSnapPoint = {distance: distanceToSnapPoint, position: position};\r\n        }\r\n      // }\r\n    }\r\n\r\n    return closestSnapPoint.position;\r\n  }\r\n\r\n  private _createSnappingPreviewMesh(item: Item): void {\r\n    if (!this._lastSnappedItemHalfSize || !this._itemHalfSizeEqual(this._lastSnappedItemHalfSize, item)) {\r\n      const box: Box3 = new Box3().setFromObject(item);\r\n      this._lastSnappedItemHalfSize = box.max.clone().sub(box.min).divideScalar(2);\r\n      const dimensions: Vector3 = new Vector3().subVectors(box.max, box.min);\r\n      const boxGeometry: BoxGeometry = new BoxGeometry(dimensions.x, dimensions.y, dimensions.z);\r\n\r\n      if (this._previewPlacementMesh) {\r\n        this._sceneService.removeObject(this._previewPlacementMesh, false);\r\n      }\r\n\r\n      this._previewPlacementMesh = new Mesh(boxGeometry, new MeshBasicMaterial(\r\n        {color: 'green', opacity: 0.2, transparent: true, depthTest: false}\r\n      ));\r\n      this._previewPlacementMesh.name = 'snapping-preview-mesh';\r\n\r\n      this._sceneService.addObject(this._previewPlacementMesh);\r\n    }\r\n  }\r\n\r\n  private _getIntersectedFurniture(item: Object3D, position: Vector3, expandScalar: number): Furniture[] {\r\n    const originalPosition: Vector3 = item.position.clone();\r\n    item.position.copy(position);\r\n    const itemBoundingBox: Box3 = new Box3().setFromObject(item).expandByScalar(expandScalar);\r\n    const intersectedItems: Furniture[] = this._itemService.getFurniture().filter((furniture) => {\r\n      if (furniture !== item) {\r\n        const furnitureBoundingBox: Box3 = new Box3().setFromObject(furniture);\r\n        return furnitureBoundingBox.intersectsBox(itemBoundingBox);\r\n      }\r\n    });\r\n    item.position.copy(originalPosition);\r\n    return intersectedItems;\r\n  }\r\n\r\n\r\n  private _getIntersectedFurnitureSortedByDistance(item: Item): Furniture[] {\r\n    return this._getIntersectedFurniture(item, item.position, this._objectSnappingDistance * 2)\r\n      .sort((a, b) => {\r\n        if (Utils.distance(a.position.x, a.position.z, item.position.x, item.position.z) >\r\n          Utils.distance(b.position.x, b.position.z, item.position.x, item.position.z)) {\r\n          return 1;\r\n        } else if (Utils.distance(a.position.x, a.position.z, item.position.x, item.position.z) <\r\n          Utils.distance(b.position.x, b.position.z, item.position.x, item.position.z)) {\r\n          return -1;\r\n        } else {\r\n          return 0;\r\n        }\r\n      });\r\n  }\r\n\r\n  private _updateItemToSnapToHalfSize(itemToSnapTo: Object3D) {\r\n    // @ts-ignore\r\n    if (!this._lastSnappedToItemHalfSize || !this._itemHalfSizeEqual(this._lastSnappedToItemHalfSize, itemToSnapTo)) {\r\n      const box: Box3 = new Box3().setFromObject(itemToSnapTo);\r\n      this._lastSnappedToItemHalfSize = box.max.clone().sub(box.min).divideScalar(2);\r\n    }\r\n  }\r\n\r\n  private _itemHalfSizeEqual(vector: Vector3, item: Item): boolean {\r\n    const box: Box3 = new Box3().setFromObject(item);\r\n    const itemHalfSize: Vector3 = box.max.clone().sub(box.min).divideScalar(2);\r\n    return this._vector3ValuesEqual(vector, itemHalfSize);\r\n  }\r\n\r\n  private _vector3ValuesEqual(v1: Vector3, v2: Vector3): boolean {\r\n    return v1.x.toFixed(8) === v2.x.toFixed(8) && v1.y.toFixed(8) === v2.y.toFixed(8) && v1.z.toFixed(8) === v2.z.toFixed(8);\r\n  }\r\n\r\n  private _generateSnapPositionsToCheck(itemToSnapTo: Item): Vector2[] {\r\n    return [\r\n      // Positive X\r\n      new Vector2(\r\n        itemToSnapTo.position.x + this._lastSnappedToItemHalfSize.x + this._lastSnappedItemHalfSize.x,\r\n        itemToSnapTo.position.z + (this._lastSnappedToItemHalfSize.z - this._lastSnappedItemHalfSize.z)),\r\n      new Vector2(\r\n        itemToSnapTo.position.x + this._lastSnappedToItemHalfSize.x + this._lastSnappedItemHalfSize.x,\r\n        itemToSnapTo.position.z - (this._lastSnappedToItemHalfSize.z - this._lastSnappedItemHalfSize.z)),\r\n      new Vector2(itemToSnapTo.position.x + this._lastSnappedToItemHalfSize.x + this._lastSnappedItemHalfSize.x, itemToSnapTo.position.z),\r\n\r\n      // Negative X\r\n      new Vector2(\r\n        itemToSnapTo.position.x - this._lastSnappedToItemHalfSize.x - this._lastSnappedItemHalfSize.x,\r\n        itemToSnapTo.position.z + (this._lastSnappedToItemHalfSize.z - this._lastSnappedItemHalfSize.z)),\r\n      new Vector2(\r\n        itemToSnapTo.position.x - this._lastSnappedToItemHalfSize.x - this._lastSnappedItemHalfSize.x,\r\n        itemToSnapTo.position.z - (this._lastSnappedToItemHalfSize.z - this._lastSnappedItemHalfSize.z)),\r\n      new Vector2(itemToSnapTo.position.x - this._lastSnappedToItemHalfSize.x - this._lastSnappedItemHalfSize.x, itemToSnapTo.position.z),\r\n\r\n      // Positive Z\r\n      new Vector2(\r\n        itemToSnapTo.position.x + (this._lastSnappedToItemHalfSize.x - this._lastSnappedItemHalfSize.x),\r\n        itemToSnapTo.position.z + this._lastSnappedToItemHalfSize.z + this._lastSnappedItemHalfSize.z),\r\n      new Vector2(\r\n        itemToSnapTo.position.x - (this._lastSnappedToItemHalfSize.x - this._lastSnappedItemHalfSize.x),\r\n        itemToSnapTo.position.z + this._lastSnappedToItemHalfSize.z + this._lastSnappedItemHalfSize.z),\r\n      new Vector2(itemToSnapTo.position.x, itemToSnapTo.position.z + this._lastSnappedToItemHalfSize.z + this._lastSnappedItemHalfSize.z),\r\n\r\n      // Negative Z\r\n      new Vector2(\r\n        itemToSnapTo.position.x  + (this._lastSnappedToItemHalfSize.x - this._lastSnappedItemHalfSize.x),\r\n        itemToSnapTo.position.z - this._lastSnappedToItemHalfSize.z - this._lastSnappedItemHalfSize.z),\r\n      new Vector2(\r\n        itemToSnapTo.position.x  - (this._lastSnappedToItemHalfSize.x - this._lastSnappedItemHalfSize.x),\r\n        itemToSnapTo.position.z - this._lastSnappedToItemHalfSize.z - this._lastSnappedItemHalfSize.z),\r\n      new Vector2(itemToSnapTo.position.x, itemToSnapTo.position.z - this._lastSnappedToItemHalfSize.z - this._lastSnappedItemHalfSize.z),\r\n    ];\r\n  }\r\n}\r\n"]}

package/esm2015/app/plugins/core3d/components/ar-gui/ar-gui-root/ar-gui-elements/ar-gui-buttons/ar-gui-buttons.component.js

@@ -0,0 +1,36 @@
+import { Component } from '@angular/core';
+import { IconEnum } from '../../../../../../../core/enum/icon.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../../../../core/service/homedecorator-icon-cache.service";
+import * as i2 from "../../../../../service/ar.service";
+import * as i3 from "@angular/material/button";
+import * as i4 from "@colijnit/corecomponents_v12";
+export class ArGuiButtonsComponent {
+    constructor(iconService, _arService) {
+        this.iconService = iconService;
+        this._arService = _arService;
+        this.icon = IconEnum;
+    }
+    ngOnInit() {
+    }
+    endSession() {
+        this._arService.endSessionEvent();
+    }
+    showConfigurator() {
+        this._arService.showConfigurator = !this._arService.showConfigurator;
+    }
+    resetDetectedPlanes() {
+        this._arService.resetPlaneDetection();
+    }
+}
+ArGuiButtonsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ArGuiButtonsComponent, deps: [{ token: i1.HomedecoratorIconCacheService }, { token: i2.ArService }], target: i0.ɵɵFactoryTarget.Component });
+ArGuiButtonsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: ArGuiButtonsComponent, selector: "ar-gui-buttons", ngImport: i0, template: "<div class=\"buttons-container\">\r\n  <div class=\"button-container\" xmlns=\"http://www.w3.org/1999/html\">\r\n    <button mat-mini-fab class=\"button-icon back\" (click)=\"endSession()\">\r\n      <co-icon class=\"icon rotated\" [iconData]=\"iconService.getIcon(icon.TriangleDown)\"></co-icon>\r\n    </button>\r\n  </div>\r\n\r\n  <div class=\"button-container\" xmlns=\"http://www.w3.org/1999/html\">\r\n    <button class=\"button-icon\" mat-mini-fab (click)=\"showConfigurator()\">\r\n      <co-icon class=\"icon\" [iconData]=\"iconService.getIcon(icon.MagicWand)\"></co-icon>\r\n    </button>\r\n  </div>\r\n</div>\r\n", styles: [".buttons-container{position:absolute;display:flex;left:50%;bottom:0;transform:translate(-50%)}.button-container{padding:20px}.button-icon{text-align:-webkit-center}.back{padding-right:3px}.icon{width:65%;height:65%;fill:#fff}.rotated{transform:rotate(90deg)}\n"], components: [{ type: i3.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { type: i4.IconComponent, selector: "co-icon", inputs: ["icon", "iconData"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ArGuiButtonsComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ar-gui-buttons',
+                    templateUrl: './ar-gui-buttons.component.html',
+                    styleUrls: ['./ar-gui-buttons.component.scss']
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HomedecoratorIconCacheService }, { type: i2.ArService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXItZ3VpLWJ1dHRvbnMuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2NsaWVudC9hcHAvcGx1Z2lucy9jb3JlM2QvY29tcG9uZW50cy9hci1ndWkvYXItZ3VpLXJvb3QvYXItZ3VpLWVsZW1lbnRzL2FyLWd1aS1idXR0b25zL2FyLWd1aS1idXR0b25zLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9jbGllbnQvYXBwL3BsdWdpbnMvY29yZTNkL2NvbXBvbmVudHMvYXItZ3VpL2FyLWd1aS1yb290L2FyLWd1aS1lbGVtZW50cy9hci1ndWktYnV0dG9ucy9hci1ndWktYnV0dG9ucy5jb21wb25lbnQuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFVLE1BQU0sZUFBZSxDQUFDO0FBQ2xELE9BQU8sRUFBQyxRQUFRLEVBQUMsTUFBTSwwQ0FBMEMsQ0FBQzs7Ozs7O0FBU2xFLE1BQU0sT0FBTyxxQkFBcUI7SUFHaEMsWUFBbUIsV0FBMEMsRUFBVSxVQUFxQjtRQUF6RSxnQkFBVyxHQUFYLFdBQVcsQ0FBK0I7UUFBVSxlQUFVLEdBQVYsVUFBVSxDQUFXO1FBRjVFLFNBQUksR0FBb0IsUUFBUSxDQUFDO0lBRStDLENBQUM7SUFFakcsUUFBUTtJQUNSLENBQUM7SUFFTSxVQUFVO1FBQ2YsSUFBSSxDQUFDLFVBQVUsQ0FBQyxlQUFlLEVBQUUsQ0FBQztJQUNwQyxDQUFDO0lBRU0sZ0JBQWdCO1FBQ3JCLElBQUksQ0FBQyxVQUFVLENBQUMsZ0JBQWdCLEdBQUcsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLGdCQUFnQixDQUFDO0lBQ3ZFLENBQUM7SUFFTSxtQkFBbUI7UUFDeEIsSUFBSSxDQUFDLFVBQVUsQ0FBQyxtQkFBbUIsRUFBRSxDQUFDO0lBQ3hDLENBQUM7O21IQWxCVSxxQkFBcUI7dUdBQXJCLHFCQUFxQixzRENWbEMsbW5CQWFBOzRGREhhLHFCQUFxQjtrQkFMakMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsZ0JBQWdCO29CQUMxQixXQUFXLEVBQUUsaUNBQWlDO29CQUM5QyxTQUFTLEVBQUUsQ0FBQyxpQ0FBaUMsQ0FBQztpQkFDL0MiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIE9uSW5pdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQge0ljb25FbnVtfSBmcm9tICcuLi8uLi8uLi8uLi8uLi8uLi8uLi9jb3JlL2VudW0vaWNvbi5lbnVtJztcclxuaW1wb3J0IHtIb21lZGVjb3JhdG9ySWNvbkNhY2hlU2VydmljZX0gZnJvbSAnLi4vLi4vLi4vLi4vLi4vLi4vLi4vY29yZS9zZXJ2aWNlL2hvbWVkZWNvcmF0b3ItaWNvbi1jYWNoZS5zZXJ2aWNlJztcclxuaW1wb3J0IHtBclNlcnZpY2V9IGZyb20gJy4uLy4uLy4uLy4uLy4uL3NlcnZpY2UvYXIuc2VydmljZSc7XHJcblxyXG5AQ29tcG9uZW50KHtcclxuICBzZWxlY3RvcjogJ2FyLWd1aS1idXR0b25zJyxcclxuICB0ZW1wbGF0ZVVybDogJy4vYXItZ3VpLWJ1dHRvbnMuY29tcG9uZW50Lmh0bWwnLFxyXG4gIHN0eWxlVXJsczogWycuL2FyLWd1aS1idXR0b25zLmNvbXBvbmVudC5zY3NzJ11cclxufSlcclxuZXhwb3J0IGNsYXNzIEFyR3VpQnV0dG9uc0NvbXBvbmVudCBpbXBsZW1lbnRzIE9uSW5pdCB7XHJcbiAgcHVibGljIHJlYWRvbmx5IGljb246IHR5cGVvZiBJY29uRW51bSA9IEljb25FbnVtO1xyXG5cclxuICBjb25zdHJ1Y3RvcihwdWJsaWMgaWNvblNlcnZpY2U6IEhvbWVkZWNvcmF0b3JJY29uQ2FjaGVTZXJ2aWNlLCBwcml2YXRlIF9hclNlcnZpY2U6IEFyU2VydmljZSkgeyB9XHJcblxyXG4gIG5nT25Jbml0KCkge1xyXG4gIH1cclxuXHJcbiAgcHVibGljIGVuZFNlc3Npb24oKSB7XHJcbiAgICB0aGlzLl9hclNlcnZpY2UuZW5kU2Vzc2lvbkV2ZW50KCk7XHJcbiAgfVxyXG5cclxuICBwdWJsaWMgc2hvd0NvbmZpZ3VyYXRvcigpIHtcclxuICAgIHRoaXMuX2FyU2VydmljZS5zaG93Q29uZmlndXJhdG9yID0gIXRoaXMuX2FyU2VydmljZS5zaG93Q29uZmlndXJhdG9yO1xyXG4gIH1cclxuXHJcbiAgcHVibGljIHJlc2V0RGV0ZWN0ZWRQbGFuZXMoKSB7XHJcbiAgICB0aGlzLl9hclNlcnZpY2UucmVzZXRQbGFuZURldGVjdGlvbigpO1xyXG4gIH1cclxufVxyXG4iLCI8ZGl2IGNsYXNzPVwiYnV0dG9ucy1jb250YWluZXJcIj5cclxuICA8ZGl2IGNsYXNzPVwiYnV0dG9uLWNvbnRhaW5lclwiIHhtbG5zPVwiaHR0cDovL3d3dy53My5vcmcvMTk5OS9odG1sXCI+XHJcbiAgICA8YnV0dG9uIG1hdC1taW5pLWZhYiBjbGFzcz1cImJ1dHRvbi1pY29uIGJhY2tcIiAoY2xpY2spPVwiZW5kU2Vzc2lvbigpXCI+XHJcbiAgICAgIDxjby1pY29uIGNsYXNzPVwiaWNvbiByb3RhdGVkXCIgW2ljb25EYXRhXT1cImljb25TZXJ2aWNlLmdldEljb24oaWNvbi5UcmlhbmdsZURvd24pXCI+PC9jby1pY29uPlxyXG4gICAgPC9idXR0b24+XHJcbiAgPC9kaXY+XHJcblxyXG4gIDxkaXYgY2xhc3M9XCJidXR0b24tY29udGFpbmVyXCIgeG1sbnM9XCJodHRwOi8vd3d3LnczLm9yZy8xOTk5L2h0bWxcIj5cclxuICAgIDxidXR0b24gY2xhc3M9XCJidXR0b24taWNvblwiIG1hdC1taW5pLWZhYiAoY2xpY2spPVwic2hvd0NvbmZpZ3VyYXRvcigpXCI+XHJcbiAgICAgIDxjby1pY29uIGNsYXNzPVwiaWNvblwiIFtpY29uRGF0YV09XCJpY29uU2VydmljZS5nZXRJY29uKGljb24uTWFnaWNXYW5kKVwiPjwvY28taWNvbj5cclxuICAgIDwvYnV0dG9uPlxyXG4gIDwvZGl2PlxyXG48L2Rpdj5cclxuIl19

package/esm2015/app/plugins/core3d/components/ar-gui/ar-gui-root/ar-gui-elements/ar-gui-configurator/ar-gui-configurator.component.js

@@ -0,0 +1,49 @@
+import { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../../../../core/service/homedecorator-app-event.service";
+import * as i2 from "../../../../../../threedselector/threedselector/service/build-furniture.service";
+import * as i3 from "../../../../../../threedselector/threedselector/service/load-furniture.service";
+import * as i4 from "../../../../../service/ar.service";
+import * as i5 from "../../../../../../lite-selector/lite-selector/lite-selector.component";
+import * as i6 from "@angular/common";
+export class ArGuiConfiguratorComponent {
+    constructor(_appEventService, _buildFurnitureService, _loadFurnitureService, _arService) {
+        this._appEventService = _appEventService;
+        this._buildFurnitureService = _buildFurnitureService;
+        this._loadFurnitureService = _loadFurnitureService;
+        this._arService = _arService;
+        this.showSelections = true;
+        this.showAnswers = true;
+        this._subs = [];
+        this._subs.push(this._buildFurnitureService.buildFinished.subscribe(() => this._arService.updateChangedModel()), this._buildFurnitureService.arPlacementUpdate.subscribe(() => this._arService.updateChangedModel()), this._appEventService.answerCountReceived.subscribe((answerCount) => this._handleAnswerCountReceived(answerCount)), this._loadFurnitureService.metadataSet.subscribe((metadata) => {
+            if (metadata) {
+                this.metadata = metadata;
+            }
+        }));
+    }
+    ngOnInit() {
+    }
+    ngOnDestroy() {
+        this._subs.forEach((sub) => { sub.unsubscribe(); });
+    }
+    showConfigurator() {
+        return this._arService.modelPlaced() && this._arService.showConfigurator;
+    }
+    handleAnswerChosen() {
+        this._arService.savePreSelectionPosition();
+    }
+    _handleAnswerCountReceived(answerCount) {
+        this.showAnswers = answerCount > 0;
+    }
+}
+ArGuiConfiguratorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ArGuiConfiguratorComponent, deps: [{ token: i1.HomedecoratorAppEventService }, { token: i2.BuildFurnitureService }, { token: i3.LoadFurnitureService }, { token: i4.ArService }], target: i0.ɵɵFactoryTarget.Component });
+ArGuiConfiguratorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: ArGuiConfiguratorComponent, selector: "ar-gui-configurator", ngImport: i0, template: "<div *ngIf=\"showConfigurator()\">\r\n  <div class=\"configurator-container\">\r\n    <rp-lite-selector class=\"rp-lite-selector\"\r\n                      [metadata]=\"metadata\"\r\n                      [showLabel]=\"false\"\r\n                      [customDimensions]=\"true\"\r\n                      [canClose]=\"false\"\r\n                      [show]=\"true\"\r\n                      [showSelections]=\"showSelections\"\r\n                      [showAnswers]=\"showAnswers\"\r\n                      (answerChosen)=\"handleAnswerChosen()\"\r\n    ></rp-lite-selector>\r\n  </div>\r\n</div>\r\n", styles: [".configurator-container{background:white;max-width:35%;max-height:100%;position:fixed;top:0;bottom:0;right:0;left:0;z-index:2;margin-left:auto;overflow:auto}\n"], components: [{ type: i5.LiteSelectorComponent, selector: "rp-lite-selector", inputs: ["showAnswers", "show", "showSelections", "showLabel", "canClose", "metadata", "customDimensions"], outputs: ["showChange", "answerChosen"] }], directives: [{ type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ArGuiConfiguratorComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ar-gui-configurator',
+                    templateUrl: './ar-gui-configurator.component.html',
+                    styleUrls: ['./ar-gui-configurator.component.scss']
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HomedecoratorAppEventService }, { type: i2.BuildFurnitureService }, { type: i3.LoadFurnitureService }, { type: i4.ArService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/app/plugins/core3d/components/ar-gui/ar-gui-root/ar-gui-elements/ar-gui-context-menu/ar-gui-context-menu.component.js

@@ -0,0 +1,77 @@
+import { Component } from '@angular/core';
+import { Vector2, Vector3 } from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../../service/ar.service";
+import * as i2 from "../../../../../service/camera.service";
+export class ArGuiContextMenuComponent {
+    constructor(_arService, _cameraService) {
+        this._arService = _arService;
+        this._cameraService = _cameraService;
+        this.left = 0;
+        this.top = 0;
+        this.position = new Vector2();
+    }
+    ngOnInit() {
+        this._element = document.getElementById('ar-root');
+        this._item = this._arService.getActiveModel();
+        this._arService.updateContextMenu.subscribe(() => this._updateItemMenuPosition(this._item));
+    }
+    _updateItemMenuPosition(item) {
+        if (item) {
+            this.position.copy(this._calculateMenuPositions(item)
+                // calculate world positions of bounding box top corners and project them on screen
+                .map(position => this._projectVector(new Vector3().copy(position).applyQuaternion(item.quaternion).add(item.position)))
+                // find the rightmost one
+                .sort((a, b) => b.x - a.x)[0]);
+            this.left = this.position.x;
+            this.top = this.position.y;
+        }
+    }
+    _projectVector(vec3, ignoreMargin = false) {
+        const widthHalf = this._element.clientWidth / 2;
+        const heightHalf = this._element.clientHeight / 2;
+        const vector = new Vector3();
+        vector.copy(vec3);
+        vector.project(this._cameraService.camera);
+        const vec2 = new Vector2();
+        vec2.x = (vector.x * widthHalf) + widthHalf;
+        vec2.y = -(vector.y * heightHalf) + heightHalf;
+        ignoreMargin = ignoreMargin ? ignoreMargin : false;
+        if (!ignoreMargin) {
+            const widthMargin = this._element.offsetLeft;
+            const heightMargin = this._element.offsetTop;
+            vec2.x += widthMargin;
+            vec2.y += heightMargin;
+        }
+        return vec2;
+    }
+    _calculateMenuPositions(item) {
+        return [
+            new Vector3(item.getWidth() / 2, item.getHeight() / 2, item.getDepth() / 2),
+            new Vector3(-item.getWidth() / 2, item.getHeight() / 2, item.getDepth() / 2),
+            new Vector3(item.getWidth() / 2, item.getHeight() / 2, -item.getDepth() / 2),
+            new Vector3(-item.getWidth() / 2, item.getHeight() / 2, -item.getDepth() / 2)
+        ];
+    }
+}
+ArGuiContextMenuComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ArGuiContextMenuComponent, deps: [{ token: i1.ArService }, { token: i2.CameraService }], target: i0.ɵɵFactoryTarget.Component });
+ArGuiContextMenuComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: ArGuiContextMenuComponent, selector: "ar-gui-context-menu", ngImport: i0, template: `
+    <div class="context-menu" [style.left.px]="left" [style.top.px]="top">
+      <ng-content>
+      </ng-content>
+    </div>
+  `, isInline: true, styles: [".context-menu{position:absolute}.context-menu button:not(:last-child){margin-right:3px}\n"] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ArGuiContextMenuComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ar-gui-context-menu',
+                    template: `
+    <div class="context-menu" [style.left.px]="left" [style.top.px]="top">
+      <ng-content>
+      </ng-content>
+    </div>
+  `,
+                    styleUrls: ['./ar-gui-context-menu.component.scss']
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ArService }, { type: i2.CameraService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/app/plugins/core3d/components/ar-gui/ar-gui-root/ar-gui-elements/ar-gui-notifications/ar-gui-notifications.component.js

@@ -0,0 +1,26 @@
+import { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../../service/ar.service";
+import * as i2 from "@angular/material/progress-bar";
+import * as i3 from "@angular/common";
+export class ArGuiNotificationsComponent {
+    constructor(_arService) {
+        this._arService = _arService;
+    }
+    ngOnInit() {
+    }
+    modelLoading() {
+        return this._arService.modelLoading();
+    }
+}
+ArGuiNotificationsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ArGuiNotificationsComponent, deps: [{ token: i1.ArService }], target: i0.ɵɵFactoryTarget.Component });
+ArGuiNotificationsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: ArGuiNotificationsComponent, selector: "ar-gui-notifications", ngImport: i0, template: "<div class=\"loading-overlay\" *ngIf=\"modelLoading()\">\r\n  <mat-progress-bar class=\"progress-bar\" mode=\"indeterminate\"></mat-progress-bar>\r\n</div>\r\n", styles: [".loading-overlay{display:flex;position:fixed;background:black;opacity:40%;height:100%;width:100%;top:0;bottom:0;right:0;left:0;z-index:2}.progress-bar{align-self:center;width:20%;margin:auto}\n"], components: [{ type: i2.MatProgressBar, selector: "mat-progress-bar", inputs: ["color", "mode", "value", "bufferValue"], outputs: ["animationEnd"], exportAs: ["matProgressBar"] }], directives: [{ type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ArGuiNotificationsComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ar-gui-notifications',
+                    templateUrl: './ar-gui-notifications.component.html',
+                    styleUrls: ['./ar-gui-notifications.component.scss']
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ArService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/app/plugins/core3d/components/ar-gui/ar-gui-root/ar-gui-root.component.js

@@ -0,0 +1,46 @@
+import { Component } from '@angular/core';
+import { ViewMode } from '../../../../../core/enum/view-mode.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../../core/service/view-mode.service";
+import * as i2 from "../../../service/ar.service";
+import * as i3 from "@angular/material/icon";
+import * as i4 from "./ar-gui-elements/ar-gui-buttons/ar-gui-buttons.component";
+import * as i5 from "./ar-gui-elements/ar-gui-notifications/ar-gui-notifications.component";
+import * as i6 from "./ar-gui-elements/ar-gui-configurator/ar-gui-configurator.component";
+import * as i7 from "./ar-gui-elements/ar-gui-context-menu/ar-gui-context-menu.component";
+import * as i8 from "@angular/material/button";
+import * as i9 from "@angular/common";
+import * as i10 from "@angular/material/tooltip";
+import * as i11 from "../../../../../core/pipe/localize.pipe";
+export class ArGuiRootComponent {
+    constructor(_viewModeService, _arService) {
+        this._viewModeService = _viewModeService;
+        this._arService = _arService;
+    }
+    ngOnInit() {
+    }
+    inARViewMode() {
+        return this._viewModeService.viewMode === ViewMode.AR;
+    }
+    showConfigurator() {
+        this._arService.showConfigurator = true;
+        this._arService.showContextMenu = false;
+    }
+    showContextMenu() {
+        return this._arService.showContextMenu;
+    }
+    showMovePhoneAnimation() {
+        return this._arService.showMovePhoneAnimation();
+    }
+}
+ArGuiRootComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ArGuiRootComponent, deps: [{ token: i1.ViewModeService }, { token: i2.ArService }], target: i0.ɵɵFactoryTarget.Component });
+ArGuiRootComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: ArGuiRootComponent, selector: "ar-gui-root", ngImport: i0, template: "<div id=\"ar-root\">\r\n  <div *ngIf=\"inARViewMode()\">\r\n    <div *ngIf=\"showMovePhoneAnimation()\" class=\"icon-wrapper\">\r\n      <mat-icon class=\"homedecorator-material-icons\" svgIcon=\"move-phone-ar\" class=\"move-phone-icon\"></mat-icon>\r\n    </div>\r\n    <ar-gui-buttons></ar-gui-buttons>\r\n    <ar-gui-notifications></ar-gui-notifications>\r\n    <ar-gui-configurator></ar-gui-configurator>\r\n    <ar-gui-context-menu *ngIf=\"showContextMenu()\">\r\n      <button mat-mini-fab (click)=\"showConfigurator()\"\r\n              matTooltip=\"{{'CONFIGURE' | localize}}\">\r\n        <mat-icon class=\"homedecorator-material-icons\" svgIcon=\"magic-wand\"></mat-icon>\r\n      </button>\r\n    </ar-gui-context-menu>\r\n  </div>\r\n</div>\r\n", styles: [":host .icon-wrapper{display:flex;width:100vw;height:100vh;justify-content:center}:host .move-phone-icon{filter:invert(1);align-self:center;padding-top:20px;animation:myAnimation 5s infinite}@keyframes myAnimation{0%{transform:scale(3) translate(0)}25%{transform:scale(3) translate(50%)}50%{transform:scale(3) translate(0)}75%{transform:scale(3) translate(-50%)}to{transform:scale(3) translate(0)}}\n"], components: [{ type: i3.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { type: i4.ArGuiButtonsComponent, selector: "ar-gui-buttons" }, { type: i5.ArGuiNotificationsComponent, selector: "ar-gui-notifications" }, { type: i6.ArGuiConfiguratorComponent, selector: "ar-gui-configurator" }, { type: i7.ArGuiContextMenuComponent, selector: "ar-gui-context-menu" }, { type: i8.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }], directives: [{ type: i9.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i10.MatTooltip, selector: "[matTooltip]", exportAs: ["matTooltip"] }], pipes: { "localize": i11.LocalizePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ArGuiRootComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ar-gui-root',
+                    templateUrl: './ar-gui-root.component.html',
+                    styleUrls: ['./ar-gui-root.component.scss']
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ViewModeService }, { type: i2.ArService }]; } });
+//# sourceMappingURL=data:application/json;base64,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