@colijnit/homedecorator 255.1.1

package/esm2015/app/plugins/core3d/service/drag-and-drop.service.js

@@ -0,0 +1,369 @@
+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 { Vector3 } from 'three';
+import * as TWEEN from '@tweenjs/tween.js';
+var Tween = TWEEN.Tween;
+import { DraggedStatus } from '../model/dragged-status';
+import { WallItem, WallItemGroup } from '../items/wall-objects';
+import { ItemGroup } from '../items/item-group';
+import { ItemType } from '../items/item-type';
+import { Item } from '../items/item';
+import { FloorItem } from '../items/floor-item';
+import { isCustomFloorGroupType, isFloorGroupType, isFloorType, isWallFloorType, isWallType, } from '../items/factory';
+import { WallPin } from '../items/wall-pin';
+import { FloorPin } from '../items/floor-pin';
+import { MessageType } from '../../../core/enum/message-type.enum';
+import { CustomWallFloorItem } from '../items/custom-wall-floor-item';
+import { ViewMode } from '../../../core/enum/view-mode.enum';
+import { Utils } from '../core/utils';
+import { FloorPlaneItem } from '../items/floor-plane-item';
+import * as i0 from "@angular/core";
+import * as i1 from "./scene.service";
+import * as i2 from "./models.service";
+import * as i3 from "../collision-manager/collision-manager.service";
+import * as i4 from "../../room-planner/components/floorplanner/service/room.service";
+import * as i5 from "./error-glow.service";
+import * as i6 from "./outline.service";
+import * as i7 from "./hud.service";
+import * as i8 from "../../../core/service/message-bus.service";
+import * as i9 from "./item.service";
+import * as i10 from "../../../core/service/homedecorator-settings.service";
+import * as i11 from "../collision-manager/snapping-collision.service";
+import * as i12 from "../../../core/service/view-mode.service";
+import * as i13 from "./floor.service";
+export class DragAndDropService {
+    constructor(_sceneService, _modelsService, _collisionManagerService, _roomService, _errorGlowService, _outlineService, _hudService, _messageBusService, _itemService, _settingsService, _snappingCollisionService, _viewModeService, _floorService) {
+        this._sceneService = _sceneService;
+        this._modelsService = _modelsService;
+        this._collisionManagerService = _collisionManagerService;
+        this._roomService = _roomService;
+        this._errorGlowService = _errorGlowService;
+        this._outlineService = _outlineService;
+        this._hudService = _hudService;
+        this._messageBusService = _messageBusService;
+        this._itemService = _itemService;
+        this._settingsService = _settingsService;
+        this._snappingCollisionService = _snappingCollisionService;
+        this._viewModeService = _viewModeService;
+        this._floorService = _floorService;
+        this.draggedStatus = new DraggedStatus();
+        this._dragOffset = new Vector3();
+        this._subs = [];
+        this._subs.push(this._messageBusService.subscribe(MessageType.UndefinedErrorOccured, () => this._destroyPin()));
+        window.onbeforeunload = () => this.ngOnDestroy();
+    }
+    ngOnDestroy() {
+        this._subs.forEach(s => s.unsubscribe());
+    }
+    set draggedData(object) {
+        this.finishDragging();
+        this._draggedData = object;
+    }
+    get draggedData() {
+        return this._draggedData;
+    }
+    get draggedItem() {
+        return this._draggedItem;
+    }
+    set draggedItem(value) {
+        this._draggedItem = value;
+    }
+    dragModel(point, floorIntersect) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this._createPin(point, floorIntersect);
+                const closestWallEdge = this._roomService.getClosestWallEdge((point !== undefined ? point.x : 0), (point !== undefined ? point.z : 0));
+                const isDraggedObjectIsFurniture = this.draggedData.iOne;
+                if (isDraggedObjectIsFurniture) {
+                    this.draggedItem = yield this._replacePinWithFurniture(this._pin.position);
+                }
+                else {
+                    this.draggedItem = yield this._replacePinWithModel(this._pin.position);
+                }
+                if (this.draggedItem instanceof WallItem && !(isWallFloorType(this.draggedData.type) && floorIntersect)) {
+                    this.draggedItem.placeOnEdge(closestWallEdge);
+                }
+                if (this.draggedItem) {
+                    this._moveItemToPosition(this.draggedItem, this._pin.position);
+                    this.draggedStatus.objectLoaded();
+                }
+                else {
+                    this.draggedStatus.dragCanceled();
+                }
+            }
+            catch (err) {
+                this.draggedStatus.dragCanceled();
+                throw err;
+            }
+            finally {
+                if (this.draggedStatus.isMarkedToCleanUp) {
+                    this.finishDragging();
+                }
+                if (this._pin) {
+                    this._destroyPin();
+                }
+            }
+        });
+    }
+    dragFloorDecoration(floorIntersect) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (floorIntersect && floorIntersect.object) {
+                    const floorPlane = (floorIntersect.object instanceof FloorPlaneItem ? floorIntersect.object : floorIntersect.object.parent);
+                    this._floorService.highLightFloor(floorPlane);
+                }
+                else {
+                    this._floorService.unHighLightFloors();
+                }
+            }
+            catch (err) {
+                this.draggedStatus.dragCanceled();
+                throw err;
+            }
+            finally {
+                if (this.draggedStatus.isMarkedToCleanUp) {
+                    this.finishDragging();
+                }
+            }
+        });
+    }
+    updateDraggedPosition(point) {
+        if (this.draggedData.type === ItemType.FloorDecoration) {
+            this.dragFloorDecoration(this.intersectedFloor);
+        }
+        else {
+            if (this._pin && this._pin.isActive) {
+                if (this.draggedData.type === ItemType.CustomWallFloor &&
+                    ((this._pin instanceof WallPin && this.intersectedFloor) || (this._pin instanceof FloorPin && this.intersectedWall))) {
+                    this._createPin(point, this.intersectedFloor);
+                }
+                this._moveItemToPosition(this._pin, point);
+                this.draggedStatus.pinDropped();
+            }
+            else if (this.draggedItem) {
+                this._moveItemToPosition(this._draggedItem, point);
+            }
+        }
+    }
+    draggedPlaced(position, intersection) {
+        this._placedPosition = position;
+        this._placedIntersection = intersection;
+        if (this.draggedData.type === ItemType.FloorDecoration && this._placedIntersection && this._placedIntersection.object) {
+            this._floorService.configureFloor((this._placedIntersection.object instanceof FloorPlaneItem ? this._placedIntersection.object : this._placedIntersection.object.parent));
+            this._replacePinWithFurniture(this._placedPosition);
+        }
+        else {
+            if (this._pin && this._pin.isActive) {
+                this._startPinAnimation();
+            }
+            else {
+                this.updateDraggedPosition(this._placedPosition);
+            }
+        }
+        this.draggedStatus.dragDropped();
+        this._sceneService.needsRender = true;
+    }
+    finishDragging() {
+        if (this._pin) {
+            this._destroyPin();
+        }
+        this._draggedData = null;
+        this._draggedItem = null;
+        this._placedPosition = null;
+        this._placedIntersection = null;
+        this.draggedStatus.clean();
+        this._errorGlowService.hideError();
+        this._snappingCollisionService.handleEndOfDragging();
+        this._outlineService.hideOutline();
+    }
+    setDragOffset(intersectionPoint, sub = true) {
+        this._dragOffset.copy(intersectionPoint);
+        if (sub) {
+            this._dragOffset.sub(this.draggedItem.position);
+        }
+    }
+    clickDragged(intersection) {
+        const vec3 = intersection.point;
+        // if (this.intersectedWall || this.intersectedFloor) {
+        //   vec3 = this.intersectedWall ?
+        //     this.intersectedWall.point.sub(this._dragOffset) :
+        //     this.intersectedFloor.point.sub(this._dragOffset);
+        // }
+        this._moveItemToPosition(this.draggedItem, vec3.sub(this._dragOffset));
+    }
+    dragConnector(connector, vec3) {
+        if (this.draggedItem instanceof Item) {
+            this.draggedItem.dragConnector(connector, vec3 /*.sub(this._dragOffset)*/);
+        }
+    }
+    clickReleased() {
+        this._errorGlowService.hideError();
+        this._snappingCollisionService.handleEndOfDragging();
+    }
+    _createPin(point, floorIntersect) {
+        if (this._pin) {
+            this._destroyPin();
+        }
+        const closestWallEdge = this._roomService.getClosestWallEdge((point !== undefined ? point.x : 0), (point !== undefined ? point.z : 0));
+        if (!this._pin) {
+            if (isWallType(this.draggedData.type) || (isWallFloorType(this.draggedData.type) && !floorIntersect)) {
+                this._pin = new WallPin();
+                this._pin.placeOnEdge(closestWallEdge);
+            }
+            else if (isFloorType(this.draggedData.type) || (isWallFloorType(this.draggedData.type) && floorIntersect)) {
+                const pointOnTheFloor = this._roomService.getRoomCenter() ? this._roomService.getRoomCenter() : point;
+                this._pin = new FloorPin();
+                this._moveItemToPosition(this._pin, pointOnTheFloor);
+            }
+            this._itemService.addItem(this._pin);
+        }
+        this._pin.activate();
+    }
+    _replacePinWithFurniture(point) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.draggedData.constructFn(point);
+            return result && result.furniture ? result.furniture : null;
+        });
+    }
+    _replacePinWithModel(point) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const model = yield this._modelsService.get(this.draggedData.name, this.draggedData.overrides);
+            let item;
+            if (model) {
+                if (isFloorGroupType(model.type) || isCustomFloorGroupType(model.type)) {
+                    item = yield this._itemService.addFloorGroupItem(model, point);
+                }
+                else {
+                    item = yield this._itemService.addJsonItem(model, point);
+                }
+            }
+            return item;
+        });
+    }
+    _destroyPin() {
+        if (this._pin instanceof WallItem && this._pin.currentWall) {
+            this._pin.currentWall.removeOnItem(this._pin);
+        }
+        this._itemService.removeItem(this._pin);
+        this._pin = null;
+        this._pinAnimation = null;
+    }
+    _moveItemToPosition(item, vec3) {
+        if (!this._sceneService.arMode) {
+            if (item instanceof FloorItem || (item instanceof ItemGroup && !(item instanceof WallItemGroup))
+                || (item instanceof CustomWallFloorItem && this.intersectedFloor)) {
+                if (item instanceof Item && item.configuring && item.shouldMoveChild) {
+                    item.moveChildToPosition(vec3);
+                }
+                else {
+                    if (item instanceof CustomWallFloorItem && item.currentWall) {
+                        item.removeFromWall();
+                        item.moveFromWallToFloor();
+                    }
+                    this._moveFloorItemToPosition(item, vec3);
+                }
+            }
+            else if (item instanceof WallItem || item instanceof WallItemGroup) {
+                if (item instanceof CustomWallFloorItem && this.intersectedWall) {
+                    if (!item.currentWall) {
+                        const closestWallEdge = this._roomService.getClosestWallEdge((vec3 !== undefined ? vec3.x : 0), (vec3 !== undefined ? vec3.z : 0));
+                        item.moveFromFloorToWall();
+                        item.placeOnEdge(closestWallEdge);
+                    }
+                }
+                this._moveWallItemToPosition(item, vec3, this.intersectedWall);
+            }
+        }
+    }
+    _moveFloorItemToPosition(item, positionMoveTo) {
+        if (!positionMoveTo) {
+            return;
+        }
+        const collisionInfo = this._collisionManagerService.validatePosition(positionMoveTo, item.rotation, item, this._itemService.getFurniture());
+        if (!item.elevationFixed) {
+            item.elevation = 0;
+        }
+        if (!collisionInfo.valid) {
+            positionMoveTo.y = item.getFloorY();
+            if (collisionInfo.intersectsWall /* && !(item instanceof CustomWallFloorItem)*/) {
+                positionMoveTo = this._slideAtFloor(item, positionMoveTo, item.rotation);
+                this._outlineService.showOutline(item);
+            }
+            else {
+                this._outlineService.showErrorOutline(item);
+            }
+            if (positionMoveTo) {
+                item.position.copy(positionMoveTo);
+            }
+        }
+        else {
+            if (item.canElevate && !item.elevationFixed && collisionInfo.obstructingObjects && collisionInfo.obstructingObjects.length > 0) {
+                item.elevation =
+                    collisionInfo.obstructingObjects[0].halfSize.y * 2 + (collisionInfo.obstructingObjects[0].elevation);
+            }
+            else if (this._settingsService.settings.options.usePlacementSnapping
+            // && (item instanceof Item && (item.canSnapToWall || item.canSnapToObject))
+            ) {
+                this._snappingCollisionService.handleSnapping(item, positionMoveTo);
+            }
+            if (this._viewModeService.viewMode !== ViewMode.InPhotoView) {
+                positionMoveTo.y = item.getFloorY();
+            }
+            this._outlineService.showOutline(item);
+            if (!this._snappingCollisionService.itemHasSnapped()) {
+                item.position.copy(positionMoveTo);
+            }
+            this._hudService.update(true);
+        }
+    }
+    _moveWallItemToPosition(item, positionMoveTo, intersection) {
+        const collisionInfo = item.isValidPosition(positionMoveTo);
+        if (collisionInfo.valid) {
+            this._errorGlowService.hideError();
+            item.moveToPosition(positionMoveTo, intersection);
+        }
+    }
+    _slideAtFloor(item, wantedPosition, wantedRotation) {
+        let collisionInfo;
+        const movedAtX = Utils.moveAtAxis(item.position, wantedRotation, 'x', wantedPosition.x);
+        collisionInfo = this._collisionManagerService.validatePosition(movedAtX, item.rotation, item, this._itemService.getFurniture());
+        if (collisionInfo.valid) {
+            return movedAtX;
+        }
+        const movedAtZ = Utils.moveAtAxis(item.position, wantedRotation, 'z', wantedPosition.z);
+        collisionInfo = this._collisionManagerService.validatePosition(movedAtZ, item.rotation, item, this._itemService.getFurniture());
+        if (collisionInfo.valid) {
+            return movedAtZ;
+        }
+        return null;
+    }
+    _startPinAnimation() {
+        const scale = this._pin.scale.clone().multiplyScalar(1.2);
+        this._pinAnimation = new Tween(this._pin.scale)
+            .to(scale, 300)
+            .repeat(100)
+            .easing(TWEEN.Easing.Quadratic.In)
+            .yoyo(true)
+            .onUpdate(() => {
+            this._sceneService.needsRender = true;
+        });
+        this._pinAnimation.start();
+    }
+}
+DragAndDropService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DragAndDropService, deps: [{ token: i1.SceneService }, { token: i2.ModelsService }, { token: i3.CollisionManagerService }, { token: i4.RoomService }, { token: i5.ErrorGlowService }, { token: i6.OutlineService }, { token: i7.HudService }, { token: i8.MessageBusService }, { token: i9.ItemService }, { token: i10.HomedecoratorSettingsService }, { token: i11.SnappingCollisionService }, { token: i12.ViewModeService }, { token: i13.FloorService }], target: i0.ɵɵFactoryTarget.Injectable });
+DragAndDropService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DragAndDropService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DragAndDropService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SceneService }, { type: i2.ModelsService }, { type: i3.CollisionManagerService }, { type: i4.RoomService }, { type: i5.ErrorGlowService }, { type: i6.OutlineService }, { type: i7.HudService }, { type: i8.MessageBusService }, { type: i9.ItemService }, { type: i10.HomedecoratorSettingsService }, { type: i11.SnappingCollisionService }, { type: i12.ViewModeService }, { type: i13.FloorService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drag-and-drop.service.js","sourceRoot":"","sources":["../../../../../../../src/client/app/plugins/core3d/service/drag-and-drop.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\r\nimport {Euler, Intersection, Mesh, Vector3} from 'three';\r\nimport * as TWEEN from '@tweenjs/tween.js';\r\nimport {Subscription} from 'rxjs';\r\nimport Tween = TWEEN.Tween;\r\nimport {DraggedStatus} from '../model/dragged-status';\r\nimport {DraggedData} from '../interface/dragged-data.interface';\r\nimport {WallItem, WallItemGroup} from '../items/wall-objects';\r\nimport {CustomMesh} from '../items/custom-objects';\r\nimport {ItemGroup} from '../items/item-group';\r\nimport {ItemType} from '../items/item-type';\r\nimport {Item} from '../items/item';\r\nimport {FloorItem} from '../items/floor-item';\r\nimport {isCustomFloorGroupType, isFloorGroupType, isFloorType, isWallFloorType, isWallType,} from '../items/factory';\r\nimport {WallPin} from '../items/wall-pin';\r\nimport {FloorPin} from '../items/floor-pin';\r\nimport {SceneService} from './scene.service';\r\nimport {ModelsService} from './models.service';\r\nimport {CollisionManagerService} from '../collision-manager/collision-manager.service';\r\nimport {RoomService} from '../../room-planner/components/floorplanner/service/room.service';\r\nimport {ErrorGlowService} from './error-glow.service';\r\nimport {OutlineService} from './outline.service';\r\nimport {HudService} from './hud.service';\r\nimport {MessageBusService} from '../../../core/service/message-bus.service';\r\nimport {ItemService} from './item.service';\r\nimport {HomedecoratorSettingsService} from '../../../core/service/homedecorator-settings.service';\r\nimport {SnappingCollisionService} from '../collision-manager/snapping-collision.service';\r\nimport {ViewModeService} from '../../../core/service/view-mode.service';\r\nimport {MessageType} from '../../../core/enum/message-type.enum';\r\nimport {CustomFloorGroupResult} from '../model/custom-floor-group-result';\r\nimport {CustomWallFloorItem} from '../items/custom-wall-floor-item';\r\nimport {CollisionInfo} from '../model/collision-info';\r\nimport {ViewMode} from '../../../core/enum/view-mode.enum';\r\nimport {Utils} from '../core/utils';\r\nimport {Furniture} from '../items/furniture';\r\nimport {FloorService} from './floor.service';\r\nimport {FloorPlaneItem} from '../items/floor-plane-item';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class DragAndDropService implements OnDestroy {\r\n  public draggedStatus: DraggedStatus = new DraggedStatus();\r\n\r\n  public intersectedWall: Intersection;\r\n  public intersectedFloor: Intersection;\r\n\r\n  private _draggedData: DraggedData;\r\n  private _draggedItem: Item | ItemGroup;\r\n  private _pin: WallPin | FloorPin;\r\n  private _pinAnimation: TWEEN;\r\n  private _placedPosition: Vector3;\r\n  private _placedIntersection: Intersection;\r\n  private _dragOffset = new Vector3();\r\n\r\n  private _subs: Subscription[] = [];\r\n\r\n  constructor(private _sceneService: SceneService,\r\n    private _modelsService: ModelsService,\r\n    private _collisionManagerService: CollisionManagerService,\r\n    private _roomService: RoomService,\r\n    private _errorGlowService: ErrorGlowService,\r\n    private _outlineService: OutlineService,\r\n    private _hudService: HudService,\r\n    private _messageBusService: MessageBusService,\r\n    private _itemService: ItemService,\r\n    private _settingsService: HomedecoratorSettingsService,\r\n    private _snappingCollisionService: SnappingCollisionService,\r\n    private _viewModeService: ViewModeService,\r\n    private _floorService: FloorService\r\n  ) {\r\n    this._subs.push(\r\n      this._messageBusService.subscribe(MessageType.UndefinedErrorOccured, () => this._destroyPin())\r\n    );\r\n    window.onbeforeunload = () => this.ngOnDestroy();\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this._subs.forEach(s => s.unsubscribe());\r\n  }\r\n\r\n  public set draggedData(object: DraggedData) {\r\n    this.finishDragging();\r\n    this._draggedData = object;\r\n  }\r\n\r\n  public get draggedData(): DraggedData {\r\n    return this._draggedData;\r\n  }\r\n\r\n  get draggedItem(): Item | ItemGroup {\r\n    return this._draggedItem;\r\n  }\r\n\r\n  set draggedItem(value: Item | ItemGroup) {\r\n    this._draggedItem = value;\r\n  }\r\n\r\n  public async dragModel(point: Vector3, floorIntersect: Intersection): Promise<void> {\r\n    try {\r\n      this._createPin(point, floorIntersect);\r\n      const closestWallEdge =\r\n        this._roomService.getClosestWallEdge((point !== undefined ? point.x : 0), (point !== undefined ? point.z : 0));\r\n      const isDraggedObjectIsFurniture = this.draggedData.iOne;\r\n      if (isDraggedObjectIsFurniture) {\r\n        this.draggedItem = await this._replacePinWithFurniture(this._pin.position);\r\n      } else {\r\n        this.draggedItem = await this._replacePinWithModel(this._pin.position);\r\n      }\r\n      if (this.draggedItem instanceof WallItem && !(isWallFloorType(this.draggedData.type) && floorIntersect)) {\r\n        this.draggedItem.placeOnEdge(closestWallEdge);\r\n      }\r\n      if (this.draggedItem) {\r\n        this._moveItemToPosition(this.draggedItem, this._pin.position);\r\n        this.draggedStatus.objectLoaded();\r\n      } else {\r\n        this.draggedStatus.dragCanceled();\r\n      }\r\n    } catch (err) {\r\n      this.draggedStatus.dragCanceled();\r\n      throw err;\r\n    } finally {\r\n      if (this.draggedStatus.isMarkedToCleanUp) {\r\n        this.finishDragging();\r\n      }\r\n      if (this._pin) {\r\n        this._destroyPin();\r\n      }\r\n    }\r\n  }\r\n\r\n  public async dragFloorDecoration(floorIntersect: Intersection): Promise<void> {\r\n    try {\r\n      if (floorIntersect && floorIntersect.object) {\r\n        const floorPlane: FloorPlaneItem = (floorIntersect.object instanceof FloorPlaneItem ? floorIntersect.object : floorIntersect.object.parent) as FloorPlaneItem;\r\n        this._floorService.highLightFloor(floorPlane);\r\n      } else {\r\n        this._floorService.unHighLightFloors();\r\n      }\r\n    } catch (err) {\r\n      this.draggedStatus.dragCanceled();\r\n      throw err;\r\n    } finally {\r\n      if (this.draggedStatus.isMarkedToCleanUp) {\r\n        this.finishDragging();\r\n      }\r\n    }\r\n  }\r\n\r\n  public updateDraggedPosition(point: Vector3): void {\r\n    if (this.draggedData.type === ItemType.FloorDecoration) {\r\n      this.dragFloorDecoration(this.intersectedFloor);\r\n    } else {\r\n      if (this._pin && this._pin.isActive) {\r\n        if (this.draggedData.type === ItemType.CustomWallFloor &&\r\n          ((this._pin instanceof WallPin && this.intersectedFloor) || (this._pin instanceof FloorPin && this.intersectedWall))) {\r\n          this._createPin(point, this.intersectedFloor);\r\n        }\r\n        this._moveItemToPosition(this._pin, point);\r\n        this.draggedStatus.pinDropped();\r\n      } else if (this.draggedItem) {\r\n        this._moveItemToPosition(this._draggedItem, point);\r\n      }\r\n    }\r\n  }\r\n\r\n  public draggedPlaced(position: Vector3, intersection: Intersection): void {\r\n    this._placedPosition = position;\r\n    this._placedIntersection = intersection;\r\n    if (this.draggedData.type === ItemType.FloorDecoration && this._placedIntersection && this._placedIntersection.object) {\r\n      this._floorService.configureFloor((this._placedIntersection.object instanceof FloorPlaneItem ? this._placedIntersection.object : this._placedIntersection.object.parent) as FloorPlaneItem);\r\n      this._replacePinWithFurniture(this._placedPosition);\r\n    } else {\r\n      if (this._pin && this._pin.isActive) {\r\n        this._startPinAnimation();\r\n      } else {\r\n        this.updateDraggedPosition(this._placedPosition);\r\n      }\r\n    }\r\n    this.draggedStatus.dragDropped();\r\n    this._sceneService.needsRender = true;\r\n  }\r\n\r\n  public finishDragging(): void {\r\n    if (this._pin) {\r\n      this._destroyPin();\r\n    }\r\n    this._draggedData = null;\r\n    this._draggedItem = null;\r\n    this._placedPosition = null;\r\n    this._placedIntersection = null;\r\n    this.draggedStatus.clean();\r\n    this._errorGlowService.hideError();\r\n    this._snappingCollisionService.handleEndOfDragging();\r\n    this._outlineService.hideOutline();\r\n  }\r\n\r\n  public setDragOffset(intersectionPoint: Vector3, sub: boolean = true) {\r\n    this._dragOffset.copy(intersectionPoint);\r\n    if (sub) {\r\n      this._dragOffset.sub(this.draggedItem.position);\r\n    }\r\n  }\r\n\r\n  public clickDragged(intersection: any) {\r\n    const vec3 = intersection.point;\r\n    // if (this.intersectedWall || this.intersectedFloor) {\r\n    //   vec3 = this.intersectedWall ?\r\n    //     this.intersectedWall.point.sub(this._dragOffset) :\r\n    //     this.intersectedFloor.point.sub(this._dragOffset);\r\n    // }\r\n    this._moveItemToPosition(this.draggedItem, vec3.sub(this._dragOffset));\r\n  }\r\n\r\n  public dragConnector(connector: CustomMesh | Mesh, vec3: Vector3) {\r\n    if (this.draggedItem instanceof Item) {\r\n      this.draggedItem.dragConnector(connector, vec3/*.sub(this._dragOffset)*/);\r\n    }\r\n  }\r\n\r\n  public clickReleased() {\r\n    this._errorGlowService.hideError();\r\n    this._snappingCollisionService.handleEndOfDragging();\r\n  }\r\n\r\n  private _createPin(point: Vector3, floorIntersect: Intersection): void {\r\n    if (this._pin) {\r\n      this._destroyPin();\r\n    }\r\n    const closestWallEdge = this._roomService.getClosestWallEdge((point !== undefined ? point.x : 0), (point !== undefined ? point.z : 0));\r\n    if (!this._pin) {\r\n      if (isWallType(this.draggedData.type) || (isWallFloorType(this.draggedData.type) && !floorIntersect)) {\r\n        this._pin = new WallPin();\r\n        this._pin.placeOnEdge(closestWallEdge);\r\n      } else if (isFloorType(this.draggedData.type) || (isWallFloorType(this.draggedData.type) && floorIntersect)) {\r\n        const pointOnTheFloor = this._roomService.getRoomCenter() ? this._roomService.getRoomCenter() : point;\r\n        this._pin = new FloorPin();\r\n        this._moveItemToPosition(this._pin, pointOnTheFloor);\r\n      }\r\n      this._itemService.addItem(this._pin);\r\n    }\r\n    this._pin.activate();\r\n  }\r\n\r\n  private async _replacePinWithFurniture(point: Vector3): Promise<Item> {\r\n    const result: CustomFloorGroupResult = await this.draggedData.constructFn(point);\r\n    return result && result.furniture ? result.furniture : null;\r\n  }\r\n\r\n  private async _replacePinWithModel(point: Vector3): Promise<Item> {\r\n    const model = await this._modelsService.get(this.draggedData.name, this.draggedData.overrides);\r\n    let item: Item;\r\n    if (model) {\r\n      if (isFloorGroupType(model.type) || isCustomFloorGroupType(model.type)) {\r\n        item = await this._itemService.addFloorGroupItem(model, point);\r\n      } else {\r\n        item = await this._itemService.addJsonItem(model, point);\r\n      }\r\n    }\r\n    return item;\r\n  }\r\n\r\n  private _destroyPin(): void {\r\n    if (this._pin instanceof WallItem && this._pin.currentWall) {\r\n      this._pin.currentWall.removeOnItem(this._pin);\r\n    }\r\n    this._itemService.removeItem(this._pin);\r\n    this._pin = null;\r\n    this._pinAnimation = null;\r\n  }\r\n\r\n  private _moveItemToPosition(item: Item | ItemGroup, vec3: Vector3) {\r\n    if (!this._sceneService.arMode) {\r\n      if (item instanceof FloorItem || (item instanceof ItemGroup && !(item instanceof WallItemGroup))\r\n        || (item instanceof CustomWallFloorItem && this.intersectedFloor)) {\r\n        if (item instanceof Item && item.configuring && item.shouldMoveChild) {\r\n          item.moveChildToPosition(vec3);\r\n        } else {\r\n          if (item instanceof CustomWallFloorItem && item.currentWall) {\r\n            item.removeFromWall();\r\n            item.moveFromWallToFloor();\r\n          }\r\n          this._moveFloorItemToPosition(item, vec3);\r\n        }\r\n      } else if (item instanceof WallItem || item instanceof WallItemGroup) {\r\n        if (item instanceof CustomWallFloorItem && this.intersectedWall) {\r\n          if (!item.currentWall) {\r\n            const closestWallEdge =\r\n              this._roomService.getClosestWallEdge((vec3 !== undefined ? vec3.x : 0), (vec3 !== undefined ? vec3.z : 0));\r\n            item.moveFromFloorToWall();\r\n            item.placeOnEdge(closestWallEdge);\r\n          }\r\n        }\r\n        this._moveWallItemToPosition(item, vec3, this.intersectedWall);\r\n      }\r\n    }\r\n  }\r\n\r\n  private _moveFloorItemToPosition(item: Furniture, positionMoveTo: Vector3) {\r\n    if (!positionMoveTo) {\r\n      return;\r\n    }\r\n    const collisionInfo: CollisionInfo =\r\n      this._collisionManagerService.validatePosition(positionMoveTo, item.rotation, item, this._itemService.getFurniture());\r\n    if (!item.elevationFixed) {\r\n      item.elevation = 0;\r\n    }\r\n    if (!collisionInfo.valid) {\r\n      positionMoveTo.y = item.getFloorY();\r\n      if (collisionInfo.intersectsWall/* && !(item instanceof CustomWallFloorItem)*/) {\r\n        positionMoveTo = this._slideAtFloor(item, positionMoveTo, item.rotation);\r\n        this._outlineService.showOutline(item);\r\n      } else {\r\n        this._outlineService.showErrorOutline(item);\r\n      }\r\n      if (positionMoveTo) {\r\n        item.position.copy(positionMoveTo);\r\n      }\r\n    } else {\r\n      if (item.canElevate && !item.elevationFixed && collisionInfo.obstructingObjects && collisionInfo.obstructingObjects.length > 0) {\r\n        item.elevation =\r\n          (collisionInfo.obstructingObjects[0] as any).halfSize.y * 2 + ((collisionInfo.obstructingObjects[0] as any).elevation);\r\n      } else if (this._settingsService.settings.options.usePlacementSnapping\r\n        // && (item instanceof Item && (item.canSnapToWall || item.canSnapToObject))\r\n      ) {\r\n        this._snappingCollisionService.handleSnapping(item, positionMoveTo);\r\n      }\r\n      if (this._viewModeService.viewMode !== ViewMode.InPhotoView) {\r\n        positionMoveTo.y = item.getFloorY();\r\n      }\r\n      this._outlineService.showOutline(item);\r\n      if (!this._snappingCollisionService.itemHasSnapped()) {\r\n        item.position.copy(positionMoveTo);\r\n      }\r\n      this._hudService.update(true);\r\n    }\r\n  }\r\n\r\n  private _moveWallItemToPosition(item: WallItem | WallItemGroup, positionMoveTo: Vector3, intersection?: Intersection) {\r\n    const collisionInfo: CollisionInfo = item.isValidPosition(positionMoveTo);\r\n    if (collisionInfo.valid) {\r\n      this._errorGlowService.hideError();\r\n      item.moveToPosition(positionMoveTo, intersection);\r\n    }\r\n  }\r\n\r\n  private _slideAtFloor(item: Furniture, wantedPosition: Vector3, wantedRotation: Euler): Vector3 {\r\n    let collisionInfo: CollisionInfo;\r\n    const movedAtX = Utils.moveAtAxis(item.position, wantedRotation, 'x', wantedPosition.x);\r\n    collisionInfo = this._collisionManagerService.validatePosition(movedAtX, item.rotation, item, this._itemService.getFurniture());\r\n    if (collisionInfo.valid) {\r\n      return movedAtX;\r\n    }\r\n\r\n    const movedAtZ = Utils.moveAtAxis(item.position, wantedRotation, 'z', wantedPosition.z);\r\n    collisionInfo = this._collisionManagerService.validatePosition(movedAtZ, item.rotation, item, this._itemService.getFurniture());\r\n    if (collisionInfo.valid) {\r\n      return movedAtZ;\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  private _startPinAnimation() {\r\n    const scale = this._pin.scale.clone().multiplyScalar(1.2);\r\n    this._pinAnimation = new Tween(this._pin.scale)\r\n      .to(scale, 300)\r\n      .repeat(100)\r\n      .easing(TWEEN.Easing.Quadratic.In)\r\n      .yoyo(true)\r\n      .onUpdate(() => {\r\n        this._sceneService.needsRender = true;\r\n      });\r\n    this._pinAnimation.start();\r\n  }\r\n\r\n\r\n}\r\n"]}

package/esm2015/app/plugins/core3d/service/error-glow.service.js

@@ -0,0 +1,131 @@
+import { AdditiveBlending, Color, Group, Mesh, MeshBasicMaterial, Object3D } from 'three';
+import { Injectable } from '@angular/core';
+import { CustomShapeFloorItem } from '../items/custom-shape-floor-item';
+import { CustomShapeWallItem } from '../items/custom-shape-wall-item';
+import { CustomCylinderFloorItem } from '../items/custom-cylinder-floor-item';
+import { CustomCylinderWallItem } from '../items/custom-cylinder-wall-item';
+import { Utils } from '../core/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "./scene.service";
+const defaultColor = new Color(0xff0000);
+const defaultOpacity = 0.8;
+const defaultIgnoreDepth = true;
+export class ErrorGlowService {
+    constructor(_sceneService) {
+        this._sceneService = _sceneService;
+    }
+    static _createErrorGlow(item, color = defaultColor, opacity = defaultOpacity, ignoreDepth = defaultIgnoreDepth) {
+        let glow;
+        const glowMaterial = new MeshBasicMaterial({
+            color: color,
+            blending: AdditiveBlending,
+            opacity,
+            transparent: true,
+            depthTest: !ignoreDepth
+        });
+        if (item instanceof Group) {
+            glow = this._cloneGroup(item, glowMaterial);
+        }
+        else {
+            glow = this._cloneItem(item, glowMaterial);
+        }
+        glow.name = `${item.name}-glow`;
+        glow.position.copy(item.position);
+        glow.rotation.copy(item.rotation);
+        glow.scale.copy(item.scale);
+        return glow;
+    }
+    static _cloneItem(source, meshMaterial) {
+        const newItem = this._cloneObject3D(source);
+        if (meshMaterial) {
+            newItem.traverse((child) => {
+                if (child instanceof Mesh) {
+                    child.material = meshMaterial;
+                }
+            });
+        }
+        return newItem;
+    }
+    static _cloneGroup(source, meshMaterial) {
+        const newGroup = this._cloneObject3D(source);
+        if (meshMaterial) {
+            newGroup.traverse((child) => {
+                if (child instanceof Mesh) {
+                    child.material = meshMaterial;
+                }
+            });
+        }
+        return newGroup;
+    }
+    static _cloneObject3D(source) {
+        const newObject = new Object3D();
+        source.children.forEach((child) => {
+            if (!child.visible) {
+                return;
+            }
+            if (child instanceof CustomShapeFloorItem
+                || child instanceof CustomShapeWallItem
+                || child instanceof CustomCylinderFloorItem
+                || child instanceof CustomCylinderWallItem) {
+                const customShapeItem = child.cloneItem();
+                customShapeItem.position.y = 0;
+                newObject.add(customShapeItem);
+            }
+            else if (child instanceof Mesh) {
+                newObject.add(child.clone());
+            }
+            else if (child instanceof Object3D) {
+                const clone = this._cloneObject3D(child);
+                clone.position.copy(child.position);
+                clone.rotation.copy(child.rotation);
+                newObject.add(clone);
+            }
+        });
+        return newObject;
+    }
+    showError(item, position, rotation, parent) {
+        const pos = position || item.position;
+        const rot = rotation || item.rotation;
+        if (this._errorGlow && this._errorGlow.userData.cloneID !== item.uuid) {
+            this._removeErrorGlowObject();
+        }
+        if (parent) {
+            this._parent = parent;
+        }
+        if (!this._errorGlow) {
+            this._errorGlow = ErrorGlowService._createErrorGlow(item);
+            this._errorGlow.userData.cloneID = item.uuid;
+            parent ? parent.add(this._errorGlow) : this._sceneService.addObject(this._errorGlow);
+        }
+        if (this._errorGlow) {
+            this._errorGlow.visible = true;
+            this._errorGlow.position.copy(pos);
+            this._errorGlow.rotation.copy(rot);
+        }
+    }
+    hideError() {
+        if (this._errorGlow) {
+            this._errorGlow.visible = false;
+        }
+    }
+    _removeErrorGlowObject() {
+        if (this._parent) {
+            this._parent.remove(this._errorGlow);
+            Utils.DisposeObject(this._errorGlow);
+            this._parent = null;
+        }
+        else {
+            this._sceneService.removeObject(this._errorGlow);
+        }
+        this._errorGlow = null;
+    }
+}
+ErrorGlowService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ErrorGlowService, deps: [{ token: i1.SceneService }], target: i0.ɵɵFactoryTarget.Injectable });
+ErrorGlowService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ErrorGlowService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ErrorGlowService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SceneService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"error-glow.service.js","sourceRoot":"","sources":["../../../../../../../src/client/app/plugins/core3d/service/error-glow.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {AdditiveBlending, Color, Euler, Group, Mesh, MeshBasicMaterial, Object3D, Vector3} from 'three';\r\nimport {Injectable} from '@angular/core';\r\nimport {SceneService} from './scene.service';\r\nimport {CustomShapeFloorItem} from '../items/custom-shape-floor-item';\r\nimport {CustomShapeWallItem} from '../items/custom-shape-wall-item';\r\nimport {CustomCylinderFloorItem} from '../items/custom-cylinder-floor-item';\r\nimport {CustomCylinderWallItem} from '../items/custom-cylinder-wall-item';\r\nimport {Utils} from '../core/utils';\r\n\r\nconst defaultColor = new Color(0xff0000);\r\nconst defaultOpacity = 0.8;\r\nconst defaultIgnoreDepth = true;\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ErrorGlowService {\r\n\r\n  private _errorGlow: Object3D | Group;\r\n  private _parent: Object3D;\r\n\r\n  constructor(private _sceneService: SceneService) {\r\n  }\r\n\r\n  private static _createErrorGlow(\r\n    item: Object3D, color = defaultColor, opacity = defaultOpacity, ignoreDepth = defaultIgnoreDepth): Object3D | Group {\r\n    let glow: Object3D | Group;\r\n    const glowMaterial = new MeshBasicMaterial({\r\n      color: color,\r\n      blending: AdditiveBlending,\r\n      opacity,\r\n      transparent: true,\r\n      depthTest: !ignoreDepth\r\n    });\r\n\r\n    if (item instanceof Group) {\r\n      glow = this._cloneGroup(item, glowMaterial);\r\n    } else {\r\n      glow = this._cloneItem(item, glowMaterial);\r\n    }\r\n\r\n    glow.name = `${item.name}-glow`;\r\n    glow.position.copy(item.position);\r\n    glow.rotation.copy(item.rotation);\r\n    glow.scale.copy(item.scale);\r\n    return glow;\r\n  }\r\n\r\n  private static _cloneItem(source: Object3D, meshMaterial?: MeshBasicMaterial): Object3D {\r\n    const newItem = this._cloneObject3D(source);\r\n    if (meshMaterial) {\r\n      newItem.traverse((child: any) => {\r\n        if (child instanceof Mesh) {\r\n          child.material = meshMaterial;\r\n        }\r\n      });\r\n    }\r\n    return newItem;\r\n  }\r\n\r\n  private static _cloneGroup(source: Group, meshMaterial?: MeshBasicMaterial): Group {\r\n    const newGroup = <Group>this._cloneObject3D(source);\r\n    if (meshMaterial) {\r\n      newGroup.traverse((child: any) => {\r\n        if (child instanceof Mesh) {\r\n          child.material = meshMaterial;\r\n        }\r\n      });\r\n    }\r\n    return newGroup;\r\n  }\r\n\r\n  private static _cloneObject3D(source: Object3D): Object3D {\r\n    const newObject = new Object3D();\r\n    source.children.forEach((child: any) => {\r\n      if (!child.visible) {\r\n        return;\r\n      }\r\n      if (child instanceof CustomShapeFloorItem\r\n        || child instanceof CustomShapeWallItem\r\n        || child instanceof CustomCylinderFloorItem\r\n        || child instanceof CustomCylinderWallItem ) {\r\n        const customShapeItem = child.cloneItem();\r\n        customShapeItem.position.y = 0;\r\n        newObject.add(customShapeItem);\r\n      } else if (child instanceof Mesh) {\r\n        newObject.add(child.clone());\r\n      } else if (child instanceof Object3D) {\r\n        const clone = this._cloneObject3D(child);\r\n        clone.position.copy(child.position);\r\n        clone.rotation.copy(child.rotation);\r\n        newObject.add(clone);\r\n      }\r\n    });\r\n    return newObject;\r\n  }\r\n\r\n  public showError(item: Object3D, position?: Vector3, rotation?: Euler, parent?: Object3D) {\r\n    const pos = position || item.position;\r\n    const rot = rotation || item.rotation;\r\n\r\n    if (this._errorGlow && this._errorGlow.userData.cloneID !== item.uuid) {\r\n      this._removeErrorGlowObject();\r\n    }\r\n    if (parent) {\r\n      this._parent = parent;\r\n    }\r\n    if (!this._errorGlow) {\r\n      this._errorGlow = ErrorGlowService._createErrorGlow(item);\r\n      this._errorGlow.userData.cloneID = item.uuid;\r\n      parent ? parent.add(this._errorGlow) : this._sceneService.addObject(this._errorGlow);\r\n    }\r\n    if (this._errorGlow) {\r\n      this._errorGlow.visible = true;\r\n      this._errorGlow.position.copy(pos);\r\n      this._errorGlow.rotation.copy(rot);\r\n    }\r\n  }\r\n\r\n  public hideError() {\r\n    if (this._errorGlow) {\r\n      this._errorGlow.visible = false;\r\n    }\r\n  }\r\n\r\n  private _removeErrorGlowObject(): void {\r\n    if (this._parent) {\r\n      this._parent.remove(this._errorGlow);\r\n      Utils.DisposeObject(this._errorGlow);\r\n      this._parent = null;\r\n    } else {\r\n      this._sceneService.removeObject(this._errorGlow);\r\n    }\r\n    this._errorGlow = null;\r\n  }\r\n\r\n}\r\n"]}