@colijnit/homedecorator 255.1.1

package/esm2015/app/homedecorator.module.js

@@ -0,0 +1,60 @@
+import { NgModule } from '@angular/core';
+import { HomedecoratorComponent } from './homedecorator.component';
+import { ServiceLocator } from './service/service-locator.service';
+import { CommonModule } from '@angular/common';
+import { ProgressBarModule } from './shared/progress-bar/progress-bar.module';
+import { LoadingOverlayModule } from './shared/loading-overlay/loading-overlay.module';
+import { HdLoaderModule } from './shared/loader/hd-loader.module';
+import { ExportDialogModule } from './shared/export-dialog/export-dialog.module';
+import { PluginsModule } from './plugins/plugins.module';
+import { InfoDialogModule } from './shared/info-dialog/info-dialog.module';
+import { DialogModule } from './shared/dialog/dialog.module';
+import * as i0 from "@angular/core";
+export class HomedecoratorModule {
+    constructor(_injector) {
+        this._injector = _injector;
+        ServiceLocator.injector = this._injector;
+    }
+}
+HomedecoratorModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: HomedecoratorModule, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.NgModule });
+HomedecoratorModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: HomedecoratorModule, bootstrap: [HomedecoratorComponent], declarations: [HomedecoratorComponent], imports: [CommonModule,
+        ProgressBarModule,
+        LoadingOverlayModule,
+        HdLoaderModule,
+        ExportDialogModule,
+        InfoDialogModule,
+        PluginsModule,
+        DialogModule], exports: [HomedecoratorComponent] });
+HomedecoratorModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: HomedecoratorModule, imports: [[
+            CommonModule,
+            ProgressBarModule,
+            LoadingOverlayModule,
+            HdLoaderModule,
+            ExportDialogModule,
+            InfoDialogModule,
+            PluginsModule,
+            DialogModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: HomedecoratorModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        ProgressBarModule,
+                        LoadingOverlayModule,
+                        HdLoaderModule,
+                        ExportDialogModule,
+                        InfoDialogModule,
+                        PluginsModule,
+                        DialogModule
+                    ],
+                    declarations: [
+                        HomedecoratorComponent
+                    ],
+                    exports: [
+                        HomedecoratorComponent
+                    ],
+                    bootstrap: [HomedecoratorComponent]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,119 @@
+import { Euler, Vector3 } from 'three';
+import { Injectable } from '@angular/core';
+import { validFloorplanPosition } from './floorplan-collision-detection';
+import * as i0 from "@angular/core";
+import * as i1 from "../../room-planner/components/floorplanner/service/floorplan.service";
+import * as i2 from "../service/scene.service";
+import * as i3 from "../service/intersection.service";
+import * as i4 from "../service/floor.service";
+export class CollisionManagerService {
+    constructor(_floorplanService, _sceneService, _intersectionService, _floorService) {
+        this._floorplanService = _floorplanService;
+        this._sceneService = _sceneService;
+        this._intersectionService = _intersectionService;
+        this._floorService = _floorService;
+        this.checkCollisions = true;
+        this._cachedMeshes = {};
+        this._origPosition = new Vector3();
+        this._origRotation = new Euler();
+    }
+    validatePosition(newPosition, newRotation, piece, allFurniture = []) {
+        if (!this.checkCollisions) {
+            return { valid: true };
+        }
+        const otherFurniture = allFurniture.filter(f => f.uuid !== piece.uuid);
+        const floorplanRooms = this._floorplanService.getRooms();
+        const orphanWalls = this._floorplanService.getOrphanWalls();
+        /*
+        for debugging purposes, uncomment to visualize bounding boxes
+         */
+        // if (this._sceneService) {
+        //   const meshes = piece.getVisibleMeshesParents();
+        //   const corners = meshes.map((mesh: Item | CustomMesh) => {
+        //     if (mesh instanceof CustomMesh) {
+        //       if (newPosition) {
+        //         piece.wantsRotation = undefined;
+        //         return mesh.moveBBoxCorners(newPosition);
+        //       }
+        //       if (newRotation) {
+        //         piece.wantsRotation = newRotation;
+        //         return mesh.rotateBBoxCorners(newRotation);
+        //       }
+        //       return mesh.getBBoxCorners();
+        //     } else {
+        //       return mesh.computeBBoxCorners(newPosition, newRotation);
+        //     }
+        //   });
+        //
+        //   const points = (corners as any).flat();
+        //   this._sceneService.removeObject(this.collisionMesh);
+        //   const geo = new BufferGeometry().setFromPoints(points).rotateX(Math.PI / 2);
+        //   // const mat = new MeshBasicMaterial({color: 'blue'});
+        //   // this.collisionMesh = new Mesh(geo, mat);
+        //   const material = new LineBasicMaterial({color: 'blue', linewidth: 5});
+        //   // Create the final object to add to the scene
+        //   this.collisionMesh = new Line(geo, material);
+        //
+        //   this.collisionMesh.name = 'collision-mesh';
+        //   this._sceneService.addObject(this.collisionMesh);
+        // }
+        /* end debugging     */
+        const { valid, intersectsWall, obstructingObjects, noRooms } = validFloorplanPosition(newPosition, newRotation, piece, otherFurniture, floorplanRooms, orphanWalls);
+        if (valid && !obstructingObjects) {
+            return { valid };
+        }
+        else if (valid && obstructingObjects) {
+            return { valid, obstructingObjects };
+        }
+        else if (!valid && intersectsWall) {
+            if (noRooms) {
+                const groundIntersects = this._intersectionService.getIntersections(newPosition, [this._floorService.groundPlane]);
+                if (groundIntersects.length > 0) {
+                    return { valid: true };
+                }
+            }
+            else {
+                return { valid, intersectsWall };
+            }
+        }
+        // const wallPlanes: Mesh[] = this.model.getWallEdgePlanes();
+        this._origPosition.copy(piece.position);
+        this._origRotation.copy(piece.rotation);
+        if (newPosition) {
+            piece.position.copy(newPosition);
+        }
+        if (newRotation) {
+            piece.rotation.copy(newRotation);
+        }
+        piece.updateMatrix();
+        // const collides = rayCollides(piece, obstructingObjects, wallPlanes);
+        // const collides = deepCollides(piece, obstructingObjects, this._cachedMeshes);
+        if (newPosition) {
+            piece.position.copy(this._origPosition);
+        }
+        if (newRotation) {
+            piece.rotation.copy(this._origRotation);
+        }
+        piece.updateMatrix();
+        // TODO: Tidy up caching of positions
+        // if (!collides) {
+        //   if (piece instanceof CustomMesh || piece instanceof Item) {
+        //     this._cachedMeshes[piece.id] = piece.getBBoxCorners();
+        //   } else {
+        //     this._cachedMeshes[piece.id] = null;
+        //   }
+        // }
+        //
+        // return { valid: !collides };
+        return { valid: !obstructingObjects };
+    }
+}
+CollisionManagerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CollisionManagerService, deps: [{ token: i1.FloorplanService }, { token: i2.SceneService }, { token: i3.IntersectionService }, { token: i4.FloorService }], target: i0.ɵɵFactoryTarget.Injectable });
+CollisionManagerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CollisionManagerService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CollisionManagerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.FloorplanService }, { type: i2.SceneService }, { type: i3.IntersectionService }, { type: i4.FloorService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collision-manager.service.js","sourceRoot":"","sources":["../../../../../../../src/client/app/plugins/core3d/collision-manager/collision-manager.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Euler, Line, Vector3} from 'three';\r\nimport {Injectable} from '@angular/core';\r\nimport {validFloorplanPosition} from './floorplan-collision-detection';\r\nimport {FloorplanService} from '../../room-planner/components/floorplanner/service/floorplan.service';\r\nimport {SceneService} from '../service/scene.service';\r\nimport {IntersectionService} from '../service/intersection.service';\r\nimport {FloorService} from '../service/floor.service';\r\nimport {Furniture} from '../items/furniture';\r\nimport {CollisionInfo} from '../model/collision-info';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class CollisionManagerService {\r\n\r\n  public checkCollisions: boolean = true;\r\n  public collisionMesh: Line;\r\n\r\n  private _cachedMeshes: object = {};\r\n  private _origPosition = new Vector3();\r\n  private _origRotation = new Euler();\r\n\r\n  constructor(\r\n    private _floorplanService: FloorplanService,\r\n    private _sceneService: SceneService,\r\n    private _intersectionService: IntersectionService,\r\n    private _floorService: FloorService\r\n  ) {\r\n  }\r\n\r\n  public validatePosition(\r\n    newPosition: Vector3,\r\n    newRotation: Euler,\r\n    piece: Furniture,\r\n    allFurniture: Furniture[] = []\r\n  ): CollisionInfo {\r\n    if (!this.checkCollisions) {\r\n      return {valid: true};\r\n    }\r\n    const otherFurniture: Furniture[] = allFurniture.filter(f => f.uuid !== piece.uuid);\r\n    const floorplanRooms = this._floorplanService.getRooms();\r\n    const orphanWalls = this._floorplanService.getOrphanWalls();\r\n\r\n    /*\r\n    for debugging purposes, uncomment to visualize bounding boxes\r\n     */\r\n    // if (this._sceneService) {\r\n    //   const meshes = piece.getVisibleMeshesParents();\r\n    //   const corners = meshes.map((mesh: Item | CustomMesh) => {\r\n    //     if (mesh instanceof CustomMesh) {\r\n    //       if (newPosition) {\r\n    //         piece.wantsRotation = undefined;\r\n    //         return mesh.moveBBoxCorners(newPosition);\r\n    //       }\r\n    //       if (newRotation) {\r\n    //         piece.wantsRotation = newRotation;\r\n    //         return mesh.rotateBBoxCorners(newRotation);\r\n    //       }\r\n    //       return mesh.getBBoxCorners();\r\n    //     } else {\r\n    //       return mesh.computeBBoxCorners(newPosition, newRotation);\r\n    //     }\r\n    //   });\r\n    //\r\n    //   const points = (corners as any).flat();\r\n    //   this._sceneService.removeObject(this.collisionMesh);\r\n    //   const geo = new BufferGeometry().setFromPoints(points).rotateX(Math.PI / 2);\r\n    //   // const mat = new MeshBasicMaterial({color: 'blue'});\r\n    //   // this.collisionMesh = new Mesh(geo, mat);\r\n    //   const material = new LineBasicMaterial({color: 'blue', linewidth: 5});\r\n    //   // Create the final object to add to the scene\r\n    //   this.collisionMesh = new Line(geo, material);\r\n    //\r\n    //   this.collisionMesh.name = 'collision-mesh';\r\n    //   this._sceneService.addObject(this.collisionMesh);\r\n    // }\r\n    /* end debugging     */\r\n\r\n    const {valid, intersectsWall, obstructingObjects, noRooms} = validFloorplanPosition(\r\n      newPosition, newRotation, piece, otherFurniture, floorplanRooms, orphanWalls\r\n    );\r\n    if (valid && !obstructingObjects) {\r\n      return {valid};\r\n    } else if (valid && obstructingObjects) {\r\n      return {valid, obstructingObjects};\r\n    } else if (!valid && intersectsWall) {\r\n      if (noRooms) {\r\n        const groundIntersects = this._intersectionService.getIntersections(newPosition, [this._floorService.groundPlane]);\r\n        if (groundIntersects.length > 0) {\r\n          return {valid: true};\r\n        }\r\n      } else {\r\n        return {valid, intersectsWall};\r\n      }\r\n    }\r\n\r\n    // const wallPlanes: Mesh[] = this.model.getWallEdgePlanes();\r\n    this._origPosition.copy(piece.position);\r\n    this._origRotation.copy(piece.rotation);\r\n\r\n    if (newPosition) {\r\n      piece.position.copy(newPosition);\r\n    }\r\n    if (newRotation) {\r\n      piece.rotation.copy(newRotation);\r\n    }\r\n    piece.updateMatrix();\r\n\r\n    // const collides = rayCollides(piece, obstructingObjects, wallPlanes);\r\n    // const collides = deepCollides(piece, obstructingObjects, this._cachedMeshes);\r\n\r\n    if (newPosition) {\r\n      piece.position.copy(this._origPosition);\r\n    }\r\n    if (newRotation) {\r\n      piece.rotation.copy(this._origRotation);\r\n    }\r\n    piece.updateMatrix();\r\n\r\n    // TODO: Tidy up caching of positions\r\n    // if (!collides) {\r\n    //   if (piece instanceof CustomMesh || piece instanceof Item) {\r\n    //     this._cachedMeshes[piece.id] = piece.getBBoxCorners();\r\n    //   } else {\r\n    //     this._cachedMeshes[piece.id] = null;\r\n    //   }\r\n    // }\r\n    //\r\n    // return { valid: !collides };\r\n    return {valid: !obstructingObjects};\r\n  }\r\n}\r\n"]}

package/esm2015/app/plugins/core3d/collision-manager/floorplan-collision-detection.js

@@ -0,0 +1,158 @@
+import { Vector2 } from 'three';
+import { CustomMesh } from '../items/custom-objects';
+import { ItemGroup } from '../items/item-group';
+import { Utils } from '../core/utils';
+// checks if given corners of mesh are inside a room
+function meshInRoom(corners, rooms) {
+    let insideRoom = false;
+    for (let i = 0; i < rooms.length; i++) {
+        const room = rooms[i];
+        const interiorCorners = room.getInteriorCorners();
+        if (Utils.polygonInsidePolygon(corners, interiorCorners)) {
+            insideRoom = true;
+        }
+    }
+    return insideRoom;
+}
+// returns list of rooms an item defined by corners belongs to
+function roomsContainingMesh(meshPosition, rooms) {
+    return rooms.reduce((belongsTo, room) => {
+        const interiorCorners = room.getInteriorCorners();
+        if (Utils.pointInPolygon(meshPosition.x, meshPosition.z, interiorCorners)) {
+            return belongsTo.concat(room);
+        }
+        return belongsTo;
+    }, []);
+}
+function edgeIsObstructingMesh(meshCorners, edge) {
+    const edgeCorners = edge.corners().map(corner => {
+        return new Vector2(corner.x, corner.y);
+    });
+    for (const mCorners of meshCorners) {
+        if (Utils.polygonPolygonIntersect(mCorners, edgeCorners)) {
+            return true;
+        }
+    }
+    return false;
+}
+function objectsObstructingMesh(meshGroup, meshCorners, objects) {
+    return objects.reduce((obstructing, object) => {
+        if (object !== meshGroup && object.obstructFloorMoves) {
+            const children = object.getVisibleMeshesParents();
+            for (let i = 0; i < children.length; i++) {
+                const child = children[i];
+                const childCorners = child.getBBoxCorners();
+                const isInside = Utils.polygonInsidePolygon(meshCorners, childCorners) ||
+                    Utils.polygonInsidePolygon(childCorners, meshCorners);
+                if (isInside || Utils.polygonPolygonIntersect(meshCorners, childCorners)) {
+                    obstructing.push(object);
+                    break; // already found obstruction, so might as well break
+                }
+            }
+        }
+        return obstructing;
+    }, []);
+}
+function includeItemGroupAsItems(objects) {
+    const result = [];
+    for (let i = 0; i < objects.length; i++) {
+        if (objects[i] instanceof ItemGroup) {
+            objects[i].children.forEach(child => result.push(child));
+        }
+        else {
+            result.push(objects[i]);
+        }
+    }
+    return result;
+}
+function uniqueCorners(value, index, self) {
+    return self.indexOf(value) === index;
+}
+export function validFloorplanPosition(newPosition, newRotation, meshGroup, objects = [], floorplanRooms, orphanWalls) {
+    // if there is no room, then there's possibly some imported room (glb)
+    if (floorplanRooms.length === 0) {
+        return { valid: false, noRooms: true };
+    }
+    const meshes = meshGroup.getVisibleMeshesParents();
+    let corners = meshes.map((mesh) => {
+        if (mesh instanceof CustomMesh) {
+            if (newPosition) {
+                meshGroup.wantsRotation = undefined;
+                return mesh.moveBBoxCorners(newPosition);
+            }
+            if (newRotation) {
+                meshGroup.wantsRotation = newRotation;
+                return mesh.rotateBBoxCorners(newRotation);
+            }
+            return mesh.getBBoxCorners();
+        }
+        else {
+            return mesh.computeBBoxCorners(newPosition, newRotation);
+        }
+    });
+    // remove duplicates
+    corners = corners.filter((v, i, a) => a.findIndex(f => JSON.stringify(f) === JSON.stringify(v)) === i);
+    // ensure that every mesh is inside a room
+    let inRoom = true;
+    for (let i = 0; i < corners.length; i++) {
+        if (!meshInRoom(corners[i], floorplanRooms)) {
+            inRoom = false;
+            break; // mesh is placed out of room, get out
+        }
+    }
+    if (!inRoom) {
+        return { valid: false, intersectsWall: true };
+    }
+    const inRooms = meshes.reduce((rooms, mesh) => {
+        return rooms.concat(roomsContainingMesh(mesh.localAnchor(newPosition), floorplanRooms));
+    }, []);
+    // check whether mesh intersects inner rooms walls
+    const maxRoomArea = inRooms.reduce((max, room) => Math.max(max, room.area), 0);
+    const accountedRooms = floorplanRooms.filter(room => room.area <= maxRoomArea);
+    for (const room of accountedRooms) {
+        for (const meshCorners of corners) {
+            if (Utils.polygonPolygonIntersect(room.getInteriorCorners(), meshCorners)) {
+                return { valid: false, intersectsWall: true };
+            }
+        }
+    }
+    // check whether mesh intersects any inner walls
+    for (const wall of orphanWalls) {
+        if ((wall.frontEdge && edgeIsObstructingMesh(corners, wall.frontEdge)) ||
+            (wall.backEdge && edgeIsObstructingMesh(corners, wall.backEdge))) {
+            return { valid: false, intersectsWall: true };
+        }
+    }
+    // check whether other objects get in the way
+    if (typeof meshGroup.obstructFloorMoves === 'boolean' && meshGroup.obstructFloorMoves === false) {
+        objects = [];
+    }
+    else {
+        objects = includeItemGroupAsItems(objects).filter((item) => item !== meshGroup && item.obstructFloorMoves);
+    }
+    if (!objects.length) {
+        return { valid: true };
+    }
+    // check whether there are any other objects obstructing mesh
+    // const obstructing = meshes.reduce((o, mesh, index) =>
+    //   o.concat(objectsObstructingMesh(meshGroup, corners[index], objects)), []);
+    const obstructing = [];
+    for (let i = 0; i < corners.length; i++) {
+        const obstructingMeshes = objectsObstructingMesh(meshGroup, corners[i], objects);
+        if (obstructingMeshes.length > 0) {
+            for (let j = 0; j < obstructingMeshes.length; j++) {
+                if (obstructing.indexOf(obstructingMeshes[j]) < 0) {
+                    obstructing.push(obstructingMeshes[j]);
+                }
+            }
+        }
+    }
+    return obstructing.length
+        ? (obstructing.length === 1
+            ? (meshGroup.canElevate && obstructing[0].stackable ?
+                { valid: true, obstructingObjects: obstructing } :
+                { valid: false, obstructingObjects: obstructing })
+            : { valid: false, obstructingObjects: obstructing })
+        : { valid: true };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"floorplan-collision-detection.js","sourceRoot":"","sources":["../../../../../../../src/client/app/plugins/core3d/collision-manager/floorplan-collision-detection.ts"],"names":[],"mappings":"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","sourcesContent":["import {Euler, Vector2, Vector3} from 'three';\r\nimport {HalfEdge, Room, Wall} from '../items/wall-objects';\r\nimport {CustomMesh} from '../items/custom-objects';\r\nimport {Item} from '../items/item';\r\nimport {ItemGroup} from '../items/item-group';\r\nimport {Utils} from '../core/utils';\r\nimport {Furniture} from '../items/furniture';\r\n\r\n// checks if given corners of mesh are inside a room\r\nfunction meshInRoom(corners: Vector2[], rooms: Room[]): boolean {\r\n  let insideRoom: boolean = false;\r\n  for (let i = 0; i < rooms.length; i++) {\r\n    const room: Room = rooms[i];\r\n    const interiorCorners = room.getInteriorCorners();\r\n    if (Utils.polygonInsidePolygon(corners, interiorCorners)) {\r\n      insideRoom = true;\r\n    }\r\n  }\r\n  return insideRoom;\r\n}\r\n\r\n// returns list of rooms an item defined by corners belongs to\r\nfunction roomsContainingMesh(meshPosition: Vector3, rooms: Room[]): Room[] {\r\n  return rooms.reduce((belongsTo: Room[], room: Room): Room[] => {\r\n    const interiorCorners = room.getInteriorCorners();\r\n    if (Utils.pointInPolygon(meshPosition.x, meshPosition.z, interiorCorners)) {\r\n      return belongsTo.concat(room);\r\n    }\r\n    return belongsTo;\r\n  }, []);\r\n}\r\n\r\nfunction edgeIsObstructingMesh(meshCorners: Vector2[][], edge: HalfEdge): boolean {\r\n  const edgeCorners = edge.corners().map(corner => {\r\n    return new Vector2(corner.x, corner.y);\r\n  });\r\n\r\n  for (const mCorners of meshCorners) {\r\n    if (Utils.polygonPolygonIntersect(mCorners, edgeCorners)) {\r\n      return true;\r\n    }\r\n  }\r\n\r\n  return false;\r\n}\r\n\r\nfunction objectsObstructingMesh(meshGroup, meshCorners, objects): Furniture[] {\r\n  return objects.reduce((obstructing, object) => {\r\n    if (object !== meshGroup && object.obstructFloorMoves) {\r\n      const children = object.getVisibleMeshesParents();\r\n      for (let i: number = 0; i < children.length; i++) {\r\n        const child: Item | CustomMesh = children[i];\r\n        const childCorners = child.getBBoxCorners();\r\n        const isInside\r\n          = Utils.polygonInsidePolygon(meshCorners, childCorners) ||\r\n            Utils.polygonInsidePolygon(childCorners, meshCorners);\r\n        if (isInside || Utils.polygonPolygonIntersect(meshCorners, childCorners)) {\r\n          obstructing.push(object);\r\n          break; // already found obstruction, so might as well break\r\n        }\r\n      }\r\n    }\r\n    return obstructing;\r\n  }, []);\r\n}\r\n\r\nfunction includeItemGroupAsItems(objects): Furniture[] {\r\n  const result: Furniture[] = [];\r\n  for (let i = 0; i < objects.length; i++) {\r\n    if (objects[i] instanceof ItemGroup) {\r\n      objects[i].children.forEach(child => result.push(child));\r\n    } else {\r\n      result.push(objects[i]);\r\n    }\r\n  }\r\n  return result;\r\n}\r\n\r\nfunction uniqueCorners(value, index, self) {\r\n  return self.indexOf(value) === index;\r\n}\r\n\r\nexport function validFloorplanPosition(\r\n  newPosition: Vector3,\r\n  newRotation: Euler,\r\n  meshGroup: Furniture,\r\n  objects: Furniture[] = [],\r\n  floorplanRooms: Room[],\r\n  orphanWalls: Wall[]\r\n): {\r\n  valid: boolean,\r\n  intersectsWall?: boolean,\r\n  obstructingObjects?: Furniture[],\r\n  noRooms?: boolean\r\n} {\r\n  // if there is no room, then there's possibly some imported room (glb)\r\n  if (floorplanRooms.length === 0) {\r\n    return { valid: false, noRooms: true };\r\n  }\r\n\r\n  const meshes = meshGroup.getVisibleMeshesParents();\r\n  let corners = meshes.map((mesh: Item | CustomMesh) => {\r\n    if (mesh instanceof CustomMesh) {\r\n      if (newPosition) {\r\n        meshGroup.wantsRotation = undefined;\r\n        return mesh.moveBBoxCorners(newPosition);\r\n      }\r\n      if (newRotation) {\r\n        meshGroup.wantsRotation = newRotation;\r\n        return mesh.rotateBBoxCorners(newRotation);\r\n      }\r\n      return mesh.getBBoxCorners();\r\n    } else {\r\n      return mesh.computeBBoxCorners(newPosition, newRotation);\r\n    }\r\n  });\r\n  // remove duplicates\r\n  corners = corners.filter((v, i, a) => a.findIndex(f => JSON.stringify(f) === JSON.stringify(v)) === i);\r\n\r\n  // ensure that every mesh is inside a room\r\n  let inRoom: boolean = true;\r\n  for (let i = 0; i < corners.length; i++) {\r\n    if (!meshInRoom(corners[i], floorplanRooms)) {\r\n      inRoom = false;\r\n      break; // mesh is placed out of room, get out\r\n    }\r\n  }\r\n  if (!inRoom) {\r\n    return { valid: false, intersectsWall: true };\r\n  }\r\n\r\n  const inRooms = meshes.reduce((rooms, mesh: Item | CustomMesh) => {\r\n    return rooms.concat(\r\n      roomsContainingMesh(mesh.localAnchor(newPosition), floorplanRooms)\r\n    );\r\n  }, []);\r\n\r\n  // check whether mesh intersects inner rooms walls\r\n  const maxRoomArea = inRooms.reduce((max, room) => Math.max(max, room.area), 0);\r\n  const accountedRooms = floorplanRooms.filter(room => room.area <= maxRoomArea);\r\n  for (const room of accountedRooms) {\r\n    for (const meshCorners of corners) {\r\n      if (Utils.polygonPolygonIntersect(room.getInteriorCorners(), meshCorners)) {\r\n        return { valid: false, intersectsWall: true };\r\n      }\r\n    }\r\n  }\r\n\r\n  // check whether mesh intersects any inner walls\r\n  for (const wall of orphanWalls) {\r\n    if (\r\n      (wall.frontEdge && edgeIsObstructingMesh(corners, wall.frontEdge)) ||\r\n      (wall.backEdge && edgeIsObstructingMesh(corners, wall.backEdge))\r\n    ) {\r\n      return { valid: false, intersectsWall: true };\r\n    }\r\n  }\r\n\r\n  // check whether other objects get in the way\r\n  if (typeof meshGroup.obstructFloorMoves === 'boolean' && meshGroup.obstructFloorMoves === false) {\r\n    objects = [];\r\n  } else {\r\n    objects = includeItemGroupAsItems(objects).filter((item: Furniture) =>\r\n      item !== meshGroup && item.obstructFloorMoves);\r\n  }\r\n  if (!objects.length) {\r\n    return { valid: true };\r\n  }\r\n\r\n  // check whether there are any other objects obstructing mesh\r\n  // const obstructing = meshes.reduce((o, mesh, index) =>\r\n  //   o.concat(objectsObstructingMesh(meshGroup, corners[index], objects)), []);\r\n  const obstructing = [];\r\n  for (let i = 0; i < corners.length; i++) {\r\n    const obstructingMeshes: Furniture[] = objectsObstructingMesh(meshGroup, corners[i], objects);\r\n    if (obstructingMeshes.length > 0) {\r\n      for (let j = 0; j < obstructingMeshes.length; j++) {\r\n        if (obstructing.indexOf(obstructingMeshes[j]) < 0) {\r\n          obstructing.push(obstructingMeshes[j]);\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  return obstructing.length\r\n    ? (obstructing.length === 1\r\n      ? (meshGroup.canElevate && obstructing[0].stackable ?\r\n        { valid: true, obstructingObjects: obstructing } :\r\n        { valid: false, obstructingObjects: obstructing})\r\n      : { valid: false, obstructingObjects: obstructing })\r\n    : { valid: true };\r\n}\r\n"]}