@colijnit/homedecorator 255.1.1

package/esm2015/app/plugins/core3d/items/wall-objects.js

@@ -0,0 +1,2381 @@
+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 { BoxGeometry, BufferAttribute, BufferGeometry, Color, DoubleSide, Matrix4, Mesh, MeshBasicMaterial, MeshPhysicalMaterial, Path, Quaternion, Shape, ShapeGeometry, SRGBColorSpace, Vector2, Vector3 } from 'three';
+import * as THREE from 'three';
+import { sameTextures } from '../../../core/model/texture';
+import { Item } from './item';
+import { Utils } from '../core/utils';
+import { defaultEdgeColor, defaultWallColor } from '../../room-planner/components/floorplanner/const/defaults';
+import { ThreeMesh } from './three-mesh';
+import { isNill } from '../../../core/utils/function/is-nill.function';
+import { TextureType } from '../../../core/model/texture-type';
+import { MaterialUtils } from '../../../core/utils/material.utils';
+import { ItemType } from './item-type';
+import * as Geometry from '../model/geometry';
+import { ItemGroup } from './item-group';
+/**
+ * A Wall is the basic element to create Rooms.
+ *
+ * Walls consists of two half edges.
+ */
+export class Wall {
+    /**
+     * Constructs a new wall.
+     * @param start Start corner.
+     * @param end End corner.
+     */
+    constructor(start, end) {
+        this.start = start;
+        this.end = end;
+        /** Front is the plane from start to end. */
+        this.frontEdge = null;
+        /** Back is the plane from end to start. */
+        this.backEdge = null;
+        /** */
+        this.orphan = false;
+        /** Items attached to this wall */
+        this.items = [];
+        this.itemsChanged = false;
+        /** */
+        this.onItems = [];
+        /** The front-side color. */
+        this.frontColor = defaultWallColor;
+        /** The back-side color. */
+        this.backColor = defaultWallColor;
+        this.id = this.getUuid();
+        this.start.attachStart(this);
+        this.end.attachEnd(this);
+    }
+    set height(value) {
+        this._height = value;
+        if (this.frontEdge) {
+            this.frontEdge.height = this._height;
+        }
+        if (this.backEdge) {
+            this.backEdge.height = this._height;
+        }
+        this.items.forEach((item) => item.reposition());
+        this.onItems.forEach((item) => item.reposition());
+    }
+    get height() {
+        return this._height;
+    }
+    getUuid() {
+        return [this.start.id, this.end.id].join();
+    }
+    showHideWall(show) {
+        if (this.frontEdge) {
+            this.frontEdge.showHideEdge(show);
+        }
+        if (this.backEdge) {
+            this.backEdge.showHideEdge(show);
+        }
+    }
+    resetFrontBack() {
+        if (this.frontEdge) {
+            this.frontEdge.disposePlane();
+        }
+        if (this.backEdge) {
+            this.backEdge.disposePlane();
+        }
+        this.frontEdge = null;
+        this.backEdge = null;
+        this.orphan = false;
+    }
+    move(x, y) {
+        if (!this.amountWallMoved) {
+            this.amountWallMoved = new Vector2();
+        }
+        const diffX = this.end.x - this.start.x;
+        const diffY = this.end.y - this.start.y;
+        const prevStartX = this.start.x;
+        const prevStartY = this.start.y;
+        this.start.move(x, y);
+        this.end.move(x + diffX, y + diffY);
+        this.amountWallMoved.add(new Vector2(this.start.x - prevStartX, this.start.y - prevStartY));
+    }
+    relativeMove(dx, dy) {
+        this.start.relativeMove(dx, dy);
+        this.end.relativeMove(dx, dy);
+    }
+    fireRedraw() {
+        if (this.frontEdge) {
+            this.frontEdge.redraw();
+        }
+        if (this.backEdge) {
+            this.backEdge.redraw();
+        }
+    }
+    getStart() {
+        return this.start;
+    }
+    getEnd() {
+        return this.end;
+    }
+    getStartX() {
+        return this.start.getX();
+    }
+    getEndX() {
+        return this.end.getX();
+    }
+    getStartY() {
+        return this.start.getY();
+    }
+    getEndY() {
+        return this.end.getY();
+    }
+    remove() {
+        this.start.detachWall(this);
+        this.end.detachWall(this);
+        this.frontTexture = undefined;
+        this.backTexture = undefined;
+    }
+    setStart(corner) {
+        this.start.detachWall(this);
+        corner.attachStart(this);
+        this.start = corner;
+    }
+    setEnd(corner) {
+        this.end.detachWall(this);
+        corner.attachEnd(this);
+        this.end = corner;
+    }
+    distanceFrom(x, y) {
+        return Utils.pointDistanceFromLine(x, y, this.getStartX(), this.getStartY(), this.getEndX(), this.getEndY());
+    }
+    closestPointTo(x, y) {
+        return Utils.closestPointOnLine(x, y, this.getStartX(), this.getStartY(), this.getEndX(), this.getEndY());
+    }
+    isToOrFrom(x, y) {
+        return (this.getStartX() === x && this.getStartY() === y) ||
+            (this.getEndX() === x && this.getEndY() === y);
+    }
+    /** Return the corner opposite of the one provided.
+     * @param corner The given corner.
+     * @returns The opposite corner.
+     */
+    _oppositeCorner(corner) {
+        if (this.start === corner) {
+            return this.end;
+        }
+        else if (this.end === corner) {
+            return this.start;
+        }
+        else {
+            console.log('Wall does not connect to corner');
+        }
+    }
+    get length() {
+        return Utils.distance(this.getStartX(), this.getStartY(), this.getEndX(), this.getEndY());
+    }
+    get edgesLengths() {
+        const lengths = [];
+        if (this.frontEdge) {
+            lengths.push(this.frontEdge.interiorDistance());
+        }
+        if (this.backEdge) {
+            lengths.push(this.backEdge.interiorDistance());
+        }
+        return lengths;
+    }
+    updateInWallItems() {
+        this.items.filter(item => item instanceof InWallItem).forEach((item) => item.onWallUpdated(this));
+    }
+    updateWallItems() {
+        this.items.filter(item => item instanceof WallItem).forEach((item) => item.onWallMoved(this));
+        this.onItems.filter(item => item instanceof WallItem || item instanceof WallItemGroup).forEach((item) => item.onWallMoved(this));
+        this.amountWallMoved = undefined;
+    }
+    getItems() {
+        return this.items;
+    }
+    getWallItems() {
+        return this.items.filter(item => item instanceof WallItem);
+    }
+    get side() {
+        if (this.frontEdge && this.backEdge) {
+            return THREE.DoubleSide;
+        }
+        else if (this.frontEdge) {
+            return THREE.FrontSide;
+        }
+        else if (this.backEdge) {
+            return THREE.BackSide;
+        }
+    }
+    addItem(item) {
+        this.items.push(item);
+        this.itemsChanged = true;
+    }
+    removeItem(item) {
+        this.items = this.items.filter(i => i !== item);
+        this.itemsChanged = true;
+    }
+    addOnItem(item) {
+        this.onItems.push(item);
+        this.itemsChanged = true;
+    }
+    removeOnItem(item) {
+        this.onItems = this.onItems.filter(i => i !== item);
+        this.itemsChanged = true;
+    }
+}
+/**
+ * Corners are used to define Walls.
+ */
+export class Corner {
+    /** Constructs a corner.
+     * @param x X coordinate.
+     * @param y Y coordinate.
+     * @param id An optional unique id. If not set, created internally.
+     */
+    constructor(x, y, id) {
+        this.x = x;
+        this.y = y;
+        this.id = id;
+        /** Array of start walls. */
+        this.wallStarts = [];
+        /** Array of end walls. */
+        this.wallEnds = [];
+        this.id = id || Utils.guid();
+    }
+    absorbWallsFrom(corner) {
+        for (let i = corner.wallStarts.length - 1; i >= 0; i--) {
+            corner.wallStarts[i].setStart(this);
+        }
+        for (let i = corner.wallEnds.length - 1; i >= 0; i--) {
+            corner.wallEnds[i].setEnd(this);
+        }
+    }
+    /**
+     * @returns
+     * @deprecated
+     */
+    getX() {
+        return this.x;
+    }
+    /**
+     * @returns
+     * @deprecated
+     */
+    getY() {
+        return this.y;
+    }
+    /** Moves corner relatively to new position.
+     * @param dx The delta x.
+     * @param dy The delta y.
+     */
+    relativeMove(dx, dy) {
+        this.move(this.x + dx, this.y + dy);
+    }
+    /** Removes all walls. */
+    removeAll() {
+        for (let i = 0; i < this.wallStarts.length; i++) {
+            this.wallStarts[i].remove();
+        }
+        for (let i = 0; i < this.wallEnds.length; i++) {
+            this.wallEnds[i].remove();
+        }
+    }
+    /** Moves corner to new position.
+     * @param newX The new x position.
+     * @param newY The new y position.
+     */
+    move(newX, newY) {
+        this.x = newX;
+        this.y = newY;
+    }
+    /** Gets the adjacent corners.
+     * @returns Array of corners.
+     */
+    adjacentCorners() {
+        const retArray = [];
+        for (let i = 0; i < this.wallStarts.length; i++) {
+            retArray.push(this.wallStarts[i].getEnd());
+        }
+        for (let i = 0; i < this.wallEnds.length; i++) {
+            retArray.push(this.wallEnds[i].getStart());
+        }
+        return retArray;
+    }
+    /** Checks if a wall is connected.
+     * @param wall A wall.
+     * @returns True in case of connection.
+     */
+    isWallConnected(wall) {
+        for (let i = 0; i < this.wallStarts.length; i++) {
+            if (this.wallStarts[i] === wall) {
+                return true;
+            }
+        }
+        for (let i = 0; i < this.wallEnds.length; i++) {
+            if (this.wallEnds[i] === wall) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     *
+     */
+    distanceFrom(x, y) {
+        const distance = Utils.distance(x, y, this.x, this.y);
+        return distance;
+    }
+    /** Gets the distance from a wall.
+     * @param wall A wall.
+     * @returns The distance.
+     */
+    distanceFromWall(wall) {
+        return wall.distanceFrom(this.x, this.y);
+    }
+    /** Gets the distance from a corner.
+     * @param corner A corner.
+     * @returns The distance.
+     */
+    distanceFromCorner(corner) {
+        return this.distanceFrom(corner.x, corner.y);
+    }
+    /** Detaches a wall.
+     * @param wall A wall.
+     */
+    detachWall(wall) {
+        Utils.removeValue(this.wallStarts, wall);
+        Utils.removeValue(this.wallEnds, wall);
+    }
+    /** Attaches a start wall.
+     * @param wall A wall.
+     */
+    attachStart(wall) {
+        this.wallStarts.push(wall);
+    }
+    /** Attaches an end wall.
+     * @param wall A wall.
+     */
+    attachEnd(wall) {
+        this.wallEnds.push(wall);
+    }
+    /** Get wall to corner.
+     * @param corner A corner.
+     * @return The associated wall or null.
+     */
+    wallTo(corner) {
+        for (let i = 0; i < this.wallStarts.length; i++) {
+            if (this.wallStarts[i].getEnd() === corner) {
+                return this.wallStarts[i];
+            }
+        }
+        return null;
+    }
+    /** Get wall from corner.
+     * @param corner A corner.
+     * @return The associated wall or null.
+     */
+    wallFrom(corner) {
+        for (let i = 0; i < this.wallEnds.length; i++) {
+            if (this.wallEnds[i].getStart() === corner) {
+                return this.wallEnds[i];
+            }
+        }
+        return null;
+    }
+    /** Get wall to or from corner.
+     * @param corner A corner.
+     * @return The associated wall or null.
+     */
+    wallToOrFrom(corner) {
+        return this.wallTo(corner) || this.wallFrom(corner);
+    }
+    get startWalls() {
+        return this.wallStarts;
+    }
+    get endWalls() {
+        return this.wallEnds;
+    }
+    /** Ensure we do not have duplicate walls (i.e. same start and end points) */
+    removeDuplicateWalls() {
+        // delete the wall between these corners, if it exists
+        const wallEndpoints = {};
+        const wallStartpoints = {};
+        for (let i = this.wallStarts.length - 1; i >= 0; i--) {
+            if (this.wallStarts[i].getEnd() === this) {
+                // remove zero length wall
+                this.wallStarts[i].remove();
+            }
+            else if (this.wallStarts[i].getEnd().id in wallEndpoints) {
+                // remove duplicated wall
+                this.wallStarts[i].remove();
+            }
+            else {
+                wallEndpoints[this.wallStarts[i].getEnd().id] = true;
+            }
+        }
+        for (let i = this.wallEnds.length - 1; i >= 0; i--) {
+            if (this.wallEnds[i].getStart() === this) {
+                // removed zero length wall
+                this.wallEnds[i].remove();
+            }
+            else if (this.wallEnds[i].getStart().id in wallStartpoints) {
+                // removed duplicated wall
+                this.wallEnds[i].remove();
+            }
+            else {
+                wallStartpoints[this.wallEnds[i].getStart().id] = true;
+            }
+        }
+        // find and remove cycle ~ more than a single wall between 2 corners
+        for (const outWall of this.wallStarts) {
+            for (const inWall of this.wallEnds) {
+                if (outWall.getEnd() === inWall.getStart()) {
+                    outWall.remove();
+                }
+            }
+        }
+    }
+}
+/**
+ * Half Edges are created by Room.
+ *
+ * Once rooms have been identified, Half Edges are created for each interior wall.
+ *
+ * A wall can have two half edges if it is visible from both sides.
+ */
+export class HalfEdge {
+    /**
+     * Constructs a half edge.
+     * @param room The associated room.
+     * @param wall The corresponding wall.
+     * @param front True if front side.
+     */
+    constructor(room, wall, front) {
+        this.room = room;
+        this.wall = wall;
+        this.front = front;
+        /** used for intersection testing... not convinced this belongs here */
+        this.plane = null;
+        /** transform from world coords to wall planes (z=0) */
+        this.interiorTransform = new Matrix4();
+        /** transform from world coords to wall planes (z=0) */
+        this.invInteriorTransform = new Matrix4();
+        /** transform from world coords to wall planes (z=0) */
+        this.exteriorTransform = new Matrix4();
+        /** transform from world coords to wall planes (z=0) */
+        this.invExteriorTransform = new Matrix4();
+        /** */
+        this.edges = [];
+        this.front = front || false;
+        this.offset = wall.thickness / 2.0;
+        this.height = wall.height;
+        if (this.front) {
+            this.wall.frontEdge = this;
+        }
+        else {
+            this.wall.backEdge = this;
+        }
+        this.wall.updateInWallItems();
+    }
+    /** When height of walls are modified, plane should be recreated */
+    set height(value) {
+        this._height = value;
+        this.disposePlane();
+        this.generatePlane();
+    }
+    get height() {
+        return this._height;
+    }
+    showHideEdge(show) {
+        this.edges.forEach(e => e.showHideEdge(show));
+    }
+    updateVisibility(cameraPosition) {
+        let visibilityChanged = null;
+        this.edges.forEach(e => {
+            const edgeVisibilityChanged = e.updateVisibility(cameraPosition);
+            if (edgeVisibilityChanged !== null) {
+                visibilityChanged = edgeVisibilityChanged;
+            }
+        });
+        return visibilityChanged;
+    }
+    updateVisiblity(visibility) {
+        this.edges.forEach(e => {
+            e.visible = visibility;
+            e.updateObjectVisibility();
+            e.setAllPlanesVisible();
+        });
+    }
+    redraw() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // this.edges.forEach(e => e.redraw());
+            for (let i = 0; i < this.edges.length; i++) {
+                yield this.edges[i].redraw();
+            }
+        });
+    }
+    /**
+     *
+     */
+    getTexture() {
+        if (this.front) {
+            return this.wall.frontTexture;
+        }
+        else {
+            return this.wall.backTexture;
+        }
+    }
+    getColor() {
+        if (this.front) {
+            return this.wall.frontColor;
+        }
+        else {
+            return this.wall.backColor;
+        }
+    }
+    /**
+     *
+     */
+    setTexture(texture) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (texture) {
+                texture.roughness = !isNill(texture.roughness) ? texture.roughness : 0.8;
+            }
+            if (this.front) {
+                this.wall.frontTexture = texture;
+                this.wall.frontColor = defaultWallColor;
+            }
+            else {
+                this.wall.backTexture = texture;
+                this.wall.backColor = defaultWallColor;
+            }
+            // this.redrawCallbacks.fire();
+            yield this.redraw();
+        });
+    }
+    setColor(value) {
+        if (this.front) {
+            this.wall.frontTexture = null;
+            this.wall.frontColor = value;
+        }
+        else {
+            this.wall.backTexture = null;
+            this.wall.backColor = value;
+        }
+        // this.redrawCallbacks.fire();
+        this.redraw();
+    }
+    /**
+     * this feels hacky, but need wall items
+     */
+    generatePlane() {
+        function transformCorner(corner) {
+            return new Vector3(corner.x, 0, corner.y);
+        }
+        this.offset = this.wall.thickness / 2.0;
+        this._height = this.wall.height;
+        const v1 = transformCorner(this.interiorStart());
+        const v2 = transformCorner(this.interiorEnd());
+        const v3 = v2.clone();
+        v3.y = this.wall.height;
+        const v4 = v1.clone();
+        v4.y = this.wall.height;
+        const geometry = new BufferGeometry().setFromPoints([v1, v2, v3, v4]);
+        const faceVertexIndexArray = new Uint16Array([0, 1, 2, 0, 2, 3]);
+        const faceBufferAttribute = new BufferAttribute(faceVertexIndexArray, 1);
+        geometry.setIndex(faceBufferAttribute);
+        geometry.computeVertexNormals();
+        geometry.computeBoundingBox();
+        this.plane = new ThreeMesh(geometry, new MeshPhysicalMaterial(null));
+        this.plane.name = `half-edge-plane-${this.front ? 'front' : 'back'}`;
+        this.plane.castShadow = true;
+        Utils.setPlaneVisibility(this.plane, true);
+        this.plane.userData.edge = this;
+        this.computeTransforms(this.interiorTransform, this.invInteriorTransform, this.interiorStart(), this.interiorEnd());
+        this.computeTransforms(this.exteriorTransform, this.invExteriorTransform, this.exteriorStart(), this.exteriorEnd());
+    }
+    disposePlane() {
+        if (this.plane) {
+            Utils.DisposeObject(this.plane);
+            this.plane = null;
+        }
+    }
+    interiorDistance() {
+        const start = this.interiorStart();
+        const end = this.interiorEnd();
+        return Utils.distance(start.x, start.y, end.x, end.y);
+    }
+    computeTransforms(transform, invTransform, start, end) {
+        const v1 = start;
+        const v2 = end;
+        const angle = Utils.angle(1, 0, v2.x - v1.x, v2.y - v1.y);
+        const tt = new Matrix4();
+        tt.makeTranslation(-v1.x, 0, -v1.y);
+        const tr = new Matrix4();
+        tr.makeRotationY(-angle);
+        transform.multiplyMatrices(tr, tt);
+        invTransform.copy(transform).invert();
+    }
+    /** Gets the distance from specified point.
+     * @param x X coordinate of the point.
+     * @param y Y coordinate of the point.
+     * @returns The distance.
+     */
+    distanceTo(x, y) {
+        // x, y, x1, y1, x2, y2
+        return Utils.pointDistanceFromLine(x, y, this.interiorStart().x, this.interiorStart().y, this.interiorEnd().x, this.interiorEnd().y);
+    }
+    getStart() {
+        if (this.front) {
+            return this.wall.getStart();
+        }
+        else {
+            return this.wall.getEnd();
+        }
+    }
+    getEnd() {
+        if (this.front) {
+            return this.wall.getEnd();
+        }
+        else {
+            return this.wall.getStart();
+        }
+    }
+    getOppositeEdge() {
+        if (this.front) {
+            return this.wall.backEdge;
+        }
+        else {
+            return this.wall.frontEdge;
+        }
+    }
+    // these return an object with attributes x, y
+    interiorEnd() {
+        const vec = this.halfAngleVector(this, this.next);
+        return new Vector2(this.getEnd().x + vec.x, this.getEnd().y + vec.y);
+    }
+    interiorStart() {
+        const vec = this.halfAngleVector(this.prev, this);
+        return new Vector2(this.getStart().x + vec.x, this.getStart().y + vec.y);
+    }
+    interiorCenter() {
+        return new Vector2((this.interiorStart().x + this.interiorEnd().x) / 2.0, (this.interiorStart().y + this.interiorEnd().y) / 2.0);
+    }
+    exteriorEnd() {
+        const vec = this.halfAngleVector(this, this.next);
+        return new Vector2(this.getEnd().x - vec.x, this.getEnd().y - vec.y);
+    }
+    exteriorStart() {
+        const vec = this.halfAngleVector(this.prev, this);
+        return new Vector2(this.getStart().x - vec.x, this.getStart().y - vec.y);
+    }
+    /** Get the corners of the half edge.
+     * @returns An array of x,y pairs.
+     */
+    corners() {
+        return [this.interiorStart(), this.interiorEnd(),
+            this.exteriorEnd(), this.exteriorStart()];
+    }
+    /**
+     * Gets CCW angle from v1 to v2
+     */
+    halfAngleVector(v1, v2) {
+        // make the best of things if we dont have prev or next
+        let v1startX;
+        let v1startY;
+        let v1endX;
+        let v1endY;
+        let v2startX;
+        let v2startY;
+        let v2endX;
+        let v2endY;
+        if (!v1) {
+            v1startX = v2.getStart().x - (v2.getEnd().x - v2.getStart().x);
+            v1startY = v2.getStart().y - (v2.getEnd().y - v2.getStart().y);
+            v1endX = v2.getStart().x;
+            v1endY = v2.getStart().y;
+        }
+        else {
+            v1startX = v1.getStart().x;
+            v1startY = v1.getStart().y;
+            v1endX = v1.getEnd().x;
+            v1endY = v1.getEnd().y;
+        }
+        if (!v2) {
+            v2startX = v1.getEnd().x;
+            v2startY = v1.getEnd().y;
+            v2endX = v1.getEnd().x + (v1.getEnd().x - v1.getStart().x);
+            v2endY = v1.getEnd().y + (v1.getEnd().y - v1.getStart().y);
+        }
+        else {
+            v2startX = v2.getStart().x;
+            v2startY = v2.getStart().y;
+            v2endX = v2.getEnd().x;
+            v2endY = v2.getEnd().y;
+        }
+        // CCW angle between edges
+        const theta = Utils.angle2pi(v1startX - v1endX, v1startY - v1endY, v2endX - v1endX, v2endY - v1endY);
+        // cosine and sine of half angle
+        const cs = Math.cos(theta / 2.0);
+        const sn = Math.sin(theta / 2.0);
+        // rotate v2
+        const v2dx = v2endX - v2startX;
+        const v2dy = v2endY - v2startY;
+        const vx = v2dx * cs - v2dy * sn;
+        const vy = v2dx * sn + v2dy * cs;
+        // normalize
+        const mag = Utils.distance(0, 0, vx, vy);
+        const desiredMag = (this.offset) / sn;
+        const scalar = desiredMag / mag;
+        return new Vector2(vx * scalar, vy * scalar);
+    }
+    get invExteriorQuaternion() {
+        const quaternion = new Quaternion();
+        quaternion.setFromRotationMatrix(this.invExteriorTransform);
+        return quaternion;
+    }
+}
+export class Edge {
+    constructor(_halfEdge) {
+        this._halfEdge = _halfEdge;
+        this._fillerColor = new Color(0xdddddd);
+        this._planes = {
+            exterior: null,
+            interior: null,
+            sides: null,
+            bottom: null,
+            top: null
+        };
+        this._last = {
+            color: null,
+            texture: null,
+            fillerMaterial: null,
+            wallMaterial: null,
+            height: null
+        };
+        if (_halfEdge) {
+            this._wall = _halfEdge.wall;
+            this._front = _halfEdge.front;
+            // this.updatePlanes();
+        }
+    }
+    showHideEdge(show) {
+        this._planeList().forEach(p => p.visible = show);
+    }
+    _planeList() {
+        return (this._planes.sides || []).concat([
+            this._planes.top,
+            this._planes.bottom,
+            this._planes.interior,
+            this._planes.exterior
+        ]).filter(x => x);
+    }
+    getPlanes() {
+        return this._planeList();
+    }
+    getTopSideFillers() {
+        return this._planes.sides.concat([this._planes.top]);
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // this.halfEdge.redrawCallbacks.add(this.redraw);
+            // halfEdge.itemAddedCallbacks.add(updateObjectVisibility);
+            // controls.cameraMovedCallbacks.add(updateVisibility);
+            yield this.updatePlanes();
+            // addToScene();
+        });
+    }
+    redraw() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.updatePlanes();
+        });
+    }
+    // private removeFromScene() {
+    //   this.planeList().forEach((plane) => {
+    //     scene.remove(plane);
+    //     Utils.disposeObject(plane);
+    //   });
+    //   Object.keys(planes).forEach((key: string) => planes[key] = null);
+    //   Object.keys(last).forEach((key: string) => last[key] = null);
+    // }
+    // private addToScene() {
+    //   planeList().forEach((plane) => {
+    //     scene.add(plane);
+    //   });
+    //   updateVisibility();
+    // }
+    updateVisibility(cameraPosition) {
+        // finds the normal from the specified halfEdge
+        const start = this._halfEdge.interiorStart();
+        const end = this._halfEdge.interiorEnd();
+        const x = end.x - start.x;
+        const y = end.y - start.y;
+        // rotate 90 degrees CCW
+        const normal = new Vector3(-y, 0, x);
+        normal.normalize();
+        // setup camera
+        const position = cameraPosition.clone();
+        const focus = new Vector3((start.x + end.x) / 2.0, 0, (start.y + end.y) / 2.0);
+        const direction = position.sub(focus).normalize();
+        // find dot
+        const dot = normal.dot(direction);
+        // update visible
+        const newVisible = (dot >= 0);
+        // show or hide plans
+        this._planeList().forEach((plane) => Utils.setPlaneVisibility(plane, newVisible));
+        if (newVisible !== this.visible) {
+            this.visible = newVisible;
+            this.updateObjectVisibility();
+            return newVisible;
+        }
+        else {
+            return null;
+        }
+    }
+    updateObjectVisibility() {
+        this._wall.items.forEach((item) => {
+            item.updateEdgeVisibility(this);
+        });
+        this._wall.onItems.forEach((item) => {
+            item.updateEdgeVisibility(this);
+        });
+    }
+    setAllPlanesVisible() {
+        this._planeList().forEach((plane) => Utils.setPlaneVisibility(plane, true));
+    }
+    _addMaterialMap(material, texture) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dimensions = new THREE.Vector2(this._halfEdge.interiorDistance(), this._wall.height - this._wall.thickness);
+            texture.dimensions = dimensions.multiplyScalar(100);
+            switch (texture.type) {
+                case TextureType.Image:
+                    material.map = yield MaterialUtils.FromImage(texture);
+                    material.map.colorSpace = SRGBColorSpace;
+                    material.needsUpdate = true;
+                    break;
+                case TextureType.CustomPattern:
+                    material.map = yield MaterialUtils.CustomTileMapTexture(texture, dimensions);
+                    material.map.colorSpace = SRGBColorSpace;
+                    material.needsUpdate = true;
+                    break;
+                case TextureType.Basic:
+                    material.map = yield MaterialUtils.FromUrl(texture.url, texture.stretch, texture.tileSize, null, null, texture.dimensions, texture.tileRotation);
+                    material.map.colorSpace = SRGBColorSpace;
+                    material.needsUpdate = true;
+                    break;
+                case TextureType.PBR:
+                    material = material;
+                    if (texture.materializeUrl) {
+                        yield MaterialUtils.loadMaterializeMaps(material, texture);
+                    }
+                    else {
+                        material.map = yield MaterialUtils.FromUrl(texture.url, texture.stretch, texture.tileSize, texture.repeatX, texture.repeatY, texture.dimensions, texture.tileRotation);
+                        material.map.colorSpace = SRGBColorSpace;
+                        material.roughnessMap = texture.roughnessMap ? yield MaterialUtils.FromUrl(texture.roughnessMap, texture.stretch, texture.tileSize, texture.repeatX, texture.repeatY, texture.dimensions, texture.tileRotation) : null;
+                        material.bumpMap = texture.bumpMap ? yield MaterialUtils.FromUrl(texture.bumpMap, texture.stretch, texture.tileSize, texture.repeatX, texture.repeatY, texture.dimensions, texture.tileRotation) : null;
+                        material.normalMap = texture.normalMap ? yield MaterialUtils.FromUrl(texture.normalMap, texture.stretch, texture.tileSize, texture.repeatX, texture.repeatY, texture.dimensions, texture.tileRotation) : null;
+                        material.metalnessMap = texture.metalnessMap ? yield MaterialUtils.FromUrl(texture.metalnessMap, texture.stretch, texture.tileSize, texture.repeatX, texture.repeatY, texture.dimensions, texture.tileRotation) : null;
+                        material.aoMap = texture.aoMap ? yield MaterialUtils.FromUrl(texture.aoMap, texture.stretch, texture.tileSize, texture.repeatX, texture.repeatY, texture.dimensions, texture.tileRotation) : null;
+                        material.needsUpdate = true;
+                    }
+            }
+        });
+    }
+    _isValid(startEnd) {
+        return !startEnd.find(e => !isFinite(e.x) || !isFinite(e.y));
+    }
+    _updateFillerMaterial() {
+        if (this._fillerMaterial) {
+            return this._fillerMaterial;
+        }
+        const material = new MeshBasicMaterial({
+            color: this._fillerColor,
+            side: DoubleSide
+        });
+        return material;
+    }
+    _updateWallMaterial(texture, color = defaultEdgeColor) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isSameColor = color && this._last.color && color === this._last.color;
+            const isSameTexture = sameTextures(texture, this._last.texture);
+            if (isSameColor && isSameTexture) {
+                return this._wallMaterial;
+            }
+            if (!isSameColor) {
+                this._last.color = color;
+            }
+            if (!isSameTexture) {
+                this._last.texture = Object.assign({}, texture);
+            }
+            let material;
+            material = new THREE.MeshPhongMaterial({
+                color: color,
+                side: THREE.FrontSide
+            });
+            if (texture) {
+                material = new THREE.MeshStandardMaterial({
+                    color: color,
+                    side: THREE.FrontSide,
+                    roughness: !isNill(texture.roughness) ? texture.roughness : 0.8,
+                    metalness: !isNill(texture.metalness) ? texture.metalness : 0,
+                    bumpScale: !isNill(texture.bumpScale) ? texture.bumpScale : 1
+                });
+                yield this._addMaterialMap(material, texture);
+            }
+            return material;
+        });
+    }
+    _equalLastVec2(plane, paramSuffix) {
+        const paramName = `${plane}${paramSuffix}`;
+        const getter = this._halfEdge[paramName]();
+        return this._last[paramName] &&
+            this._halfEdge[paramName] &&
+            this._last[paramName].x === getter.x &&
+            this._last[paramName].y === getter.y;
+    }
+    _copyLast(plane, params) {
+        params.forEach((param) => {
+            const paramName = param === 'InvTransform' ?
+                this._invTransformParam(plane) :
+                `${plane}${param}`;
+            const current = 'function' === typeof this._halfEdge[paramName] ?
+                this._halfEdge[paramName]() : this._halfEdge[paramName];
+            this._last[paramName] = current;
+        });
+    }
+    _transformParam(plane) {
+        return `${plane}Transform`;
+    }
+    _invTransformParam(plane) {
+        return `inv${plane.charAt(0).toUpperCase()}${plane.substr(1)}Transform`;
+    }
+    _updateMainPlane(plane, material) {
+        let updatePlane = this._planes[plane];
+        const geo = this._createGeometry(this._halfEdge[`${plane}Start`](), this._halfEdge[`${plane}End`](), this._halfEdge[this._transformParam(plane)], this._halfEdge[this._invTransformParam(plane)]);
+        if (!updatePlane) {
+            updatePlane = new ThreeMesh(geo, material);
+            updatePlane.name = 'edge';
+            updatePlane.userData.wall = this._wall;
+            updatePlane.castShadow = true;
+            updatePlane.receiveShadow = true;
+        }
+        else {
+            updatePlane.geometry = geo;
+            updatePlane.material = material;
+            updatePlane.material.needsUpdate = true;
+        } /* else {
+      updatePlane = this.makeWall(
+        this.halfEdge[`${plane}Start`](),
+        this.halfEdge[`${plane}End`](),
+        this.halfEdge[this.transformParam(plane)],
+        this.halfEdge[this.invTransformParam(plane)],
+        material
+      );
+    }*/
+        return updatePlane;
+        // const oldPlane = this.planes[plane];
+        // const newPlane = this.makeWall(
+        //   this.halfEdge[`${plane}Start`](),
+        //   this.halfEdge[`${plane}End`](),
+        //   this.halfEdge[this.transformParam(plane)],
+        //   this.halfEdge[this.invTransformParam(plane)],
+        //   material
+        // );
+        // if (oldPlane) {
+        //   // scene.remove(oldPlane);
+        //   Utils.disposeObject(oldPlane);
+        // }
+        // // scene.add(newPlane);
+        // return newPlane;
+    }
+    _updateBottomPlane() {
+        const oldPlane = this._planes.bottom;
+        if (oldPlane &&
+            this._equalLastVec2('interior', 'Start') &&
+            this._equalLastVec2('interior', 'End') &&
+            this._equalLastVec2('exterior', 'Start') &&
+            this._equalLastVec2('exterior', 'End')) {
+            return oldPlane;
+        }
+        const newPlane = this._buildFiller(0, this._fillerMaterial);
+        if (oldPlane) {
+            // Dispose function does not actually remove the object from the scene
+            Utils.DisposeObject(oldPlane);
+            oldPlane.visible = false;
+        }
+        // scene.add(newPlane);
+        return newPlane;
+    }
+    _updateTopPlane() {
+        const oldPlane = this._planes.top;
+        if (oldPlane &&
+            this._last.height === this._wall.height &&
+            this._equalLastVec2('interior', 'Start') &&
+            this._equalLastVec2('interior', 'End') &&
+            this._equalLastVec2('exterior', 'Start') &&
+            this._equalLastVec2('exterior', 'End')) {
+            return oldPlane;
+        }
+        if (oldPlane) {
+            // Dispose function does not actually remove the object from the scene
+            Utils.DisposeObject(oldPlane);
+            oldPlane.visible = false;
+        }
+        const newPlane = this._buildFiller(this._wall.height, this._fillerMaterial);
+        // scene.add(newPlane);
+        return newPlane;
+    }
+    _updateSidePlanes() {
+        const oldPlanes = this._planes.sides;
+        if (oldPlanes &&
+            this._last.height === this._wall.height &&
+            this._equalLastVec2('interior', 'Start') &&
+            this._equalLastVec2('interior', 'End') &&
+            this._equalLastVec2('exterior', 'Start') &&
+            this._equalLastVec2('exterior', 'End')) {
+            return oldPlanes;
+        }
+        const newPlanes = [
+            this._buildSideFiller(this._halfEdge.interiorStart(), this._halfEdge.exteriorStart(), this._wall.height, this._fillerMaterial),
+            this._buildSideFiller(this._halfEdge.interiorEnd(), this._halfEdge.exteriorEnd(), this._wall.height, this._fillerMaterial)
+        ];
+        if (oldPlanes) {
+            oldPlanes.forEach(p => {
+                // Dispose function does not actually remove the object from the scene
+                Utils.DisposeObject(p);
+                p.visible = false;
+            });
+        }
+        // newPlanes.forEach(p => scene.add(p));
+        return newPlanes;
+    }
+    updatePlanes() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._fillerMaterial = this._updateFillerMaterial();
+            if (this._isValid([this._halfEdge.exteriorStart(), this._halfEdge.exteriorEnd()])) {
+                this._planes.exterior = this._updateMainPlane('exterior', this._fillerMaterial);
+                if (this._halfEdge.getTexture() && this._halfEdge.getTexture().type !== TextureType.Image) {
+                    this._updateUvs(this._planes.exterior);
+                }
+            }
+            const oldWallMaterial = this._wallMaterial;
+            this._wallMaterial = yield this._updateWallMaterial(this._halfEdge.getTexture(), this._halfEdge.getColor());
+            if (this._isValid([this._halfEdge.interiorStart(), this._halfEdge.interiorEnd()])) {
+                // this.planes.interior = (!oldWallMaterial || oldWallMaterial === this.wallMaterial)
+                //   ? this.updateMainPlane('interior', this.wallMaterial)
+                //   : this.updateMainPlaneMaterial('interior', this.wallMaterial);
+                this._planes.interior = this._updateMainPlane('interior', this._wallMaterial);
+                if (this._halfEdge.getTexture() && this._halfEdge.getTexture().type !== TextureType.Image) {
+                    this._updateUvs(this._planes.interior);
+                }
+            }
+            this._planes.bottom = this._updateBottomPlane();
+            this._planes.top = this._updateTopPlane();
+            this._planes.sides = this._updateSidePlanes();
+            this._last.fillerMaterial = this._fillerMaterial;
+            this._last.wallMaterial = this._wallMaterial;
+            this._last.height = this._wall.height;
+            this._copyLast('exterior', ['Start', 'End', 'Transform', 'InvTransform']);
+            this._copyLast('interior', ['Start', 'End', 'Transform', 'InvTransform']);
+        });
+    }
+    _updateUvs(mesh) {
+        const dimensions = new THREE.Vector2(this._halfEdge.interiorDistance(), this._wall.height - this._wall.thickness).multiplyScalar(100);
+        const ratio = dimensions.x / dimensions.y;
+        let uvY;
+        const tempVector = new Vector2();
+        const uvArray = mesh.geometry.attributes.uv;
+        if (uvArray) {
+            for (let i = 0; i < uvArray.count; i++) {
+                tempVector.fromBufferAttribute(uvArray, i);
+                uvY = tempVector.y;
+                uvY -= 0.5;
+                uvY /= ratio;
+                uvY += 0.5;
+                uvArray.setY(i, uvY);
+            }
+            uvArray.needsUpdate = true;
+        }
+    }
+    // start, end have x and y attributes (i.e. corners)
+    _createGeometry(start, end, transform, invTransform) {
+        const v1 = this._toVec3(start);
+        const v2 = this._toVec3(end);
+        const v3 = v2.clone();
+        v3.y = this._wall.height;
+        const v4 = v1.clone();
+        v4.y = this._wall.height;
+        const points = [v1.clone(), v2.clone(), v3.clone(), v4.clone()];
+        points.forEach((p) => {
+            p.applyMatrix4(transform);
+        });
+        const shape = new Shape([
+            new Vector2(points[0].x, points[0].y),
+            new Vector2(points[1].x, points[1].y),
+            new Vector2(points[2].x, points[2].y),
+            new Vector2(points[3].x, points[3].y)
+        ]);
+        // add holes for each wall item
+        const itemHoles = this._wall.items
+            .filter((item) => !isNaN(item.position.x))
+            .map((item) => {
+            const pos = item.position.clone();
+            pos.applyMatrix4(transform);
+            const halfSize = item.halfSize;
+            const min = halfSize.clone().multiplyScalar(-1);
+            const max = halfSize.clone();
+            min.add(pos);
+            max.add(pos);
+            const holePoints = [
+                new Vector2(min.x, min.y),
+                new Vector2(max.x, min.y),
+                new Vector2(max.x, max.y),
+                new Vector2(min.x, max.y)
+            ];
+            return holePoints;
+        });
+        const polygons = Utils.polygonsUnion(itemHoles);
+        polygons.forEach(holePolygon => shape.holes.push(new Path(holePolygon)));
+        const geometry = new ShapeGeometry(shape);
+        const positionAttribute = geometry.getAttribute('position');
+        const uvAttribute = geometry.getAttribute('uv');
+        Utils.ApplyBufferAttributeMatrixTransform(positionAttribute, invTransform);
+        // make UVs
+        const totalDistance = Utils.distance(v1.x, v1.z, v2.x, v2.z);
+        const height = this._wall.height;
+        function vertexToUv(vertex) {
+            const x = Utils.distance(v1.x, v1.z, vertex.x, vertex.z) / totalDistance;
+            const y = vertex.y / height;
+            return new THREE.Vector2(x, y);
+        }
+        const tempUVArray = [];
+        const positionDataAsVector3Array = Utils.GetVector3ArrayFromBufferAttribute(positionAttribute.clone());
+        positionDataAsVector3Array.forEach((vertex) => {
+            tempUVArray.push(vertexToUv(vertex));
+        });
+        tempUVArray.forEach((uvVector, index) => {
+            uvAttribute.setXY(index, uvVector.x, uvVector.y);
+        });
+        uvAttribute.needsUpdate = true;
+        geometry.computeVertexNormals();
+        return geometry;
+    }
+    _buildSideFiller(p1, p2, height, material) {
+        const points = [
+            this._toVec3(p1),
+            this._toVec3(p2),
+            this._toVec3(p2, height),
+            this._toVec3(p1, height)
+        ];
+        const geometry = new BufferGeometry().setFromPoints(points);
+        const filler = new Mesh(geometry, material);
+        filler.castShadow = true;
+        filler.receiveShadow = true;
+        filler.name = 'edge-side-filler';
+        return filler;
+    }
+    _buildFiller(height, material) {
+        const points = [
+            this._toVec2(this._halfEdge.exteriorStart()),
+            this._toVec2(this._halfEdge.exteriorEnd()),
+            this._toVec2(this._halfEdge.interiorEnd()),
+            this._toVec2(this._halfEdge.interiorStart())
+        ];
+        const shape = new Shape(points);
+        const geometry = new ShapeGeometry(shape);
+        const filler = new Mesh(geometry, material);
+        filler.name = 'edge-filler';
+        filler.castShadow = true;
+        filler.receiveShadow = true;
+        filler.rotation.set(Math.PI / 2, 0, 0);
+        filler.position.y = height;
+        return filler;
+    }
+    _toVec2(pos) {
+        return new Vector2(pos.x, pos.y);
+    }
+    _toVec3(pos, height = 0) {
+        return new Vector3(pos.x, height, pos.y);
+    }
+}
+export class Room {
+    // private floorChangeCallbacks = $.Callbacks();
+    constructor(corners, defaultTexture) {
+        this.corners = corners;
+        this.interiorCorners = [];
+        this.edgePointer = null;
+        this.edgeHeights = [];
+        this.floorPlane = null;
+        this.floorColor = 0xcccccc;
+        this.ceilingPlane = null;
+        if (defaultTexture) {
+            this.floorTexture = defaultTexture;
+        }
+        this._setEdgePointer();
+        this._updateInteriorCorners();
+    }
+    dispose() {
+        Utils.DisposeObject(this.floorPlane);
+        Utils.DisposeObject(this.ceilingPlane);
+    }
+    getInteriorCorners() {
+        return this.interiorCorners.map((c) => new Vector2(c.x, c.y));
+    }
+    getUuid() {
+        const cornerUuids = Utils.map(this.corners, function (c) {
+            return c.id;
+        });
+        cornerUuids.sort();
+        return cornerUuids.join();
+    }
+    getTexture() {
+        // const uuid = this.getUuid();
+        // return this.floorplan.getFloorTexture(uuid);
+        return this.floorTexture;
+    }
+    getColor() {
+        // const uuid = this.getUuid();
+        // return this.floorplan.getFloorColor(uuid) || defaultFloorColor;
+        return this.floorColor;
+    }
+    useTexture() {
+        // return defaultFloorColor === this.getColor();
+    }
+    /**
+     * textureStretch always true, just an argument for consistency with walls
+     */
+    // public setTexture(texture: Texture) {
+    //   // const uuid = this.getUuid();
+    //   // this.floorplan.setFloorTexture(uuid, texture);
+    //   // this.floorplan.deleteFloorColor(uuid);
+    //   // this.floorChangeCallbacks.fire();
+    // }
+    // public setColor(color: number) {
+    //   // const uuid = this.getUuid();
+    //   // this.floorplan.deleteFloorTexture(uuid);
+    //   // this.floorplan.setFloorColor(uuid, color);
+    //   // this.floorChangeCallbacks.fire();
+    // }
+    updateWallHeights() {
+        let edge = this.edgePointer;
+        this.edgeHeights.length = 0;
+        while (true) {
+            this.edgeHeights.push(edge.wall.height);
+            if (edge.next === this.edgePointer) {
+                break;
+            }
+            else {
+                edge = edge.next;
+            }
+        }
+    }
+    setDefaultFloorTexture() {
+        // if (!this._defaultFloorTexture) {
+        //   return;
+        // }
+        // const uuid = this.getUuid();
+        // if (!this.floorplan.getFloorTexture(uuid) && !this.floorplan.getFloorColor(uuid)) {
+        //   this.setTexture(this._defaultFloorTexture);
+        // }
+    }
+    _updateInteriorCorners() {
+        let edge = this.edgePointer;
+        this.edgeHeights.length = 0;
+        while (true) {
+            this.interiorCorners.push(edge.interiorStart());
+            edge.generatePlane();
+            this.edgeHeights.push(edge.height);
+            if (edge.next === this.edgePointer) {
+                break;
+            }
+            else {
+                edge = edge.next;
+            }
+        }
+    }
+    _setEdgePointer() {
+        let prevEdge = null;
+        let firstEdge = null;
+        for (let i = 0; i < this.corners.length; i++) {
+            const firstCorner = this.corners[i];
+            const secondCorner = this.corners[(i + 1) % this.corners.length];
+            // find if wall is heading in that direction
+            const wallTo = firstCorner.wallTo(secondCorner);
+            const wallFrom = firstCorner.wallFrom(secondCorner);
+            let edge;
+            if (wallTo) {
+                edge = new HalfEdge(this, wallTo, true);
+            }
+            else if (wallFrom) {
+                edge = new HalfEdge(this, wallFrom, false);
+            }
+            else {
+                // something horrible has happened
+                console.log('corners arent connected by a wall, uh oh');
+            }
+            if (i === 0) {
+                firstEdge = edge;
+            }
+            else {
+                edge.prev = prevEdge;
+                prevEdge.next = edge;
+                if (i + 1 === this.corners.length) {
+                    firstEdge.prev = edge;
+                    edge.next = firstEdge;
+                }
+            }
+            prevEdge = edge;
+        }
+        // hold on to an edge reference
+        this.edgePointer = firstEdge;
+    }
+    get area() {
+        const polygon = this._polygonFromCorners(this.interiorCorners);
+        return Utils.polygonArea(polygon);
+    }
+    get center() {
+        const polygon = this._polygonFromCorners(this.corners);
+        return Utils.polygonCenter(polygon);
+    }
+    _polygonFromCorners(corners) {
+        return corners.map(c => new Vector2(c.x, c.y));
+    }
+}
+/**
+ * A Wall Item is an entity to be placed related to a wall.
+ */
+export class WallItem extends Item {
+    constructor(metadata, object, texture, handlers) {
+        super(metadata, object, texture, handlers);
+        /** The currently applied wall */
+        this.currentWall = null;
+        /** The currently applied wall edge. */
+        this.currentWallEdge = null;
+        /** Used for finding rotations */
+        this._refVec = new THREE.Vector2(0, 1.0);
+        this._positionYTolerance = 0.005;
+        /** */
+        this._wallOffsetScalar = 0;
+        /** */
+        this._sizeX = 0;
+        /** */
+        this._sizeY = 0;
+        this._flipped = false;
+        /** */
+        this.addToWall = false;
+        /** */
+        this.boundToFloor = false;
+        /** */
+        this.frontVisible = false;
+        this.backVisible = false;
+        this._hasFrontEdge = false;
+        this._hasBackEdge = false;
+        this.allowRotate = false;
+        if (texture) {
+            this.setTexture(texture);
+        }
+    }
+    /** */
+    removed() {
+        if (!isNill(this.currentWallEdge) && this.addToWall) {
+            this.currentWallEdge.wall.removeItem(this);
+            this.redrawWall();
+        }
+    }
+    removeFromWall() {
+        if (this.currentWall) {
+            this.currentWall.removeOnItem(this);
+            this.currentWall = undefined;
+            this.currentWallEdge = undefined;
+        }
+    }
+    /**
+     * Only hides item when entire wall is hidden
+     * This prevents items being set hidden for inner walls
+     * */
+    updateEdgeVisibility(edge) {
+        if (this.currentWall) {
+            let shouldShow = false;
+            if (this.currentWall.backEdge) {
+                this.currentWall.backEdge.edges.forEach((e) => {
+                    if (e.visible) {
+                        shouldShow = true;
+                    }
+                });
+            }
+            if (this.currentWall.frontEdge) {
+                this.currentWall.frontEdge.edges.forEach(e => {
+                    if (e.visible) {
+                        shouldShow = true;
+                    }
+                });
+            }
+            this.visible = shouldShow;
+        }
+    }
+    /** */
+    updateSize() {
+        this._wallOffsetScalar = this.getDepth() / 2;
+        this._sizeX = this.getWidth();
+        this._sizeY = this.getHeight();
+    }
+    /** */
+    resized() {
+        if (this.boundToFloor) {
+            this.position.y = this._boundToFloorY();
+        }
+        this.updateSize();
+        this.redrawWall();
+    }
+    /** */
+    placeOnEdge(edge) {
+        if (!edge) {
+            return;
+        }
+        this._onFrontSide = edge.wall.frontEdge === edge;
+        this._changeWallEdge(edge);
+        this.updateSize();
+        // position not set
+        const center = edge.interiorCenter();
+        const newPos = this.positionSet ?
+            (edge.wall.amountWallMoved ? this.position.add(new Vector3(edge.wall.amountWallMoved.x, 0, 0)) : this.position.clone()) :
+            new THREE.Vector3(center.x, edge.wall.height / 2.0, center.y);
+        this._boundMove(newPos);
+        this.position.copy(newPos);
+        this.redrawWall();
+    }
+    reposition() {
+        const newPos = this.position.clone();
+        this._boundMove(newPos);
+        this.position.copy(newPos);
+    }
+    getFloorY() {
+        if (this.halfSize && this.currentWallEdge) {
+            return this._moveToYPosition(this.halfSize.y + this.elevation);
+        }
+        else {
+            return this.position.y;
+        }
+    }
+    isValidPosition(position, rotation, options) {
+        return { valid: !!this.currentWallEdge };
+    }
+    /** */
+    moveToPosition(vec3, intersection) {
+        if (intersection && this.currentWallEdge) {
+            if (intersection.object.userData.edge && intersection.object.userData.edge.wall !== this.currentWallEdge.wall) {
+                this._changeWallEdge(intersection.object.userData.edge);
+            }
+            this._boundMove(vec3);
+            this.position.copy(vec3);
+            this.redrawWall();
+        }
+    }
+    /** */
+    moveTo2dPosition(x, y, edge) {
+        const vec3 = new Vector3(x, this.position.y, y);
+        this._changeWallEdge(edge);
+        this._boundMove(vec3);
+        this.position.copy(vec3);
+        this.redrawWall();
+    }
+    /** */
+    getWallOffset() {
+        return this._wallOffsetScalar;
+    }
+    getStartX() {
+        return this.position.x - this.getSizeX() / 2 * Math.cos(this.rotation.y);
+    }
+    getStartY() {
+        return this.position.z + this.getSizeX() / 2 * Math.sin(this.rotation.y);
+    }
+    getEndX() {
+        return this.position.x + this.getSizeX() / 2 * Math.cos(this.rotation.y);
+    }
+    getEndY() {
+        return this.position.z - this.getSizeX() / 2 * Math.sin(this.rotation.y);
+    }
+    /**
+     @returns x axis size of item's bounding box
+     */
+    getSizeX() {
+        return this._sizeX;
+    }
+    /**
+     @returns y axis size of item's bounding box
+     */
+    getSizeY() {
+        return this._sizeY;
+    }
+    heightUpdated(amount) {
+        if (!isNill(amount)) {
+            this.position.y = this._moveToYPosition(this.position.y + amount);
+            this.redrawWall();
+        }
+        else {
+            super.heightUpdated();
+        }
+    }
+    updateGeometry(width, height) {
+        const geometry = Geometry.wallBox(width, height, this.getItemThickness());
+        this.object.geometry.dispose();
+        const rotation = this.rotation.y;
+        this.rotation.y = 0;
+        // this.initializeGeometry(geometry);
+        this.rotation.y = rotation;
+        this.resized();
+        this.redrawWall();
+    }
+    setTexture(texture) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.texture = texture && Object.assign({}, texture);
+            return yield this.createMaterial(this.currentWallEdge ? this.currentWallEdge.wall.side : undefined);
+        });
+    }
+    onWallMoved(wall) {
+        if (wall.frontEdge) {
+            this.placeOnEdge(wall.frontEdge);
+        }
+        if (wall.backEdge) {
+            this.placeOnEdge(wall.backEdge);
+        }
+    }
+    updateMaterialVisibility(side = THREE.DoubleSide) {
+        if (!this.texture) {
+            return;
+        }
+        if (this.currentWallEdge) {
+            return;
+        }
+        const isSame = this._isWallSame();
+        if (!isSame) {
+            this.createMaterial(side, isSame);
+            return;
+        }
+        const textureMaterialFront = this.object.material[4];
+        const textureMaterialBack = this.object.material[5];
+        switch (side) {
+            case THREE.DoubleSide:
+                textureMaterialFront.visible = true;
+                textureMaterialBack.visible = true;
+                break;
+            case THREE.FrontSide:
+                textureMaterialFront.visible = this.frontVisible;
+                textureMaterialBack.visible = !this.frontVisible;
+                break;
+            case THREE.BackSide:
+                textureMaterialFront.visible = !this.frontVisible;
+                textureMaterialBack.visible = this.frontVisible;
+                break;
+        }
+    }
+    createTextureMaterial(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { side = THREE.DoubleSide, flip = false } = options || {};
+            const texture = this.getTexture();
+            const material = new THREE.MeshPhongMaterial({ side });
+            material.transparent = true;
+            if (texture) {
+                yield this.addMaterialMap(material, texture, flip);
+            }
+            return material;
+        });
+    }
+    getTexture() {
+        return this.texture;
+    }
+    createMaterial(side = THREE.DoubleSide, isSame = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let textureMaterialFront;
+            let textureMaterialBack;
+            switch (side) {
+                case THREE.DoubleSide:
+                    this._flipped = !isSame;
+                    textureMaterialFront = yield this.createTextureMaterial({ side: THREE.FrontSide, flip: this._flipped });
+                    textureMaterialBack = yield this.createTextureMaterial({ side: THREE.FrontSide, flip: !this._flipped });
+                    break;
+                case THREE.FrontSide:
+                    this._flipped = !isSame;
+                    if (this.frontVisible) {
+                        textureMaterialFront = yield this.createTextureMaterial({ side: THREE.FrontSide, flip: this._flipped });
+                    }
+                    else {
+                        textureMaterialBack = yield this.createTextureMaterial({ side: THREE.BackSide, flip: !this._flipped });
+                    }
+                    break;
+                case THREE.BackSide: {
+                    this._flipped = !isSame;
+                    if (!this.frontVisible) {
+                        textureMaterialFront = yield this.createTextureMaterial({ side: THREE.FrontSide, flip: this._flipped });
+                    }
+                    else {
+                        textureMaterialBack = yield this.createTextureMaterial({
+                            side: THREE.BackSide, flip: !this._flipped
+                        });
+                    }
+                    break;
+                }
+            }
+            this.object.material = this.getMaterials(textureMaterialFront, textureMaterialBack);
+        });
+    }
+    setYPositionBasedOnElevation() {
+        this.position.y = this.elevation + this.halfSize.y;
+    }
+    addMaterialMap(material, texture, flip) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dimensions = this.getMaterialMapDimensions();
+            texture.dimensions = dimensions.multiplyScalar(100);
+            switch (texture.type) {
+                case TextureType.Image:
+                    if (flip) {
+                        material.map = yield MaterialUtils.FromFlippedImage(texture, dimensions);
+                    }
+                    else {
+                        material.map = yield MaterialUtils.FromImage(texture);
+                    }
+                    break;
+                case TextureType.CustomPattern:
+                    material.map = yield MaterialUtils.CustomTileMapTexture(texture, dimensions);
+                    break;
+                case TextureType.Basic:
+                    material.map = yield MaterialUtils.FromUrl(texture.url, texture.stretch, texture.tileSize, null, null, texture.dimensions, texture.tileRotation);
+                    break;
+            }
+            // this.scene.needsUpdate = true;
+            // this.scene.textureLoadedCallbacks.fire();
+        });
+    }
+    getMaterialMapDimensions() {
+        return new THREE.Vector2(this.getWidth(), this.getHeight());
+    }
+    getMaterials(textureMaterialFront, textureMaterialBack) {
+        return [
+            MaterialUtils.defaultWindow.clone(),
+            MaterialUtils.defaultWindow.clone(),
+            MaterialUtils.defaultWindow.clone(),
+            MaterialUtils.defaultWindow.clone(),
+            textureMaterialFront || MaterialUtils.defaultWindow.clone(),
+            textureMaterialBack || MaterialUtils.defaultWindow.clone() // Back side
+        ];
+    }
+    getItemThickness() {
+        return this.currentWall.thickness - 0.01;
+    }
+    /** */
+    redrawWall() {
+        if (this.currentWallEdge && this.currentWallEdge.wall) {
+            this.currentWallEdge.wall.fireRedraw();
+        }
+        // this.updateEdgeVisibility(true, this._onFrontSide);
+    }
+    /** */
+    _changeWallEdge(wallEdge) {
+        if (this.currentWallEdge === wallEdge) {
+            if (!this.currentWall) {
+                this.currentWall = wallEdge.wall;
+            }
+            return;
+        }
+        if (!isNill(this.currentWallEdge)) {
+            if (this.addToWall) {
+                this.currentWallEdge.wall.removeItem(this);
+                this.redrawWall();
+            }
+            else {
+                this.currentWallEdge.wall.removeOnItem(this);
+            }
+        }
+        if (!wallEdge) {
+            return;
+        }
+        // find angle between wall normals
+        const normal2 = new THREE.Vector2();
+        const normal3 = Utils.GetFaceNormalFromBufferGeometry(wallEdge.plane.geometry, 0, 0);
+        normal2.x = normal3.x;
+        normal2.y = normal3.z;
+        const angle = Utils.angle(this._refVec.x, this._refVec.y, normal2.x, normal2.y);
+        this.rotation.y = (this.default180 ? Math.PI : 0) + angle;
+        this.traverse(c => c.matrixWorldNeedsUpdate = true);
+        // update currentWall
+        this.currentWall = wallEdge.wall;
+        this.currentWallEdge = wallEdge;
+        if (this.addToWall) {
+            wallEdge.wall.addItem(this);
+            if (this.metadata.texture) {
+                this.updateMaterialVisibility(wallEdge.wall.side);
+            }
+            this.redrawWall();
+        }
+        else {
+            wallEdge.wall.addOnItem(this);
+        }
+    }
+    _boundToFloorY() {
+        return 0.5 * this.getHeight() * this.scale.y + 0.01;
+    }
+    /** takes the move vec3, and makes sure object stays bounded on plane */
+    _boundMove(vec3) {
+        const edge = this.currentWallEdge;
+        vec3.applyMatrix4(edge.interiorTransform);
+        edge.wall.itemsChanged = true;
+        if (vec3.x < this._sizeX / 2.0 + this._positionYTolerance) {
+            vec3.x = this._sizeX / 2.0 + this._positionYTolerance;
+        }
+        else if (vec3.x > (edge.interiorDistance() - this._sizeX / 2.0 - this._positionYTolerance)) {
+            vec3.x = edge.interiorDistance() - this._sizeX / 2.0 - this._positionYTolerance;
+        }
+        if (this.boundToFloor) {
+            vec3.y = this._boundToFloorY();
+        }
+        else {
+            if (this.elevationFixed || !this.elevationAdjustable) {
+                // if elevation is higher than the wall, use maxY
+                vec3.y = Math.min(this._getMaxY(edge), this.halfSize.y + this.elevation);
+            }
+            else {
+                const maxY = this._getMaxY(edge);
+                const minY = this._getMinT();
+                if (vec3.y < minY) {
+                    vec3.y = minY;
+                }
+                else if (vec3.y > maxY) {
+                    vec3.y = maxY;
+                }
+                this.elevation = vec3.y - this.halfSize.y;
+            }
+        }
+        vec3.z = this.getWallOffset();
+        vec3.applyMatrix4(edge.invInteriorTransform);
+    }
+    _isWallSame() {
+        let isSame = false;
+        if (this.currentWallEdge) {
+            const onFrontSide = this.currentWallEdge === this.currentWallEdge.wall.frontEdge;
+            if (this._onFrontSide === undefined) {
+                this._onFrontSide = onFrontSide;
+            }
+            isSame = onFrontSide === this._onFrontSide;
+        }
+        return isSame;
+    }
+    _getMaxY(edge) {
+        return edge.height - this._sizeY / 2.0 - this._positionYTolerance;
+    }
+    _getMinT() {
+        return this._sizeY / 2.0 + this._positionYTolerance;
+    }
+    _moveToYPosition(position) {
+        const maxY = this._getMaxY(this.currentWallEdge);
+        const minY = this._getMinT();
+        if (position > maxY) {
+            this.elevation = maxY - this.halfSize.y;
+            return maxY;
+        }
+        if (position < minY) {
+            this.elevation = minY - this.halfSize.y;
+            return minY;
+        }
+        return position;
+    }
+}
+export class InWallItem extends WallItem {
+    constructor(metadata, object, texture) {
+        super(metadata, object, texture);
+        this._frameWidth = 0.07;
+        this._frameDepth = 0.1;
+        this._defaultFrameColor = 9070146; // RAL-1011
+        this._defaultDoorColor = 16777215; // RAL-9010
+        this.opening = {
+            show: false,
+            double: false,
+            invertDirection: false,
+            invertSide: true
+        };
+        this.frameColor = this._defaultFrameColor;
+        this.doorColor = this._defaultDoorColor;
+        this.windowColor = new THREE.Color(0.0431, 0.0588, 0.0902);
+        this.isGlass = false;
+        this._isWindow = false;
+        this._doorpost = false;
+        this._setDefault();
+        this.frameTitle = 'Frame';
+        this.customMeshTitle = this._isWindow ? 'Window' : 'Door';
+        this.canChangeCustomMeshColor = !this._isWindow;
+        this.receiveShadow = true;
+        this.addToWall = true;
+        this._glassMaterialCheck();
+    }
+    get doorpost() {
+        return this._doorpost;
+    }
+    dispose() {
+        super.dispose();
+        Utils.DisposeObject(this.topFrame);
+        Utils.DisposeObject(this.leftFrame);
+        Utils.DisposeObject(this.rightFrame);
+        Utils.DisposeObject(this.bottomFrame);
+        Utils.DisposeObject(this.customMesh);
+        Utils.DisposeMaterial(this.frameMaterial);
+        Utils.DisposeMaterial(this.doorMaterialFront);
+        Utils.DisposeMaterial(this.windowMaterial);
+    }
+    placeOnEdge(edge) {
+        if (this.isCustom) {
+            const checkMaterial = this._isWindow ? this.windowMaterial : this.doorMaterialFront;
+            if (!checkMaterial) {
+                this._createMaterials(THREE.DoubleSide);
+            }
+            this.createCustomMesh(this.getWidth(), this.getHeight());
+        }
+        super.placeOnEdge(edge);
+    }
+    /** */
+    getWallOffset() {
+        return -this.currentWallEdge.offset;
+    }
+    distanceFrom2d(x, y) {
+        return Utils.pointDistanceFromLine(x, y, this.getStartX(), this.getStartY(), this.getEndX(), this.getEndY());
+    }
+    onWallUpdated(wall) {
+        if (this.metadata.texture) {
+            this.updateMaterialVisibility(wall.side);
+        }
+    }
+    updateFrameColor(color) {
+        this.frameColor = color;
+        this.frameMaterial.color.setHex(color);
+        this.frameMaterial.needsUpdate = true;
+        // this.scene.needsUpdate = true;
+    }
+    updateDoorColor(color) {
+        this.doorColor = color;
+        this.doorMaterialFront.color.setHex(color);
+        this.doorMaterialFront.transparent = false;
+        this.doorMaterialFront.opacity = 1;
+        this.doorMaterialFront.map = undefined;
+        this.doorMaterialFront.needsUpdate = true;
+        // this.scene.needsUpdate = true;
+    }
+    updateGlassMaterial() {
+        if (!this.isGlass) {
+            this.doorMaterialFront.color.setHex(0xdff0f2);
+            this.doorMaterialFront.transparent = true;
+            this.doorMaterialFront.alphaTest = 0;
+            this.doorMaterialFront.opacity = 0.2;
+            this.doorMaterialFront.map = undefined;
+            this.doorMaterialFront.needsUpdate = true;
+            this.doorMaterialFront.side = THREE.FrontSide;
+            this.isGlass = true;
+            this.customMesh.castShadow = false;
+        }
+        else {
+            this.doorMaterialFront.transparent = false;
+            this.doorMaterialFront.opacity = 1;
+            this.isGlass = false;
+            this.customMesh.castShadow = true;
+        }
+    }
+    updateGeometry(width, height) {
+        if (this.isCustom) {
+            this.createCustomMesh(width, height);
+            // this.calculateHalfSize();
+            this.redrawWall();
+        }
+        else {
+            super.updateGeometry(width, height);
+        }
+    }
+    adjustWallBox(geometry) {
+        geometry.getAttribute('position').needsUpdate = true;
+        geometry.computeBoundingBox();
+        geometry.applyMatrix4(new Matrix4().makeTranslation(-0.5 * (geometry.boundingBox.max.x + geometry.boundingBox.min.x), -0.5 * (geometry.boundingBox.max.y + geometry.boundingBox.min.y), -0.5 * (geometry.boundingBox.max.z + geometry.boundingBox.min.z)));
+        geometry.computeBoundingBox();
+        this.object.geometry = geometry;
+        this.calculateHalfSize();
+    }
+    getVisibleMeshes() {
+        if (this.isCustom && this.visible) {
+            const meshes = [
+                this.leftFrame,
+                this.topFrame,
+                this.rightFrame,
+                this.customMesh
+            ];
+            if (this._isWindow /*|| this._doorpost*/) {
+                meshes.push(this.bottomFrame);
+            }
+            return meshes;
+        }
+        else {
+            return super.getVisibleMeshes();
+        }
+    }
+    createTextureMaterial(options) {
+        const _super = Object.create(null, {
+            createTextureMaterial: { get: () => super.createTextureMaterial }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isCustom) {
+                const { side = THREE.DoubleSide, flip = false } = options || {};
+                const checkMaterial = this._isWindow ? this.windowMaterial : this.doorMaterialFront;
+                if (!checkMaterial) {
+                    this._createMaterials(side);
+                }
+                const texture = this.getTexture();
+                if (!texture) {
+                    // reset to default texture
+                    this._createMaterials(side);
+                    this.createCustomMesh(this.getWidth(), this.getHeight());
+                    return this._isWindow ? this.windowMaterial : this.doorMaterialFront;
+                }
+                const material = this._isWindow ? this.windowMaterial : this.doorMaterialFront;
+                const defaultMaterial = new THREE.MeshPhongMaterial();
+                material.transparent = false;
+                material.color = defaultMaterial.color.clone();
+                material.opacity = defaultMaterial.opacity;
+                material.refractionRatio = defaultMaterial.refractionRatio;
+                material.shininess = defaultMaterial.shininess;
+                material.specular = defaultMaterial.specular.clone();
+                // Allows for transparency in png's
+                material.alphaTest = 0.5;
+                // Makes sure the image in only projected once on the mesh
+                material.side = THREE.FrontSide;
+                // Removes white edges surrounding the image
+                material.transparent = true;
+                // material.color = new THREE.Color(1, 1, 1);
+                yield this.addMaterialMap(material, texture, flip);
+                material.needsUpdate = true;
+                return material;
+            }
+            else {
+                return yield _super.createTextureMaterial.call(this, options);
+            }
+        });
+    }
+    createCustomMesh(width, height) {
+        const halfWidth = width / 2;
+        const halfFrame = (this._frameWidth / 2);
+        this.leftFrame = this._createFrameSide(this._frameWidth, this._getHeightFrame(height), this._frameDepth);
+        this.leftFrame.rotation.set(this._isWindow ? 180 * (Math.PI / 180) : 0, 0, 0);
+        this.leftFrame.position.x = -halfWidth + halfFrame;
+        this.leftFrame.name = 'leftFrame';
+        if (!this._isWindow) {
+            this.leftFrame.position.y = -(this._frameWidth / 2) + 0.02;
+        }
+        this.topFrame = this._createFrameSide(this._frameWidth, width, this._frameDepth);
+        this.topFrame.rotation.set(0, this._isWindow ? 180 * (Math.PI / 180) : 0, -90 * (Math.PI / 180));
+        this.topFrame.position.y = (height / 2) - (this._frameWidth / 2);
+        this.topFrame.name = 'topFrame';
+        this.rightFrame = this._createFrameSide(this._frameWidth, this._getHeightFrame(height), this._frameDepth);
+        this.rightFrame.rotation.set(this._isWindow ? 180 * (Math.PI / 180) : 0, 0, -180 * (Math.PI / 180));
+        this.rightFrame.position.x = (width / 2) - (this._frameWidth / 2);
+        this.rightFrame.name = 'rightFrame';
+        if (!this._isWindow) {
+            this.rightFrame.position.y = -(this._frameWidth / 2) + 0.02;
+        }
+        if (this._isWindow /*|| this._doorpost*/) {
+            this.bottomFrame = this._createFrameSide(this._frameWidth, width, this._frameDepth);
+            this.bottomFrame.rotation.set(0, 180 * (Math.PI / 180), 90 * (Math.PI / 180));
+            this.bottomFrame.position.y = -(height / 2) + (this._frameWidth / 2);
+            this.bottomFrame.name = 'bottomFrame';
+        }
+        let customGeo;
+        if (this._isWindow) {
+            customGeo = new THREE.BoxGeometry(width - (2 * this._frameWidth) + 0.04, height - (2 * this._frameWidth) + 0.04, 0.024);
+        }
+        else {
+            customGeo = new THREE.BoxGeometry(width - 0.02 * (this._frameWidth - 0.02), height - (this._frameWidth - 0.02), 0.04);
+        }
+        this.customMesh = new THREE.Mesh(customGeo, this._isWindow ? this.windowMaterial : this.doorMaterialFront);
+        this.customMesh.castShadow = this._isWindow ? false : !this.isGlass;
+        this.customMesh.renderOrder = -1;
+        this.customMesh.name = 'customMesh';
+        if (this._isWindow) {
+            this.customMesh.name += 'Window';
+        }
+        if (this.isGlass) {
+            this.customMesh.name += 'Glass';
+        }
+        if (this._isWindow) {
+            this.customMesh.position.z = -0.012;
+        }
+        else {
+            this.customMesh.position.y = -(this._frameWidth / 2) + 0.01;
+            this.customMesh.position.z = 0.02;
+        }
+        this._getAdditionalTexture().then((frontAdditionalObj) => {
+            if (frontAdditionalObj) {
+                const backAdditionalObj = frontAdditionalObj.clone(true);
+                backAdditionalObj.rotation.x = 180 * (Math.PI / 180);
+                if (this.additionalTexture.data) {
+                    frontAdditionalObj.position.set(-(width / 2) + this.additionalTexture.data.x, -(height / 2) + this.additionalTexture.data.y, 0.02);
+                    backAdditionalObj.position.set(-(width / 2) + this.additionalTexture.data.x, -(height / 2) + this.additionalTexture.data.y, -0.02);
+                }
+                this.customMesh.add(frontAdditionalObj);
+                this.customMesh.add(backAdditionalObj);
+            }
+        });
+        this.children.length = 0;
+        this.add(this.leftFrame, this.rightFrame, this.topFrame, this.customMesh);
+        if (this._isWindow /*|| this._doorpost*/) {
+            this.add(this.bottomFrame);
+        }
+        this.calculateHalfSize();
+        // this.scene.needsUpdate = true;
+    }
+    cloneItem() {
+        const clone = this.createClass();
+        this.cloneProperties(clone);
+        clone.name = 'test clone';
+        return clone;
+    }
+    createMaterial(side = THREE.DoubleSide, isSame = true) {
+        const _super = Object.create(null, {
+            createTextureMaterial: { get: () => super.createTextureMaterial }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isCustom) {
+                yield this.createTextureMaterial({ side: THREE.FrontSide, flip: false });
+            }
+            else {
+                yield _super.createTextureMaterial.call(this, { side, isSame });
+            }
+        });
+    }
+    createClass() {
+        // create new object for proper dimensions
+        const mesh = new Mesh(new BoxGeometry(this.halfSize.x * 2, this.halfSize.y * 2, this.halfSize.z * 2));
+        return new InWallItem(this.metadata, mesh);
+    }
+    cloneProperties(clone) {
+        clone.userData = this.userData;
+        clone.doorMaterialFront = this.doorMaterialFront ? this.doorMaterialFront.clone() : undefined;
+        if (clone.doorMaterialFront) {
+            clone.doorMaterialFront.emissive = new THREE.Color(0x000000);
+            clone.doorMaterialFront.needsUpdate = true;
+        }
+        clone.windowMaterial = this.windowMaterial ? this.windowMaterial.clone() : undefined;
+        if (clone.windowMaterial) {
+            clone.windowMaterial.emissive = new THREE.Color(0x000000);
+            clone.windowMaterial.needsUpdate = true;
+        }
+        clone.frameMaterial = this.frameMaterial ? this.frameMaterial.clone() : undefined;
+        if (clone.frameMaterial) {
+            clone.frameMaterial.emissive = new THREE.Color(0x000000);
+            clone.frameMaterial.needsUpdate = true;
+        }
+        clone.frameColor = this.frameColor;
+        clone.doorColor = this.doorColor;
+        clone.object.material = [clone.frameMaterial, clone._isWindow ? clone.windowMaterial : clone.doorMaterialFront];
+        clone.texture = this.texture;
+        clone.additionalTexture = this.additionalTexture;
+        clone.isGlass = this.isGlass;
+    }
+    getMaterials(textureMaterialFront, textureMaterialBack) {
+        if (this.isCustom) {
+            return this.object.material;
+        }
+        else {
+            return super.getMaterials(textureMaterialFront, textureMaterialBack);
+        }
+    }
+    getMaterialMapDimensions() {
+        if (this.isCustom) {
+            return new THREE.Vector2(this.getWidth() - 0.14, this.getHeight() - 0.07);
+        }
+        else {
+            return super.getMaterialMapDimensions();
+        }
+    }
+    initiateItemObject(data) {
+        if (this.isCustom && data && data.geometry) {
+            data.geometry.verticesNeedUpdate = true;
+            data.geometry.computeBoundingBox();
+            data.geometry.applyMatrix4(new Matrix4().makeTranslation(-0.5 * (data.geometry.boundingBox.max.x + data.geometry.boundingBox.min.x), -0.5 * (data.geometry.boundingBox.max.y + data.geometry.boundingBox.min.y), -0.5 * (data.geometry.boundingBox.max.z + data.geometry.boundingBox.min.z)));
+            data.geometry.computeBoundingBox();
+            const max = data.geometry.boundingBox.max.clone();
+            const min = data.geometry.boundingBox.min.clone();
+            this.halfSize = max.sub(min).divideScalar(2);
+        }
+    }
+    _setDefault() {
+        // workaround because properties are not available yet when creating window/door from loading from cloud/local
+        this.frameColor = this.metadata.frameColor ? this.metadata.frameColor : this._defaultFrameColor; // RAL-1011
+        this.doorColor = this.metadata.doorColor ? this.metadata.doorColor : this._defaultDoorColor; // RAL-9010
+        this.windowColor = this.metadata.windowColor ? this.metadata.windowColor : new THREE.Color(0xdff0f2);
+        this._isWindow = this.metadata.itemType === ItemType.InWall;
+        this._doorpost = this.metadata.doorpost;
+        this.isGlass = this.metadata.isGlass ? this.metadata.isGlass : false;
+    }
+    _createMaterials(side) {
+        this._setDefault();
+        this.frameMaterial = new THREE.MeshPhongMaterial({ side: side, name: 'frameMaterial' });
+        this.frameMaterial.color = new THREE.Color(this.frameColor);
+        if (this._isWindow) {
+            this.windowMaterial = new THREE.MeshPhongMaterial({ side: side, color: this.windowColor, name: 'windowMaterial' });
+            this.windowMaterial.transparent = true;
+            this.windowMaterial.alphaTest = 0;
+            this.windowMaterial.opacity = 0.2;
+            this.windowMaterial.map = undefined;
+            this.windowMaterial.needsUpdate = true;
+            this.windowMaterial.side = THREE.FrontSide;
+            this.object.material = [this.frameMaterial, this.windowMaterial];
+        }
+        else {
+            this.doorMaterialFront = new THREE.MeshPhongMaterial({ side: side, name: 'doorMaterialFront' });
+            this.doorMaterialFront.color = new THREE.Color(this.doorColor);
+            if (this._doorpost) {
+                this.doorMaterialFront.transparent = true;
+                this.doorMaterialFront.opacity = 0;
+            }
+            this.object.material = [this.frameMaterial, this.doorMaterialFront];
+        }
+    }
+    _getHeightFrame(height) {
+        return height - (this._isWindow ? 2 * (this._frameWidth - 0.02) : this._frameWidth - 0.02);
+    }
+    _createFrameSide(width, height, depth) {
+        const outerFrameWidth = width - 0.02;
+        const outerFrameGeo = new THREE.BoxGeometry(outerFrameWidth, height, depth);
+        const outerFrame = new THREE.Mesh(outerFrameGeo, this.frameMaterial);
+        outerFrame.castShadow = true;
+        outerFrame.receiveShadow = true;
+        const innerFrameGeo = new THREE.BoxGeometry(0.02, height, depth / 2);
+        const innerFrame = new THREE.Mesh(innerFrameGeo, this.frameMaterial);
+        innerFrame.castShadow = true;
+        innerFrame.receiveShadow = true;
+        innerFrame.position.x = (outerFrameWidth / 2) + 0.01;
+        innerFrame.position.z = -depth / 4;
+        const frameSide = new THREE.Object3D();
+        frameSide.add(outerFrame, innerFrame);
+        const boundingBox = new THREE.Box3().setFromObject(frameSide);
+        const bbCenterPivot = new THREE.Vector3();
+        boundingBox.getCenter(bbCenterPivot);
+        const delta = new THREE.Vector3().sub(bbCenterPivot).setY(0);
+        frameSide.children.forEach((child) => {
+            child.position.add(delta);
+        });
+        const frameSideMesh = new Mesh();
+        frameSideMesh.add(outerFrame, innerFrame);
+        return frameSideMesh;
+    }
+    _getAdditionalTexture() {
+        return new Promise((resolve, reject) => {
+            // if (this.additionalTexture) {
+            //     LoaderUtils.LoadObjModel(this.additionalTexture.url).then((obj: THREE.Mesh) => {
+            //         const additionalObj: THREE.Mesh = <Mesh>obj.clone(true);
+            //         additionalObj.children.map(c => c.position.set(0, 0, 0));
+            //         if (this.additionalTexture.scale) {
+            //             additionalObj.scale.multiplyScalar(this.additionalTexture.scale);
+            //         }
+            //         resolve(additionalObj);
+            //     });
+            // } else {
+            resolve(null);
+            // }
+        });
+    }
+    _glassMaterialCheck() {
+        let meshesFound = 0;
+        this.traverse((child) => {
+            if (child instanceof Mesh && child.material) {
+                meshesFound++;
+                child.castShadow = true;
+                const materials = !Array.isArray(child.material) ? [child.material] : child.material;
+                materials.forEach(material => {
+                    if (material.name && (material.name === 'Fixed_Glass' || material.name === 'Default_Glass')) {
+                        child.castShadow = false;
+                        material.transparent = true;
+                        material.opacity = 0.2;
+                        material.format = THREE.RGBAFormat;
+                        material.needsUpdate = true;
+                    }
+                });
+            }
+        });
+        // Remove to ignore old door models
+        if (meshesFound === 1) {
+            this.traverse((child) => {
+                if (child instanceof Mesh) {
+                    child.castShadow = true;
+                    const materials = !Array.isArray(child.material) ? [child.material] : child.material;
+                    materials.forEach(m => {
+                        m.visible = m.name && (m.name === 'Fixed_Glass' || m.name === 'Default_Glass') ? m.visible = false : m.visible = true;
+                    });
+                }
+            });
+        }
+    }
+}
+export class WallItemGroup extends ItemGroup {
+    constructor() {
+        super();
+        this.elevationAdjustable = true;
+        this._positionYTolerance = 0.005;
+        this._wallOffsetScalar = 0;
+        this._sizeX = 0;
+        this._sizeY = 0;
+        this._refVec = new THREE.Vector2(0, 1.0);
+        this.metadata = {
+            itemType: 22
+        };
+        this.userData.itemType = this.metadata.itemType;
+    }
+    redrawWall() {
+        if (this.currentWallEdge && this.currentWallEdge.wall) {
+            this.currentWallEdge.wall.fireRedraw();
+        }
+    }
+    isValidPosition(position, rotation, options) {
+        return { valid: true };
+    }
+    moveToPosition(vec3, intersection) {
+        if (intersection) {
+            if (!this.currentWallEdge && this.items[0].currentWallEdge) {
+                this.currentWallEdge = this.items[0].currentWallEdge;
+            }
+            if (this.currentWallEdge) {
+                this._boundMove(vec3);
+                this.position.copy(vec3);
+                this.redrawWall();
+            }
+        }
+    }
+    createBoundaryBox() {
+        this.boundaryBox.setFromObject(this);
+        const max = this.boundaryBox.max.clone();
+        const min = this.boundaryBox.min.clone();
+        this.halfSize = max.sub(min).divideScalar(2);
+        this.updateSize();
+    }
+    centerPivot() {
+        const boundaryBoxCenter = this.boundaryBoxCenter;
+        this.position.copy(boundaryBoxCenter);
+        this.items.forEach(i => {
+            const originalPosition = i.position.clone();
+            const newPosition = originalPosition.sub(boundaryBoxCenter);
+            i.position.copy(newPosition);
+        });
+    }
+    updateSize() {
+        this._wallOffsetScalar = this.halfSize.z;
+        this._sizeX = this.halfSize.x * 2;
+        this._sizeY = this.halfSize.y * 2;
+    }
+    onWallMoved(wall) {
+        if (wall.frontEdge) {
+            this.placeOnEdge(wall.frontEdge);
+        }
+        if (wall.backEdge) {
+            this.placeOnEdge(wall.backEdge);
+        }
+    }
+    placeOnEdge(edge) {
+        this._originalRotation = this.rotation.clone();
+        if (!edge) {
+            return;
+        }
+        this._onFrontSide = edge.wall.frontEdge === edge;
+        this._changeWallEdge(edge);
+        const newPos = edge.wall.amountWallMoved ? this.position.add(new Vector3(edge.wall.amountWallMoved.x, 0, 0)) : this.position.clone();
+        this._boundMove(newPos);
+        this.position.copy(newPos);
+        this.redrawWall();
+        this.allowRotate = false;
+    }
+    handleGroupCreation() {
+        this.items.forEach((i) => {
+            if (!this.currentWallEdge) {
+                this.currentWallEdge = i.currentWallEdge;
+                this.currentWall = this.currentWallEdge.wall;
+            }
+            this.currentWall.removeOnItem(i);
+        });
+        this.placeOnEdge(this.currentWallEdge);
+    }
+    _changeWallEdge(wallEdge) {
+        // find angle between wall normals
+        const normal2 = new THREE.Vector2();
+        const normal3 = Utils.GetFaceNormalFromBufferGeometry(wallEdge.plane.geometry, 0, 0);
+        normal2.x = normal3.x;
+        normal2.y = normal3.z;
+        const wallRotation = Utils.angle(this._refVec.x, this._refVec.y, normal2.x, normal2.y);
+        // transfer rotation from child to parent and reset boundary box
+        if (this.items[0].rotation.y !== 0) {
+            this.items.forEach((i) => {
+                const itemWorldPosition = i.getWorldPosition(new Vector3());
+                this.remove(i);
+                this.rotation.y = wallRotation;
+                i.position.copy(itemWorldPosition);
+                this.attach(i);
+                this.rotation.y = 0;
+            });
+            this.createBoundaryBox();
+        }
+        this.rotation.y = wallRotation;
+        this.traverse(c => c.matrixWorldNeedsUpdate = true);
+        // update currentWall
+        this.currentWall = wallEdge.wall;
+        this.currentWallEdge = wallEdge;
+        wallEdge.wall.addOnItem(this);
+    }
+    updateEdgeVisibility(edge) {
+        if (this.currentWall) {
+            let shouldShow = false;
+            if (this.currentWall.backEdge) {
+                this.currentWall.backEdge.edges.forEach((e) => {
+                    if (e.visible) {
+                        shouldShow = true;
+                    }
+                });
+            }
+            if (this.currentWall.frontEdge) {
+                this.currentWall.frontEdge.edges.forEach(e => {
+                    if (e.visible) {
+                        shouldShow = true;
+                    }
+                });
+            }
+            this.visible = shouldShow;
+        }
+    }
+    _boundMove(vec3) {
+        const edge = this.currentWallEdge;
+        vec3.applyMatrix4(edge.interiorTransform);
+        edge.wall.itemsChanged = true;
+        if (vec3.x < this._sizeX / 2.0 + this._positionYTolerance) {
+            vec3.x = this._sizeX / 2.0 + this._positionYTolerance;
+        }
+        else if (vec3.x > (edge.interiorDistance() - this._sizeX / 2.0 - this._positionYTolerance)) {
+            vec3.x = edge.interiorDistance() - this._sizeX / 2.0 - this._positionYTolerance;
+        }
+        if (this.elevationFixed || !this.elevationAdjustable) {
+            vec3.y = this.position.y;
+        }
+        else {
+            const maxY = this._getMaxY(edge);
+            const minY = this._getMinY();
+            if (vec3.y < minY) {
+                vec3.y = minY;
+            }
+            else if (vec3.y > maxY) {
+                vec3.y = maxY;
+            }
+            this.elevation = vec3.y - this.halfSize.y;
+        }
+        vec3.z = this._wallOffsetScalar;
+        vec3.applyMatrix4(edge.invInteriorTransform);
+    }
+    _getMaxY(edge) {
+        return edge.height - this.halfSize.y - this._positionYTolerance;
+    }
+    _getMinY() {
+        return this.halfSize.y + this._positionYTolerance;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wall-objects.js","sourceRoot":"","sources":["../../../../../../../src/client/app/plugins/core3d/items/wall-objects.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n    BoxGeometry,\r\n    BufferAttribute,\r\n    BufferGeometry,\r\n    Color, DoubleSide, Euler, Intersection, Material,\r\n    Matrix4,\r\n    Mesh,\r\n    MeshBasicMaterial, MeshPhongMaterial,\r\n    MeshPhysicalMaterial, MeshStandardMaterial, Object3D, Path,\r\n    Quaternion, Shape, ShapeGeometry, SRGBColorSpace,\r\n    Vector2,\r\n    Vector3\r\n} from 'three';\r\nimport * as THREE from 'three';\r\nimport {sameTextures, Texture} from '../../../core/model/texture';\r\nimport {Item} from './item';\r\nimport {Utils} from '../core/utils';\r\nimport {defaultEdgeColor, defaultWallColor} from '../../room-planner/components/floorplanner/const/defaults';\r\nimport {ThreeMesh} from './three-mesh';\r\nimport {isNill} from '../../../core/utils/function/is-nill.function';\r\nimport {TextureType} from '../../../core/model/texture-type';\r\nimport {MaterialUtils} from '../../../core/utils/material.utils';\r\nimport {Metadata} from './metadata';\r\nimport {ItemType} from './item-type';\r\nimport {CollisionInfo} from '../model/collision-info';\r\nimport * as Geometry from '../model/geometry';\r\nimport {ItemGroup} from './item-group';\r\nimport {OutputEncoding} from '../../../core/enum/output-encoding.enum';\r\nimport {FloorPlaneItem} from './floor-plane-item';\r\n\r\n/**\r\n * A Wall is the basic element to create Rooms.\r\n *\r\n * Walls consists of two half edges.\r\n */\r\nexport class Wall {\r\n\r\n    /** The unique id of each wall. */\r\n    private id: string;\r\n\r\n    /** Front is the plane from start to end. */\r\n    public frontEdge: HalfEdge = null;\r\n\r\n    /** Back is the plane from end to start. */\r\n    public backEdge: HalfEdge = null;\r\n\r\n    /** */\r\n    public orphan = false;\r\n\r\n    /** Items attached to this wall */\r\n    public items: Item[] = [];\r\n    public itemsChanged = false;\r\n\r\n    /** */\r\n    public onItems: Item[] = [];\r\n\r\n    /** The front-side texture. */\r\n    public frontTexture: Texture;\r\n\r\n    /** The back-side texture. */\r\n    public backTexture: Texture;\r\n\r\n    /** The front-side color. */\r\n    public frontColor = defaultWallColor;\r\n\r\n    /** The back-side color. */\r\n    public backColor = defaultWallColor;\r\n\r\n    public thickness;\r\n\r\n    public set height(value: number) {\r\n        this._height = value;\r\n        if (this.frontEdge) {\r\n            this.frontEdge.height = this._height;\r\n        }\r\n        if (this.backEdge) {\r\n            this.backEdge.height = this._height;\r\n        }\r\n        this.items.forEach((item: WallItem) => item.reposition());\r\n        this.onItems.forEach((item: WallItem) => item.reposition());\r\n    }\r\n\r\n    public get height(): number {\r\n        return this._height;\r\n    }\r\n\r\n    public amountWallMoved: Vector2;\r\n\r\n    private _height: number;\r\n\r\n    /**\r\n     * Constructs a new wall.\r\n     * @param start Start corner.\r\n     * @param end End corner.\r\n     */\r\n    constructor(private start: Corner, private end: Corner) {\r\n        this.id = this.getUuid();\r\n\r\n        this.start.attachStart(this);\r\n        this.end.attachEnd(this);\r\n    }\r\n\r\n    private getUuid(): string {\r\n        return [this.start.id, this.end.id].join();\r\n    }\r\n\r\n    public showHideWall(show: boolean): void {\r\n        if (this.frontEdge) { this.frontEdge.showHideEdge(show); }\r\n        if (this.backEdge) { this.backEdge.showHideEdge(show); }\r\n    }\r\n\r\n    public resetFrontBack() {\r\n        if (this.frontEdge) { this.frontEdge.disposePlane(); }\r\n        if (this.backEdge) { this.backEdge.disposePlane(); }\r\n        this.frontEdge = null;\r\n        this.backEdge = null;\r\n        this.orphan = false;\r\n    }\r\n\r\n    private move(x: number, y: number) {\r\n        if (!this.amountWallMoved) {\r\n            this.amountWallMoved = new Vector2();\r\n        }\r\n        const diffX = this.end.x - this.start.x;\r\n        const diffY = this.end.y - this.start.y;\r\n        const prevStartX: number = this.start.x;\r\n        const prevStartY: number = this.start.y;\r\n        this.start.move(x, y);\r\n        this.end.move(x + diffX, y + diffY);\r\n        this.amountWallMoved.add(new Vector2(this.start.x - prevStartX, this.start.y - prevStartY));\r\n    }\r\n\r\n    private relativeMove(dx: number, dy: number) {\r\n        this.start.relativeMove(dx, dy);\r\n        this.end.relativeMove(dx, dy);\r\n    }\r\n\r\n    public fireRedraw() {\r\n        if (this.frontEdge) {\r\n            this.frontEdge.redraw();\r\n        }\r\n        if (this.backEdge) {\r\n            this.backEdge.redraw();\r\n        }\r\n    }\r\n\r\n    public getStart(): Corner {\r\n        return this.start;\r\n    }\r\n\r\n    public getEnd(): Corner {\r\n        return this.end;\r\n    }\r\n\r\n    public getStartX(): number {\r\n        return this.start.getX();\r\n    }\r\n\r\n    public getEndX(): number {\r\n        return this.end.getX();\r\n    }\r\n\r\n    public getStartY(): number {\r\n        return this.start.getY();\r\n    }\r\n\r\n    public getEndY(): number {\r\n        return this.end.getY();\r\n    }\r\n\r\n    public remove() {\r\n        this.start.detachWall(this);\r\n        this.end.detachWall(this);\r\n        this.frontTexture = undefined;\r\n        this.backTexture = undefined;\r\n    }\r\n\r\n    public setStart(corner: Corner) {\r\n        this.start.detachWall(this);\r\n        corner.attachStart(this);\r\n        this.start = corner;\r\n    }\r\n\r\n    public setEnd(corner: Corner) {\r\n        this.end.detachWall(this);\r\n        corner.attachEnd(this);\r\n        this.end = corner;\r\n    }\r\n\r\n    public distanceFrom(x: number, y: number): number {\r\n        return Utils.pointDistanceFromLine(x, y,\r\n            this.getStartX(), this.getStartY(),\r\n            this.getEndX(), this.getEndY());\r\n    }\r\n\r\n    public closestPointTo(x: number, y: number): { x: number, y: number } {\r\n        return Utils.closestPointOnLine(x, y,\r\n            this.getStartX(), this.getStartY(),\r\n            this.getEndX(), this.getEndY());\r\n    }\r\n\r\n    public isToOrFrom(x: number, y: number) {\r\n        return (this.getStartX() === x && this.getStartY() === y) ||\r\n            ( this.getEndX() === x && this.getEndY() === y);\r\n    }\r\n\r\n    /** Return the corner opposite of the one provided.\r\n     * @param corner The given corner.\r\n     * @returns The opposite corner.\r\n     */\r\n    private _oppositeCorner(corner: Corner): Corner {\r\n        if (this.start === corner) {\r\n            return this.end;\r\n        } else if (this.end === corner) {\r\n            return this.start;\r\n        } else {\r\n            console.log('Wall does not connect to corner');\r\n        }\r\n    }\r\n\r\n    public get length(): number {\r\n        return Utils.distance(this.getStartX(), this.getStartY(), this.getEndX(), this.getEndY());\r\n    }\r\n\r\n    public get edgesLengths(): number[] {\r\n        const lengths: number[] = [];\r\n        if (this.frontEdge) {\r\n            lengths.push(this.frontEdge.interiorDistance());\r\n        }\r\n        if (this.backEdge) {\r\n            lengths.push(this.backEdge.interiorDistance());\r\n        }\r\n        return lengths;\r\n    }\r\n\r\n    public updateInWallItems() {\r\n        this.items.filter(item => item instanceof InWallItem).forEach((item: InWallItem) => item.onWallUpdated(this));\r\n    }\r\n\r\n    public updateWallItems() {\r\n        this.items.filter(item => item instanceof WallItem).forEach((item: WallItem) => item.onWallMoved(this));\r\n        this.onItems.filter(item => item instanceof WallItem || item instanceof WallItemGroup).forEach((item: WallItem) => item.onWallMoved(this));\r\n        this.amountWallMoved = undefined;\r\n    }\r\n\r\n    public getItems(): Item[] {\r\n        return this.items;\r\n    }\r\n\r\n    public getWallItems(): WallItem[] {\r\n        return this.items.filter(item => item instanceof WallItem) as WallItem[];\r\n    }\r\n\r\n    public get side() {\r\n        if (this.frontEdge && this.backEdge) {\r\n            return THREE.DoubleSide;\r\n        } else if (this.frontEdge) {\r\n            return THREE.FrontSide;\r\n        } else if (this.backEdge) {\r\n            return THREE.BackSide;\r\n        }\r\n    }\r\n\r\n    public addItem(item: Item) {\r\n        this.items.push(item);\r\n        this.itemsChanged = true;\r\n    }\r\n\r\n    public removeItem(item: Item) {\r\n        this.items = this.items.filter(i => i !== item);\r\n        this.itemsChanged = true;\r\n    }\r\n\r\n    public addOnItem(item: Item) {\r\n        this.onItems.push(item);\r\n        this.itemsChanged = true;\r\n    }\r\n\r\n    public removeOnItem(item: Item) {\r\n        this.onItems = this.onItems.filter(i => i !== item);\r\n        this.itemsChanged = true;\r\n    }\r\n}\r\n\r\n/**\r\n * Corners are used to define Walls.\r\n */\r\nexport class Corner {\r\n\r\n    /** Array of start walls. */\r\n    public wallStarts: Wall[] = [];\r\n\r\n    /** Array of end walls. */\r\n    public wallEnds: Wall[] = [];\r\n\r\n    /** Constructs a corner.\r\n     * @param x X coordinate.\r\n     * @param y Y coordinate.\r\n     * @param id An optional unique id. If not set, created internally.\r\n     */\r\n    constructor(public x: number, public y: number, public id?: string) {\r\n        this.id = id || Utils.guid();\r\n    }\r\n\r\n    public absorbWallsFrom(corner: Corner) {\r\n        for (let i = corner.wallStarts.length - 1; i >= 0; i--) {\r\n            corner.wallStarts[i].setStart(this);\r\n        }\r\n        for (let i = corner.wallEnds.length - 1; i >= 0; i--) {\r\n            corner.wallEnds[i].setEnd(this);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @returns\r\n     * @deprecated\r\n     */\r\n    public getX(): number {\r\n        return this.x;\r\n    }\r\n\r\n    /**\r\n     * @returns\r\n     * @deprecated\r\n     */\r\n    public getY(): number {\r\n        return this.y;\r\n    }\r\n\r\n    /** Moves corner relatively to new position.\r\n     * @param dx The delta x.\r\n     * @param dy The delta y.\r\n     */\r\n    public relativeMove(dx: number, dy: number) {\r\n        this.move(this.x + dx, this.y + dy);\r\n    }\r\n\r\n    /** Removes all walls. */\r\n    public removeAll() {\r\n        for (let i = 0; i < this.wallStarts.length; i++) {\r\n            this.wallStarts[i].remove();\r\n        }\r\n        for (let i = 0; i < this.wallEnds.length; i++) {\r\n            this.wallEnds[i].remove();\r\n        }\r\n    }\r\n\r\n    /** Moves corner to new position.\r\n     * @param newX The new x position.\r\n     * @param newY The new y position.\r\n     */\r\n    public move(newX: number, newY: number) {\r\n        this.x = newX;\r\n        this.y = newY;\r\n    }\r\n\r\n    /** Gets the adjacent corners.\r\n     * @returns Array of corners.\r\n     */\r\n    public adjacentCorners(): Corner[] {\r\n        const retArray = [];\r\n        for (let i = 0; i < this.wallStarts.length; i++) {\r\n            retArray.push(this.wallStarts[i].getEnd());\r\n        }\r\n        for (let i = 0; i < this.wallEnds.length; i++) {\r\n            retArray.push(this.wallEnds[i].getStart());\r\n        }\r\n        return retArray;\r\n    }\r\n\r\n    /** Checks if a wall is connected.\r\n     * @param wall A wall.\r\n     * @returns True in case of connection.\r\n     */\r\n    public isWallConnected(wall: Wall): boolean {\r\n        for (let i = 0; i < this.wallStarts.length; i++) {\r\n            if (this.wallStarts[i] === wall) {\r\n                return true;\r\n            }\r\n        }\r\n        for (let i = 0; i < this.wallEnds.length; i++) {\r\n            if (this.wallEnds[i] === wall) {\r\n                return true;\r\n            }\r\n        }\r\n        return false;\r\n    }\r\n\r\n    /**\r\n     *\r\n     */\r\n    public distanceFrom(x: number, y: number): number {\r\n        const distance = Utils.distance(x, y, this.x, this.y);\r\n        return distance;\r\n    }\r\n\r\n    /** Gets the distance from a wall.\r\n     * @param wall A wall.\r\n     * @returns The distance.\r\n     */\r\n    public distanceFromWall(wall: Wall): number {\r\n        return wall.distanceFrom(this.x, this.y);\r\n    }\r\n\r\n    /** Gets the distance from a corner.\r\n     * @param corner A corner.\r\n     * @returns The distance.\r\n     */\r\n    public distanceFromCorner(corner: Corner): number {\r\n        return this.distanceFrom(corner.x, corner.y);\r\n    }\r\n\r\n    /** Detaches a wall.\r\n     * @param wall A wall.\r\n     */\r\n    public detachWall(wall: Wall) {\r\n        Utils.removeValue(this.wallStarts, wall);\r\n        Utils.removeValue(this.wallEnds, wall);\r\n    }\r\n\r\n    /** Attaches a start wall.\r\n     * @param wall A wall.\r\n     */\r\n    public attachStart(wall: Wall) {\r\n        this.wallStarts.push(wall);\r\n    }\r\n\r\n    /** Attaches an end wall.\r\n     * @param wall A wall.\r\n     */\r\n    public attachEnd(wall: Wall) {\r\n        this.wallEnds.push(wall);\r\n    }\r\n\r\n    /** Get wall to corner.\r\n     * @param corner A corner.\r\n     * @return The associated wall or null.\r\n     */\r\n    public wallTo(corner: Corner): Wall {\r\n        for (let i = 0; i < this.wallStarts.length; i++) {\r\n            if (this.wallStarts[i].getEnd() === corner) {\r\n                return this.wallStarts[i];\r\n            }\r\n        }\r\n        return null;\r\n    }\r\n\r\n    /** Get wall from corner.\r\n     * @param corner A corner.\r\n     * @return The associated wall or null.\r\n     */\r\n    public wallFrom(corner: Corner): Wall {\r\n        for (let i = 0; i < this.wallEnds.length; i++) {\r\n            if (this.wallEnds[i].getStart() === corner) {\r\n                return this.wallEnds[i];\r\n            }\r\n        }\r\n        return null;\r\n    }\r\n\r\n    /** Get wall to or from corner.\r\n     * @param corner A corner.\r\n     * @return The associated wall or null.\r\n     */\r\n    public wallToOrFrom(corner: Corner): Wall {\r\n        return this.wallTo(corner) || this.wallFrom(corner);\r\n    }\r\n\r\n    public get startWalls(): Wall[] {\r\n        return this.wallStarts;\r\n    }\r\n\r\n    public get endWalls(): Wall[] {\r\n        return this.wallEnds;\r\n    }\r\n\r\n    /** Ensure we do not have duplicate walls (i.e. same start and end points) */\r\n    public removeDuplicateWalls() {\r\n        // delete the wall between these corners, if it exists\r\n        const wallEndpoints = {};\r\n        const wallStartpoints = {};\r\n        for (let i = this.wallStarts.length - 1; i >= 0; i--) {\r\n            if (this.wallStarts[i].getEnd() === this) {\r\n                // remove zero length wall\r\n                this.wallStarts[i].remove();\r\n            } else if (this.wallStarts[i].getEnd().id in wallEndpoints) {\r\n                // remove duplicated wall\r\n                this.wallStarts[i].remove();\r\n            } else {\r\n                wallEndpoints[this.wallStarts[i].getEnd().id] = true;\r\n            }\r\n        }\r\n        for (let i = this.wallEnds.length - 1; i >= 0; i--) {\r\n            if (this.wallEnds[i].getStart() === this) {\r\n                // removed zero length wall\r\n                this.wallEnds[i].remove();\r\n            } else if (this.wallEnds[i].getStart().id in wallStartpoints) {\r\n                // removed duplicated wall\r\n                this.wallEnds[i].remove();\r\n            } else {\r\n                wallStartpoints[this.wallEnds[i].getStart().id] = true;\r\n            }\r\n        }\r\n\r\n        // find and remove cycle ~ more than a single wall between 2 corners\r\n        for (const outWall of this.wallStarts) {\r\n            for (const inWall of this.wallEnds) {\r\n                if (outWall.getEnd() === inWall.getStart()) {\r\n                    outWall.remove();\r\n                }\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\n/**\r\n * Half Edges are created by Room.\r\n *\r\n * Once rooms have been identified, Half Edges are created for each interior wall.\r\n *\r\n * A wall can have two half edges if it is visible from both sides.\r\n */\r\nexport class HalfEdge {\r\n\r\n    /** The successor edge in CCW ??? direction. */\r\n    public next: HalfEdge;\r\n\r\n    /** The predecessor edge in CCW ??? direction. */\r\n    public prev: HalfEdge;\r\n\r\n    /** */\r\n    public offset: number;\r\n\r\n    /** When height of walls are modified, plane should be recreated */\r\n    public set height(value: number) {\r\n        this._height = value;\r\n        this.disposePlane();\r\n        this.generatePlane();\r\n    }\r\n\r\n    public get height(): number {\r\n        return this._height;\r\n    }\r\n\r\n    /** used for intersection testing... not convinced this belongs here */\r\n    public plane: ThreeMesh = null;\r\n\r\n    /** transform from world coords to wall planes (z=0) */\r\n    public interiorTransform = new Matrix4();\r\n\r\n    /** transform from world coords to wall planes (z=0) */\r\n    public invInteriorTransform = new Matrix4();\r\n\r\n    /** transform from world coords to wall planes (z=0) */\r\n    private exteriorTransform = new Matrix4();\r\n\r\n    /** transform from world coords to wall planes (z=0) */\r\n    private invExteriorTransform = new Matrix4();\r\n\r\n    private _height: number;\r\n\r\n    /** */\r\n\r\n    public edges: Edge[] = [];\r\n\r\n    /**\r\n     * Constructs a half edge.\r\n     * @param room The associated room.\r\n     * @param wall The corresponding wall.\r\n     * @param front True if front side.\r\n     */\r\n    constructor(private room: Room, public wall: Wall, public front: boolean) {\r\n        this.front = front || false;\r\n\r\n        this.offset = wall.thickness / 2.0;\r\n        this.height = wall.height;\r\n        if (this.front) {\r\n            this.wall.frontEdge = this;\r\n        } else {\r\n            this.wall.backEdge = this;\r\n        }\r\n        this.wall.updateInWallItems();\r\n    }\r\n\r\n    public showHideEdge(show: boolean): void {\r\n        this.edges.forEach(e => e.showHideEdge(show));\r\n    }\r\n\r\n    public updateVisibility(cameraPosition: Vector3): boolean {\r\n        let visibilityChanged: boolean = null;\r\n        this.edges.forEach(e => {\r\n            const edgeVisibilityChanged = e.updateVisibility(cameraPosition);\r\n            if (edgeVisibilityChanged !== null) {\r\n                visibilityChanged = edgeVisibilityChanged;\r\n            }\r\n        });\r\n        return visibilityChanged;\r\n    }\r\n\r\n    public updateVisiblity(visibility: boolean) {\r\n        this.edges.forEach(e => {\r\n            e.visible = visibility;\r\n            e.updateObjectVisibility();\r\n            e.setAllPlanesVisible();\r\n        });\r\n    }\r\n\r\n    public async redraw(): Promise<void> {\r\n        // this.edges.forEach(e => e.redraw());\r\n        for (let i = 0; i < this.edges.length; i++) {\r\n            await this.edges[i].redraw();\r\n        }\r\n    }\r\n\r\n    /**\r\n     *\r\n     */\r\n    public getTexture(): Texture {\r\n        if (this.front) {\r\n            return this.wall.frontTexture;\r\n        } else {\r\n            return this.wall.backTexture;\r\n        }\r\n    }\r\n\r\n    public getColor(): number {\r\n        if (this.front) {\r\n            return this.wall.frontColor;\r\n        } else {\r\n            return this.wall.backColor;\r\n        }\r\n    }\r\n\r\n    /**\r\n     *\r\n     */\r\n    public async setTexture(texture: Texture): Promise<void> {\r\n        if (texture) {\r\n            texture.roughness = !isNill(texture.roughness) ? texture.roughness : 0.8;\r\n        }\r\n\r\n        if (this.front) {\r\n            this.wall.frontTexture = texture;\r\n            this.wall.frontColor = defaultWallColor;\r\n        } else {\r\n            this.wall.backTexture = texture;\r\n            this.wall.backColor = defaultWallColor;\r\n        }\r\n        // this.redrawCallbacks.fire();\r\n        await this.redraw();\r\n    }\r\n\r\n    public setColor(value: number) {\r\n        if (this.front) {\r\n            this.wall.frontTexture = null;\r\n            this.wall.frontColor = value;\r\n        } else {\r\n            this.wall.backTexture = null;\r\n            this.wall.backColor = value;\r\n        }\r\n        // this.redrawCallbacks.fire();\r\n        this.redraw();\r\n    }\r\n\r\n    /**\r\n     * this feels hacky, but need wall items\r\n     */\r\n    public generatePlane() {\r\n        function transformCorner(corner) {\r\n            return new Vector3(corner.x, 0, corner.y);\r\n        }\r\n\r\n        this.offset = this.wall.thickness / 2.0;\r\n        this._height = this.wall.height;\r\n\r\n        const v1 = transformCorner(this.interiorStart());\r\n        const v2 = transformCorner(this.interiorEnd());\r\n        const v3 = v2.clone();\r\n        v3.y = this.wall.height;\r\n        const v4 = v1.clone();\r\n        v4.y = this.wall.height;\r\n\r\n        const geometry = new BufferGeometry().setFromPoints([v1, v2, v3, v4]);\r\n        const faceVertexIndexArray: Uint16Array = new Uint16Array([0, 1, 2, 0, 2, 3]);\r\n        const faceBufferAttribute: BufferAttribute = new BufferAttribute(faceVertexIndexArray, 1);\r\n        geometry.setIndex(faceBufferAttribute);\r\n        geometry.computeVertexNormals();\r\n        geometry.computeBoundingBox();\r\n\r\n        this.plane = new ThreeMesh(geometry, new MeshPhysicalMaterial(null));\r\n        this.plane.name = `half-edge-plane-${this.front ? 'front' : 'back'}`;\r\n        this.plane.castShadow = true;\r\n        Utils.setPlaneVisibility(this.plane, true);\r\n        this.plane.userData.edge = this;\r\n\r\n        this.computeTransforms(\r\n            this.interiorTransform, this.invInteriorTransform,\r\n            this.interiorStart(), this.interiorEnd());\r\n        this.computeTransforms(\r\n            this.exteriorTransform, this.invExteriorTransform,\r\n            this.exteriorStart(), this.exteriorEnd());\r\n    }\r\n\r\n    public disposePlane() {\r\n        if (this.plane) {\r\n            Utils.DisposeObject(this.plane);\r\n            this.plane = null;\r\n        }\r\n    }\r\n\r\n    public interiorDistance(): number {\r\n        const start = this.interiorStart();\r\n        const end = this.interiorEnd();\r\n        return Utils.distance(start.x, start.y, end.x, end.y);\r\n    }\r\n\r\n    private computeTransforms(transform, invTransform, start, end) {\r\n\r\n        const v1 = start;\r\n        const v2 = end;\r\n\r\n        const angle = Utils.angle(1, 0, v2.x - v1.x, v2.y - v1.y);\r\n\r\n        const tt = new Matrix4();\r\n        tt.makeTranslation(-v1.x, 0, -v1.y);\r\n        const tr = new Matrix4();\r\n        tr.makeRotationY(-angle);\r\n        transform.multiplyMatrices(tr, tt);\r\n        invTransform.copy(transform).invert();\r\n    }\r\n\r\n    /** Gets the distance from specified point.\r\n     * @param x X coordinate of the point.\r\n     * @param y Y coordinate of the point.\r\n     * @returns The distance.\r\n     */\r\n    public distanceTo(x: number, y: number): number {\r\n        // x, y, x1, y1, x2, y2\r\n        return Utils.pointDistanceFromLine(x, y,\r\n            this.interiorStart().x,\r\n            this.interiorStart().y,\r\n            this.interiorEnd().x,\r\n            this.interiorEnd().y);\r\n    }\r\n\r\n    public getStart() {\r\n        if (this.front) {\r\n            return this.wall.getStart();\r\n        } else {\r\n            return this.wall.getEnd();\r\n        }\r\n    }\r\n\r\n    public getEnd() {\r\n        if (this.front) {\r\n            return this.wall.getEnd();\r\n        } else {\r\n            return this.wall.getStart();\r\n        }\r\n    }\r\n\r\n    private getOppositeEdge(): HalfEdge {\r\n        if (this.front) {\r\n            return this.wall.backEdge;\r\n        } else {\r\n            return this.wall.frontEdge;\r\n        }\r\n    }\r\n\r\n    // these return an object with attributes x, y\r\n    public interiorEnd(): Vector2 {\r\n        const vec = this.halfAngleVector(this, this.next);\r\n        return new Vector2(this.getEnd().x + vec.x, this.getEnd().y + vec.y);\r\n    }\r\n\r\n    public interiorStart(): Vector2 {\r\n        const vec = this.halfAngleVector(this.prev, this);\r\n        return new Vector2(this.getStart().x + vec.x, this.getStart().y + vec.y);\r\n    }\r\n\r\n    public interiorCenter(): Vector2 {\r\n        return new Vector2((this.interiorStart().x + this.interiorEnd().x) / 2.0, (this.interiorStart().y + this.interiorEnd().y) / 2.0);\r\n    }\r\n\r\n    public exteriorEnd(): Vector2 {\r\n        const vec = this.halfAngleVector(this, this.next);\r\n        return new Vector2(this.getEnd().x - vec.x, this.getEnd().y - vec.y);\r\n    }\r\n\r\n    public exteriorStart(): Vector2 {\r\n        const vec = this.halfAngleVector(this.prev, this);\r\n        return new Vector2(this.getStart().x - vec.x, this.getStart().y - vec.y);\r\n    }\r\n\r\n    /** Get the corners of the half edge.\r\n     * @returns An array of x,y pairs.\r\n     */\r\n    public corners(): { x: number, y: number }[] {\r\n        return [this.interiorStart(), this.interiorEnd(),\r\n            this.exteriorEnd(), this.exteriorStart()];\r\n    }\r\n\r\n    /**\r\n     * Gets CCW angle from v1 to v2\r\n     */\r\n    private halfAngleVector(v1: HalfEdge, v2: HalfEdge): Vector2 {\r\n        // make the best of things if we dont have prev or next\r\n        let v1startX;\r\n        let v1startY;\r\n        let v1endX;\r\n        let v1endY;\r\n        let v2startX;\r\n        let v2startY;\r\n        let v2endX;\r\n        let v2endY;\r\n\r\n        if (!v1) {\r\n            v1startX = v2.getStart().x - (v2.getEnd().x - v2.getStart().x);\r\n            v1startY = v2.getStart().y - (v2.getEnd().y - v2.getStart().y);\r\n            v1endX = v2.getStart().x;\r\n            v1endY = v2.getStart().y;\r\n        } else {\r\n            v1startX = <number>v1.getStart().x;\r\n            v1startY = <number>v1.getStart().y;\r\n            v1endX = v1.getEnd().x;\r\n            v1endY = v1.getEnd().y;\r\n        }\r\n\r\n        if (!v2) {\r\n            v2startX = v1.getEnd().x;\r\n            v2startY = v1.getEnd().y;\r\n            v2endX = v1.getEnd().x + (v1.getEnd().x - v1.getStart().x);\r\n            v2endY = v1.getEnd().y + (v1.getEnd().y - v1.getStart().y);\r\n        } else {\r\n            v2startX = v2.getStart().x;\r\n            v2startY = v2.getStart().y;\r\n            v2endX = v2.getEnd().x;\r\n            v2endY = v2.getEnd().y;\r\n        }\r\n\r\n        // CCW angle between edges\r\n        const theta = Utils.angle2pi(\r\n            v1startX - v1endX,\r\n            v1startY - v1endY,\r\n            v2endX - v1endX,\r\n            v2endY - v1endY);\r\n\r\n        // cosine and sine of half angle\r\n        const cs = Math.cos(theta / 2.0);\r\n        const sn = Math.sin(theta / 2.0);\r\n\r\n        // rotate v2\r\n        const v2dx = v2endX - v2startX;\r\n        const v2dy = v2endY - v2startY;\r\n\r\n        const vx = v2dx * cs - v2dy * sn;\r\n        const vy = v2dx * sn + v2dy * cs;\r\n\r\n        // normalize\r\n        const mag = Utils.distance(0, 0, vx, vy);\r\n        const desiredMag = (this.offset) / sn;\r\n        const scalar = desiredMag / mag;\r\n\r\n        return new Vector2(vx * scalar, vy * scalar);\r\n    }\r\n\r\n    public get invExteriorQuaternion(): Quaternion {\r\n        const quaternion = new Quaternion();\r\n        quaternion.setFromRotationMatrix(this.invExteriorTransform);\r\n        return quaternion;\r\n    }\r\n}\r\n\r\nexport class Edge {\r\n    private _fillerColor = new Color(0xdddddd);\r\n    private readonly _wall: Wall;\r\n    private readonly _front: boolean;\r\n\r\n    private _fillerMaterial: THREE.MeshBasicMaterial;\r\n    private _wallMaterial: THREE.MeshPhongMaterial;\r\n    private _planes: {\r\n        exterior: Mesh,\r\n        interior: Mesh,\r\n        sides: Mesh[],\r\n        bottom: Mesh,\r\n        top: Mesh\r\n    } = {\r\n        exterior: null,\r\n        interior: null,\r\n        sides: null,\r\n        bottom: null,\r\n        top: null\r\n    };\r\n\r\n    private _last: {\r\n        color: number,\r\n        texture: Texture,\r\n        fillerMaterial: MeshBasicMaterial,\r\n        wallMaterial: MeshPhongMaterial,\r\n        height: number\r\n    } = {\r\n        color: null,\r\n        texture: null,\r\n        fillerMaterial: null,\r\n        wallMaterial: null,\r\n        height: null\r\n    };\r\n\r\n    public visible;\r\n\r\n    constructor(private _halfEdge: HalfEdge) {\r\n        if (_halfEdge) {\r\n            this._wall = _halfEdge.wall;\r\n            this._front = _halfEdge.front;\r\n            // this.updatePlanes();\r\n        }\r\n    }\r\n\r\n    public showHideEdge(show: boolean): void {\r\n        this._planeList().forEach(p => p.visible = show);\r\n    }\r\n\r\n    private _planeList(): Mesh[] {\r\n        return (this._planes.sides || []).concat([\r\n            this._planes.top,\r\n            this._planes.bottom,\r\n            this._planes.interior,\r\n            this._planes.exterior\r\n        ]).filter(x => x);\r\n    }\r\n\r\n    public getPlanes(): Mesh[] {\r\n        return this._planeList();\r\n    }\r\n\r\n    public getTopSideFillers(): Mesh[] {\r\n        return this._planes.sides.concat([this._planes.top]);\r\n    }\r\n\r\n    public async init(): Promise<void> {\r\n        // this.halfEdge.redrawCallbacks.add(this.redraw);\r\n        // halfEdge.itemAddedCallbacks.add(updateObjectVisibility);\r\n        // controls.cameraMovedCallbacks.add(updateVisibility);\r\n        await this.updatePlanes();\r\n        // addToScene();\r\n    }\r\n\r\n    public async redraw(): Promise<void> {\r\n        await this.updatePlanes();\r\n    }\r\n\r\n    // private removeFromScene() {\r\n    //   this.planeList().forEach((plane) => {\r\n    //     scene.remove(plane);\r\n    //     Utils.disposeObject(plane);\r\n    //   });\r\n    //   Object.keys(planes).forEach((key: string) => planes[key] = null);\r\n    //   Object.keys(last).forEach((key: string) => last[key] = null);\r\n    // }\r\n\r\n    // private addToScene() {\r\n    //   planeList().forEach((plane) => {\r\n    //     scene.add(plane);\r\n    //   });\r\n    //   updateVisibility();\r\n    // }\r\n\r\n    public updateVisibility(cameraPosition: Vector3): boolean {\r\n        // finds the normal from the specified halfEdge\r\n        const start = this._halfEdge.interiorStart();\r\n        const end = this._halfEdge.interiorEnd();\r\n        const x = end.x - start.x;\r\n        const y = end.y - start.y;\r\n        // rotate 90 degrees CCW\r\n        const normal = new Vector3(-y, 0, x);\r\n        normal.normalize();\r\n\r\n        // setup camera\r\n        const position = cameraPosition.clone();\r\n        const focus = new Vector3(\r\n            (start.x + end.x) / 2.0,\r\n            0,\r\n            (start.y + end.y) / 2.0);\r\n        const direction = position.sub(focus).normalize();\r\n\r\n        // find dot\r\n        const dot = normal.dot(direction);\r\n\r\n        // update visible\r\n        const newVisible = (dot >= 0);\r\n\r\n        // show or hide plans\r\n        this._planeList().forEach((plane: THREE.Mesh) =>\r\n            Utils.setPlaneVisibility(plane, newVisible)\r\n        );\r\n        if (newVisible !== this.visible) {\r\n            this.visible = newVisible;\r\n            this.updateObjectVisibility();\r\n            return newVisible;\r\n        } else {\r\n            return null;\r\n        }\r\n    }\r\n\r\n    public updateObjectVisibility(): void {\r\n        this._wall.items.forEach((item: WallItem) => {\r\n            item.updateEdgeVisibility(this);\r\n        });\r\n        this._wall.onItems.forEach((item: WallItem) => {\r\n            item.updateEdgeVisibility(this);\r\n        });\r\n    }\r\n\r\n    public setAllPlanesVisible() {\r\n        this._planeList().forEach((plane: THREE.Mesh) =>\r\n            Utils.setPlaneVisibility(plane, true)\r\n        );\r\n    }\r\n\r\n    private async _addMaterialMap(material: THREE.MeshPhongMaterial | THREE.MeshStandardMaterial, texture: Texture): Promise<void> {\r\n        const dimensions = new THREE.Vector2(\r\n            this._halfEdge.interiorDistance(),\r\n            this._wall.height - this._wall.thickness\r\n        );\r\n        texture.dimensions = dimensions.multiplyScalar(100);\r\n        switch (texture.type) {\r\n            case TextureType.Image:\r\n                material.map = await MaterialUtils.FromImage(texture);\r\n                material.map.colorSpace = SRGBColorSpace;\r\n                material.needsUpdate = true;\r\n                break;\r\n            case TextureType.CustomPattern:\r\n                material.map = await MaterialUtils.CustomTileMapTexture(texture, dimensions);\r\n                material.map.colorSpace = SRGBColorSpace;\r\n                material.needsUpdate = true;\r\n                break;\r\n            case TextureType.Basic:\r\n                material.map = await MaterialUtils.FromUrl(texture.url, texture.stretch, texture.tileSize, null, null, texture.dimensions, texture.tileRotation);\r\n                material.map.colorSpace = SRGBColorSpace;\r\n                material.needsUpdate = true;\r\n                break;\r\n            case TextureType.PBR:\r\n                material = material as MeshStandardMaterial;\r\n                if (texture.materializeUrl) {\r\n                    await MaterialUtils.loadMaterializeMaps(material, texture);\r\n                } else {\r\n                    material.map = await MaterialUtils.FromUrl(texture.url, texture.stretch, texture.tileSize, texture.repeatX, texture.repeatY, texture.dimensions, texture.tileRotation);\r\n                    material.map.colorSpace = SRGBColorSpace;\r\n                    material.roughnessMap = texture.roughnessMap ? await MaterialUtils.FromUrl(texture.roughnessMap, texture.stretch, texture.tileSize, texture.repeatX, texture.repeatY, texture.dimensions, texture.tileRotation) : null;\r\n                    material.bumpMap = texture.bumpMap ? await MaterialUtils.FromUrl(texture.bumpMap, texture.stretch, texture.tileSize, texture.repeatX, texture.repeatY, texture.dimensions, texture.tileRotation) : null;\r\n                    material.normalMap = texture.normalMap ? await MaterialUtils.FromUrl(texture.normalMap, texture.stretch, texture.tileSize, texture.repeatX, texture.repeatY, texture.dimensions, texture.tileRotation) : null;\r\n                    material.metalnessMap = texture.metalnessMap ? await MaterialUtils.FromUrl(texture.metalnessMap, texture.stretch, texture.tileSize, texture.repeatX, texture.repeatY, texture.dimensions, texture.tileRotation) : null;\r\n                    material.aoMap = texture.aoMap ? await MaterialUtils.FromUrl(texture.aoMap, texture.stretch, texture.tileSize, texture.repeatX, texture.repeatY, texture.dimensions, texture.tileRotation) : null;\r\n                    material.needsUpdate = true;\r\n                }\r\n        }\r\n    }\r\n\r\n    private _isValid(startEnd): boolean {\r\n        return !startEnd.find(e => !isFinite(e.x) || !isFinite(e.y));\r\n    }\r\n\r\n    private _updateFillerMaterial(): MeshBasicMaterial {\r\n        if (this._fillerMaterial) {\r\n            return this._fillerMaterial;\r\n        }\r\n        const material: MeshBasicMaterial = new MeshBasicMaterial({\r\n            color: this._fillerColor,\r\n            side: DoubleSide\r\n        });\r\n        return material;\r\n    }\r\n\r\n    private async _updateWallMaterial(texture: Texture, color: number = defaultEdgeColor): Promise<MeshPhongMaterial> {\r\n        const isSameColor = color && this._last.color && color === this._last.color;\r\n        const isSameTexture = sameTextures(texture, this._last.texture);\r\n        if (isSameColor && isSameTexture) {\r\n            return this._wallMaterial;\r\n        }\r\n        if (!isSameColor) {\r\n            this._last.color = color;\r\n        }\r\n        if (!isSameTexture) {\r\n            this._last.texture = Object.assign({}, texture);\r\n        }\r\n\r\n        let material;\r\n        material = new THREE.MeshPhongMaterial({\r\n            color: color,\r\n            side: THREE.FrontSide\r\n        });\r\n\r\n        if (texture) {\r\n            material = new THREE.MeshStandardMaterial({\r\n                color: color,\r\n                side: THREE.FrontSide,\r\n                roughness: !isNill(texture.roughness) ? texture.roughness : 0.8,\r\n                metalness: !isNill(texture.metalness) ? texture.metalness : 0,\r\n                bumpScale: !isNill(texture.bumpScale) ? texture.bumpScale : 1\r\n            });\r\n            await this._addMaterialMap(material, texture);\r\n        }\r\n        return material;\r\n    }\r\n\r\n    private _equalLastVec2(plane: string, paramSuffix: string): boolean {\r\n        const paramName = `${plane}${paramSuffix}`;\r\n        const getter = this._halfEdge[paramName]();\r\n        return this._last[paramName] &&\r\n            this._halfEdge[paramName] &&\r\n            this._last[paramName].x === getter.x &&\r\n            this._last[paramName].y === getter.y;\r\n    }\r\n\r\n    private _copyLast(plane: string, params: string[]): void {\r\n        params.forEach((param: string) => {\r\n            const paramName = param === 'InvTransform' ?\r\n                this._invTransformParam(plane) :\r\n                `${plane}${param}`;\r\n            const current = 'function' === typeof this._halfEdge[paramName] ?\r\n                this._halfEdge[paramName]() : this._halfEdge[paramName];\r\n            this._last[paramName] = current;\r\n        });\r\n    }\r\n\r\n    private _transformParam(plane: string): string {\r\n        return `${plane}Transform`;\r\n    }\r\n\r\n    private _invTransformParam(plane: string): string {\r\n        return `inv${plane.charAt(0).toUpperCase()}${plane.substr(1)}Transform`;\r\n    }\r\n\r\n    private _updateMainPlane(plane: string, material: MeshBasicMaterial | MeshPhongMaterial): Mesh {\r\n        let updatePlane: Mesh = this._planes[plane];\r\n        const geo: ShapeGeometry = this._createGeometry(\r\n            this._halfEdge[`${plane}Start`](),\r\n            this._halfEdge[`${plane}End`](),\r\n            this._halfEdge[this._transformParam(plane)],\r\n            this._halfEdge[this._invTransformParam(plane)],\r\n        );\r\n        if (!updatePlane) {\r\n            updatePlane = new ThreeMesh(geo, material);\r\n            updatePlane.name = 'edge';\r\n            updatePlane.userData.wall = this._wall;\r\n            updatePlane.castShadow = true;\r\n            updatePlane.receiveShadow = true;\r\n        } else {\r\n            updatePlane.geometry = geo;\r\n            updatePlane.material = material;\r\n            updatePlane.material.needsUpdate = true;\r\n        }/* else {\r\n      updatePlane = this.makeWall(\r\n        this.halfEdge[`${plane}Start`](),\r\n        this.halfEdge[`${plane}End`](),\r\n        this.halfEdge[this.transformParam(plane)],\r\n        this.halfEdge[this.invTransformParam(plane)],\r\n        material\r\n      );\r\n    }*/\r\n        return updatePlane;\r\n        // const oldPlane = this.planes[plane];\r\n        // const newPlane = this.makeWall(\r\n        //   this.halfEdge[`${plane}Start`](),\r\n        //   this.halfEdge[`${plane}End`](),\r\n        //   this.halfEdge[this.transformParam(plane)],\r\n        //   this.halfEdge[this.invTransformParam(plane)],\r\n        //   material\r\n        // );\r\n        // if (oldPlane) {\r\n        //   // scene.remove(oldPlane);\r\n        //   Utils.disposeObject(oldPlane);\r\n        // }\r\n        // // scene.add(newPlane);\r\n        // return newPlane;\r\n    }\r\n\r\n    private _updateBottomPlane(): Mesh {\r\n        const oldPlane = this._planes.bottom;\r\n        if (oldPlane &&\r\n            this._equalLastVec2('interior', 'Start') &&\r\n            this._equalLastVec2('interior', 'End') &&\r\n            this._equalLastVec2('exterior', 'Start') &&\r\n            this._equalLastVec2('exterior', 'End')\r\n        ) {\r\n            return oldPlane;\r\n        }\r\n        const newPlane = this._buildFiller(0, this._fillerMaterial);\r\n        if (oldPlane) {\r\n            // Dispose function does not actually remove the object from the scene\r\n            Utils.DisposeObject(oldPlane);\r\n            oldPlane.visible = false;\r\n        }\r\n        // scene.add(newPlane);\r\n        return newPlane;\r\n    }\r\n\r\n    private _updateTopPlane(): Mesh {\r\n        const oldPlane = this._planes.top;\r\n        if (oldPlane &&\r\n            this._last.height === this._wall.height &&\r\n            this._equalLastVec2('interior', 'Start') &&\r\n            this._equalLastVec2('interior', 'End') &&\r\n            this._equalLastVec2('exterior', 'Start') &&\r\n            this._equalLastVec2('exterior', 'End')\r\n        ) {\r\n            return oldPlane;\r\n        }\r\n        if (oldPlane) {\r\n            // Dispose function does not actually remove the object from the scene\r\n            Utils.DisposeObject(oldPlane);\r\n            oldPlane.visible = false;\r\n        }\r\n        const newPlane = this._buildFiller(this._wall.height, this._fillerMaterial);\r\n        // scene.add(newPlane);\r\n        return newPlane;\r\n    }\r\n\r\n    private _updateSidePlanes(): Mesh[] {\r\n        const oldPlanes = this._planes.sides;\r\n        if (oldPlanes &&\r\n            this._last.height === this._wall.height &&\r\n            this._equalLastVec2('interior', 'Start') &&\r\n            this._equalLastVec2('interior', 'End') &&\r\n            this._equalLastVec2('exterior', 'Start') &&\r\n            this._equalLastVec2('exterior', 'End')\r\n        ) {\r\n            return oldPlanes;\r\n        }\r\n        const newPlanes = [\r\n            this._buildSideFiller(this._halfEdge.interiorStart(), this._halfEdge.exteriorStart(), this._wall.height, this._fillerMaterial),\r\n            this._buildSideFiller(this._halfEdge.interiorEnd(), this._halfEdge.exteriorEnd(), this._wall.height, this._fillerMaterial)\r\n        ];\r\n        if (oldPlanes) {\r\n            oldPlanes.forEach(p => {\r\n                // Dispose function does not actually remove the object from the scene\r\n                Utils.DisposeObject(p);\r\n                p.visible = false;\r\n            });\r\n        }\r\n        // newPlanes.forEach(p => scene.add(p));\r\n        return newPlanes;\r\n    }\r\n\r\n    public async updatePlanes(): Promise<void> {\r\n        this._fillerMaterial = this._updateFillerMaterial();\r\n        if (this._isValid([this._halfEdge.exteriorStart(), this._halfEdge.exteriorEnd()])) {\r\n            this._planes.exterior = this._updateMainPlane('exterior', this._fillerMaterial);\r\n            if (this._halfEdge.getTexture() && this._halfEdge.getTexture().type !== TextureType.Image) {\r\n                this._updateUvs(this._planes.exterior);\r\n            }\r\n        }\r\n\r\n        const oldWallMaterial = this._wallMaterial;\r\n        this._wallMaterial = await this._updateWallMaterial(this._halfEdge.getTexture(), this._halfEdge.getColor());\r\n        if (this._isValid([this._halfEdge.interiorStart(), this._halfEdge.interiorEnd()])) {\r\n            // this.planes.interior = (!oldWallMaterial || oldWallMaterial === this.wallMaterial)\r\n            //   ? this.updateMainPlane('interior', this.wallMaterial)\r\n            //   : this.updateMainPlaneMaterial('interior', this.wallMaterial);\r\n            this._planes.interior = this._updateMainPlane('interior', this._wallMaterial);\r\n            if (this._halfEdge.getTexture() && this._halfEdge.getTexture().type !== TextureType.Image) {\r\n                this._updateUvs(this._planes.interior);\r\n            }\r\n        }\r\n\r\n        this._planes.bottom = this._updateBottomPlane();\r\n        this._planes.top = this._updateTopPlane();\r\n        this._planes.sides = this._updateSidePlanes();\r\n\r\n        this._last.fillerMaterial = this._fillerMaterial;\r\n        this._last.wallMaterial = this._wallMaterial;\r\n        this._last.height = this._wall.height;\r\n        this._copyLast('exterior', ['Start', 'End', 'Transform', 'InvTransform']);\r\n        this._copyLast('interior', ['Start', 'End', 'Transform', 'InvTransform']);\r\n    }\r\n\r\n    private _updateUvs(mesh: Mesh): void {\r\n        const dimensions = new THREE.Vector2(\r\n            this._halfEdge.interiorDistance(),\r\n            this._wall.height - this._wall.thickness\r\n        ).multiplyScalar(100);\r\n        const ratio: number = dimensions.x / dimensions.y;\r\n        let uvY: number;\r\n        const tempVector: Vector2 = new Vector2();\r\n        const uvArray: BufferAttribute = <BufferAttribute>mesh.geometry.attributes.uv;\r\n        if (uvArray) {\r\n            for (let i = 0; i < uvArray.count; i++) {\r\n                tempVector.fromBufferAttribute(uvArray, i);\r\n                uvY = tempVector.y;\r\n                uvY -= 0.5;\r\n                uvY /= ratio;\r\n                uvY += 0.5;\r\n                uvArray.setY(i, uvY);\r\n            }\r\n            uvArray.needsUpdate = true;\r\n        }\r\n    }\r\n\r\n    // start, end have x and y attributes (i.e. corners)\r\n    private _createGeometry(start, end, transform, invTransform): ShapeGeometry {\r\n        const v1 = this._toVec3(start);\r\n        const v2 = this._toVec3(end);\r\n        const v3 = v2.clone();\r\n        v3.y = this._wall.height;\r\n        const v4 = v1.clone();\r\n        v4.y = this._wall.height;\r\n\r\n        const points = [v1.clone(), v2.clone(), v3.clone(), v4.clone()];\r\n\r\n        points.forEach((p) => {\r\n            p.applyMatrix4(transform);\r\n        });\r\n\r\n        const shape = new Shape([\r\n            new Vector2(points[0].x, points[0].y),\r\n            new Vector2(points[1].x, points[1].y),\r\n            new Vector2(points[2].x, points[2].y),\r\n            new Vector2(points[3].x, points[3].y)\r\n        ]);\r\n\r\n        // add holes for each wall item\r\n        const itemHoles = this._wall.items\r\n            .filter((item: WallItem) => !isNaN(item.position.x))\r\n            .map((item: WallItem) => {\r\n                const pos = item.position.clone();\r\n                pos.applyMatrix4(transform);\r\n                const halfSize = item.halfSize;\r\n                const min = halfSize.clone().multiplyScalar(-1);\r\n                const max = halfSize.clone();\r\n                min.add(pos);\r\n                max.add(pos);\r\n\r\n                const holePoints = [\r\n                    new Vector2(min.x, min.y),\r\n                    new Vector2(max.x, min.y),\r\n                    new Vector2(max.x, max.y),\r\n                    new Vector2(min.x, max.y)\r\n                ];\r\n\r\n                return holePoints;\r\n            });\r\n        const polygons = Utils.polygonsUnion(itemHoles);\r\n        polygons.forEach(holePolygon => shape.holes.push(new Path(holePolygon)));\r\n\r\n        const geometry = new ShapeGeometry(shape);\r\n\r\n        const positionAttribute: BufferAttribute = <BufferAttribute>geometry.getAttribute('position');\r\n        const uvAttribute: BufferAttribute = <BufferAttribute>geometry.getAttribute('uv');\r\n        Utils.ApplyBufferAttributeMatrixTransform(positionAttribute, invTransform);\r\n\r\n        // make UVs\r\n        const totalDistance = Utils.distance(v1.x, v1.z, v2.x, v2.z);\r\n        const height = this._wall.height;\r\n\r\n        function vertexToUv(vertex) {\r\n            const x = Utils.distance(v1.x, v1.z, vertex.x, vertex.z) / totalDistance;\r\n            const y = vertex.y / height;\r\n            return new THREE.Vector2(x, y);\r\n        }\r\n\r\n        const tempUVArray: Vector2[] = [];\r\n        const positionDataAsVector3Array: Vector3[] = Utils.GetVector3ArrayFromBufferAttribute(positionAttribute.clone());\r\n\r\n        positionDataAsVector3Array.forEach((vertex: Vector3) => {\r\n            tempUVArray.push(vertexToUv(vertex));\r\n        });\r\n\r\n        tempUVArray.forEach((uvVector: Vector2, index) => {\r\n            uvAttribute.setXY(index, uvVector.x, uvVector.y);\r\n        });\r\n\r\n        uvAttribute.needsUpdate = true;\r\n        geometry.computeVertexNormals();\r\n        return geometry;\r\n    }\r\n\r\n    private _buildSideFiller(p1: Vector2, p2: Vector2, height: number, material: Material): Mesh {\r\n        const points = [\r\n            this._toVec3(p1),\r\n            this._toVec3(p2),\r\n            this._toVec3(p2, height),\r\n            this._toVec3(p1, height)\r\n        ];\r\n\r\n        const geometry = new BufferGeometry().setFromPoints(points);\r\n        const filler = new Mesh(geometry, material);\r\n        filler.castShadow = true;\r\n        filler.receiveShadow = true;\r\n        filler.name = 'edge-side-filler';\r\n        return filler;\r\n    }\r\n\r\n    private _buildFiller(height: number, material: Material): Mesh {\r\n        const points = [\r\n            this._toVec2(this._halfEdge.exteriorStart()),\r\n            this._toVec2(this._halfEdge.exteriorEnd()),\r\n            this._toVec2(this._halfEdge.interiorEnd()),\r\n            this._toVec2(this._halfEdge.interiorStart())\r\n        ];\r\n\r\n        const shape = new Shape(points);\r\n        const geometry = new ShapeGeometry(shape);\r\n\r\n        const filler = new Mesh(geometry, material);\r\n        filler.name = 'edge-filler';\r\n        filler.castShadow = true;\r\n        filler.receiveShadow = true;\r\n        filler.rotation.set(Math.PI / 2, 0, 0);\r\n        filler.position.y = height;\r\n        return filler;\r\n    }\r\n\r\n    private _toVec2(pos): Vector2 {\r\n        return new Vector2(pos.x, pos.y);\r\n    }\r\n\r\n    private _toVec3(pos: { x: number, y: number }, height = 0): Vector3 {\r\n        return new Vector3(pos.x, height, pos.y);\r\n    }\r\n}\r\n\r\nexport class Room {\r\n\r\n    public interiorCorners: Corner[] = [];\r\n\r\n    private edgePointer = null;\r\n    public edgeHeights = [];\r\n\r\n    public floorPlane: FloorPlaneItem = null;\r\n    public floorTexture: Texture;\r\n    public floorColor: number = 0xcccccc;\r\n    public ceilingPlane: Mesh = null;\r\n\r\n    // private floorChangeCallbacks = $.Callbacks();\r\n\r\n    constructor(\r\n        public corners: Corner[],\r\n        defaultTexture?: Texture\r\n    ) {\r\n        if (defaultTexture) {\r\n            this.floorTexture = defaultTexture;\r\n        }\r\n        this._setEdgePointer();\r\n        this._updateInteriorCorners();\r\n    }\r\n\r\n    public dispose(): void {\r\n        Utils.DisposeObject(this.floorPlane);\r\n        Utils.DisposeObject(this.ceilingPlane);\r\n    }\r\n\r\n    public getInteriorCorners(): Vector2[] {\r\n        return this.interiorCorners.map((c: { x: number, y: number }) => new Vector2(c.x, c.y));\r\n    }\r\n\r\n    public getUuid(): string {\r\n        const cornerUuids = Utils.map(this.corners, function (c) {\r\n            return c.id;\r\n        });\r\n        cornerUuids.sort();\r\n        return cornerUuids.join();\r\n    }\r\n\r\n    public getTexture() {\r\n        // const uuid = this.getUuid();\r\n        // return this.floorplan.getFloorTexture(uuid);\r\n        return this.floorTexture;\r\n    }\r\n\r\n    public getColor() {\r\n        // const uuid = this.getUuid();\r\n        // return this.floorplan.getFloorColor(uuid) || defaultFloorColor;\r\n        return this.floorColor;\r\n    }\r\n\r\n    public useTexture() {\r\n        // return defaultFloorColor === this.getColor();\r\n    }\r\n\r\n    /**\r\n     * textureStretch always true, just an argument for consistency with walls\r\n     */\r\n    // public setTexture(texture: Texture) {\r\n    //   // const uuid = this.getUuid();\r\n    //   // this.floorplan.setFloorTexture(uuid, texture);\r\n    //   // this.floorplan.deleteFloorColor(uuid);\r\n    //   // this.floorChangeCallbacks.fire();\r\n    // }\r\n\r\n    // public setColor(color: number) {\r\n    //   // const uuid = this.getUuid();\r\n    //   // this.floorplan.deleteFloorTexture(uuid);\r\n    //   // this.floorplan.setFloorColor(uuid, color);\r\n    //   // this.floorChangeCallbacks.fire();\r\n    // }\r\n\r\n    public updateWallHeights() {\r\n        let edge = this.edgePointer;\r\n        this.edgeHeights.length = 0;\r\n        while (true) {\r\n            this.edgeHeights.push(edge.wall.height);\r\n            if (edge.next === this.edgePointer) {\r\n                break;\r\n            } else {\r\n                edge = edge.next;\r\n            }\r\n        }\r\n    }\r\n\r\n    private setDefaultFloorTexture() {\r\n        // if (!this._defaultFloorTexture) {\r\n        //   return;\r\n        // }\r\n        // const uuid = this.getUuid();\r\n        // if (!this.floorplan.getFloorTexture(uuid) && !this.floorplan.getFloorColor(uuid)) {\r\n        //   this.setTexture(this._defaultFloorTexture);\r\n        // }\r\n    }\r\n\r\n    private _updateInteriorCorners() {\r\n        let edge = this.edgePointer;\r\n        this.edgeHeights.length = 0;\r\n        while (true) {\r\n            this.interiorCorners.push(edge.interiorStart());\r\n            edge.generatePlane();\r\n            this.edgeHeights.push(edge.height);\r\n            if (edge.next === this.edgePointer) {\r\n                break;\r\n            } else {\r\n                edge = edge.next;\r\n            }\r\n        }\r\n    }\r\n\r\n    private _setEdgePointer() {\r\n\r\n        let prevEdge = null;\r\n        let firstEdge = null;\r\n\r\n        for (let i = 0; i < this.corners.length; i++) {\r\n\r\n            const firstCorner = this.corners[i];\r\n            const secondCorner = this.corners[(i + 1) % this.corners.length];\r\n\r\n            // find if wall is heading in that direction\r\n            const wallTo = firstCorner.wallTo(secondCorner);\r\n            const wallFrom = firstCorner.wallFrom(secondCorner);\r\n            let edge: HalfEdge;\r\n\r\n            if (wallTo) {\r\n                edge = new HalfEdge(this, wallTo, true);\r\n            } else if (wallFrom) {\r\n                edge = new HalfEdge(this, wallFrom, false);\r\n            } else {\r\n                // something horrible has happened\r\n                console.log('corners arent connected by a wall, uh oh');\r\n            }\r\n\r\n\r\n            if (i === 0) {\r\n                firstEdge = edge;\r\n            } else {\r\n                edge.prev = prevEdge;\r\n                prevEdge.next = edge;\r\n                if (i + 1 === this.corners.length) {\r\n                    firstEdge.prev = edge;\r\n                    edge.next = firstEdge;\r\n                }\r\n            }\r\n            prevEdge = edge;\r\n        }\r\n\r\n        // hold on to an edge reference\r\n        this.edgePointer = firstEdge;\r\n    }\r\n\r\n    public get area(): number {\r\n        const polygon = this._polygonFromCorners(this.interiorCorners);\r\n        return Utils.polygonArea(polygon);\r\n    }\r\n\r\n    public get center(): { x: number, y: number } {\r\n        const polygon = this._polygonFromCorners(this.corners);\r\n        return Utils.polygonCenter(polygon);\r\n    }\r\n\r\n    private _polygonFromCorners(corners: Corner[]): Vector2[] {\r\n        return corners.map(c => new Vector2(c.x, c.y));\r\n    }\r\n}\r\n\r\n/**\r\n * A Wall Item is an entity to be placed related to a wall.\r\n */\r\nexport abstract class WallItem extends Item {\r\n\r\n    /** The currently applied wall */\r\n    public currentWall: Wall = null;\r\n\r\n    /** The currently applied wall edge. */\r\n    public currentWallEdge: HalfEdge = null;\r\n\r\n    /** Used for finding rotations */\r\n    private _refVec = new THREE.Vector2(0, 1.0);\r\n\r\n    private _positionYTolerance = 0.005;\r\n\r\n    /** */\r\n    private _wallOffsetScalar = 0;\r\n\r\n    /** */\r\n    private _sizeX = 0;\r\n\r\n    /** */\r\n    private _sizeY = 0;\r\n\r\n    private _flipped = false;\r\n    protected texture: Texture;\r\n\r\n    /** */\r\n    protected addToWall = false;\r\n\r\n    /** */\r\n    protected boundToFloor = false;\r\n\r\n    /** */\r\n    protected frontVisible = false;\r\n    protected backVisible = false;\r\n    private _hasFrontEdge = false;\r\n    private _hasBackEdge = false;\r\n    private _onFrontSide: boolean;\r\n\r\n    constructor(\r\n        metadata: Metadata,\r\n        object: Object3D | Mesh,\r\n        texture?: Texture,\r\n        handlers?: any\r\n    ) {\r\n        super(metadata, object, texture, handlers);\r\n\r\n        this.allowRotate = false;\r\n        if (texture) {\r\n            this.setTexture(texture);\r\n        }\r\n    }\r\n\r\n    /** */\r\n    public removed() {\r\n        if (!isNill(this.currentWallEdge) && this.addToWall) {\r\n            this.currentWallEdge.wall.removeItem(this);\r\n            this.redrawWall();\r\n        }\r\n    }\r\n\r\n    public removeFromWall(): void {\r\n        if (this.currentWall) {\r\n            this.currentWall.removeOnItem(this);\r\n            this.currentWall = undefined;\r\n            this.currentWallEdge = undefined;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Only hides item when entire wall is hidden\r\n     * This prevents items being set hidden for inner walls\r\n     * */\r\n    public updateEdgeVisibility(edge: Edge) {\r\n        if (this.currentWall) {\r\n            let shouldShow: boolean = false;\r\n            if (this.currentWall.backEdge) {\r\n                this.currentWall.backEdge.edges.forEach((e) => {\r\n                    if (e.visible) {\r\n                        shouldShow = true;\r\n                    }\r\n                });\r\n            }\r\n            if (this.currentWall.frontEdge) {\r\n                this.currentWall.frontEdge.edges.forEach(e => {\r\n                    if (e.visible) {\r\n                        shouldShow = true;\r\n                    }\r\n                });\r\n            }\r\n            this.visible = shouldShow;\r\n        }\r\n    }\r\n\r\n    /** */\r\n    public updateSize() {\r\n        this._wallOffsetScalar = this.getDepth() / 2;\r\n        this._sizeX = this.getWidth();\r\n        this._sizeY = this.getHeight();\r\n    }\r\n\r\n    /** */\r\n    public resized() {\r\n        if (this.boundToFloor) {\r\n            this.position.y = this._boundToFloorY();\r\n        }\r\n\r\n        this.updateSize();\r\n        this.redrawWall();\r\n    }\r\n\r\n    /** */\r\n    public placeOnEdge(edge: HalfEdge) {\r\n        if (!edge) {\r\n            return;\r\n        }\r\n        this._onFrontSide = edge.wall.frontEdge === edge;\r\n        this._changeWallEdge(edge);\r\n        this.updateSize();\r\n\r\n        // position not set\r\n        const center = edge.interiorCenter();\r\n        const newPos = this.positionSet ?\r\n            (edge.wall.amountWallMoved ? this.position.add(new Vector3(edge.wall.amountWallMoved.x, 0, 0)) : this.position.clone()) :\r\n            new THREE.Vector3(center.x, edge.wall.height / 2.0, center.y);\r\n        this._boundMove(newPos);\r\n        this.position.copy(newPos);\r\n        this.redrawWall();\r\n    }\r\n\r\n    public reposition(): void {\r\n        const newPos: Vector3 = this.position.clone();\r\n        this._boundMove(newPos);\r\n        this.position.copy(newPos);\r\n    }\r\n\r\n    public getFloorY(): number {\r\n        if (this.halfSize && this.currentWallEdge) {\r\n            return this._moveToYPosition(this.halfSize.y + this.elevation);\r\n        } else {\r\n            return this.position.y;\r\n        }\r\n    }\r\n\r\n    public isValidPosition(position: THREE.Vector3, rotation?: THREE.Euler, options?: any): CollisionInfo {\r\n        return {valid: !!this.currentWallEdge};\r\n    }\r\n\r\n    /** */\r\n    public moveToPosition(vec3: THREE.Vector3, intersection?: THREE.Intersection) {\r\n        if (intersection && this.currentWallEdge) {\r\n            if (intersection.object.userData.edge && intersection.object.userData.edge.wall !== this.currentWallEdge.wall) {\r\n                this._changeWallEdge(intersection.object.userData.edge);\r\n            }\r\n            this._boundMove(vec3);\r\n            this.position.copy(vec3);\r\n            this.redrawWall();\r\n        }\r\n    }\r\n\r\n    /** */\r\n    public moveTo2dPosition(x: number, y: number, edge: HalfEdge) {\r\n        const vec3 = new Vector3(x, this.position.y, y);\r\n        this._changeWallEdge(edge);\r\n        this._boundMove(vec3);\r\n        this.position.copy(vec3);\r\n        this.redrawWall();\r\n    }\r\n\r\n    /** */\r\n    public getWallOffset() {\r\n        return this._wallOffsetScalar;\r\n    }\r\n\r\n    public getStartX() {\r\n        return this.position.x - this.getSizeX() / 2 * Math.cos(this.rotation.y);\r\n    }\r\n\r\n    public getStartY() {\r\n        return this.position.z + this.getSizeX() / 2 * Math.sin(this.rotation.y);\r\n    }\r\n\r\n    public getEndX() {\r\n        return this.position.x + this.getSizeX() / 2 * Math.cos(this.rotation.y);\r\n    }\r\n\r\n    public getEndY() {\r\n        return this.position.z - this.getSizeX() / 2 * Math.sin(this.rotation.y);\r\n    }\r\n\r\n    /**\r\n     @returns x axis size of item's bounding box\r\n     */\r\n    public getSizeX() {\r\n        return this._sizeX;\r\n    }\r\n\r\n    /**\r\n     @returns y axis size of item's bounding box\r\n     */\r\n    public getSizeY() {\r\n        return this._sizeY;\r\n    }\r\n\r\n    public heightUpdated(amount?: number): void {\r\n        if (!isNill(amount)) {\r\n            this.position.y = this._moveToYPosition(this.position.y + amount);\r\n            this.redrawWall();\r\n        } else {\r\n            super.heightUpdated();\r\n        }\r\n    }\r\n\r\n    public updateGeometry(width: number, height: number) {\r\n        const geometry = Geometry.wallBox(width, height, this.getItemThickness());\r\n        (this.object as Mesh).geometry.dispose();\r\n        const rotation = this.rotation.y;\r\n        this.rotation.y = 0;\r\n        // this.initializeGeometry(geometry);\r\n        this.rotation.y = rotation;\r\n        this.resized();\r\n        this.redrawWall();\r\n    }\r\n\r\n    public async setTexture(texture: Texture): Promise<void> {\r\n        this.texture = texture && Object.assign({}, texture);\r\n        return await this.createMaterial(this.currentWallEdge ? this.currentWallEdge.wall.side : undefined);\r\n    }\r\n\r\n    public onWallMoved(wall: Wall) {\r\n        if (wall.frontEdge) {\r\n            this.placeOnEdge(wall.frontEdge);\r\n        }\r\n        if (wall.backEdge) {\r\n            this.placeOnEdge(wall.backEdge);\r\n        }\r\n    }\r\n\r\n    public updateMaterialVisibility(side: number = THREE.DoubleSide) {\r\n        if (!this.texture) {\r\n            return;\r\n        }\r\n        if (this.currentWallEdge) {\r\n            return;\r\n        }\r\n        const isSame = this._isWallSame();\r\n        if (!isSame) {\r\n            this.createMaterial(side, isSame);\r\n            return;\r\n        }\r\n        const textureMaterialFront = (this.object as any).material[4];\r\n        const textureMaterialBack = (this.object as any).material[5];\r\n        switch (side) {\r\n            case THREE.DoubleSide:\r\n                textureMaterialFront.visible = true;\r\n                textureMaterialBack.visible = true;\r\n                break;\r\n            case THREE.FrontSide:\r\n                textureMaterialFront.visible = this.frontVisible;\r\n                textureMaterialBack.visible = !this.frontVisible;\r\n                break;\r\n            case THREE.BackSide:\r\n                textureMaterialFront.visible = !this.frontVisible;\r\n                textureMaterialBack.visible = this.frontVisible;\r\n                break;\r\n        }\r\n    }\r\n\r\n    public async createTextureMaterial(options?): Promise<THREE.MeshPhongMaterial> {\r\n        const {\r\n            side = THREE.DoubleSide,\r\n            flip = false\r\n        } = options || {};\r\n        const texture = this.getTexture();\r\n\r\n        const material = new THREE.MeshPhongMaterial({side});\r\n        material.transparent = true;\r\n\r\n        if (texture) {\r\n            await this.addMaterialMap(material, texture, flip);\r\n        }\r\n\r\n        return material;\r\n    }\r\n\r\n    public getTexture(): Texture {\r\n        return this.texture;\r\n    }\r\n\r\n    protected async createMaterial(side: number = THREE.DoubleSide, isSame = true): Promise<void> {\r\n        let textureMaterialFront;\r\n        let textureMaterialBack;\r\n        switch (side) {\r\n            case THREE.DoubleSide:\r\n                this._flipped = !isSame;\r\n                textureMaterialFront = await this.createTextureMaterial({side: THREE.FrontSide, flip: this._flipped});\r\n                textureMaterialBack = await this.createTextureMaterial({side: THREE.FrontSide, flip: !this._flipped});\r\n                break;\r\n            case THREE.FrontSide:\r\n                this._flipped = !isSame;\r\n                if (this.frontVisible) {\r\n                    textureMaterialFront = await this.createTextureMaterial({side: THREE.FrontSide, flip: this._flipped});\r\n                } else {\r\n                    textureMaterialBack = await this.createTextureMaterial({side: THREE.BackSide, flip: !this._flipped});\r\n                }\r\n                break;\r\n            case THREE.BackSide: {\r\n                this._flipped = !isSame;\r\n                if (!this.frontVisible) {\r\n                    textureMaterialFront = await this.createTextureMaterial({side: THREE.FrontSide, flip: this._flipped});\r\n                } else {\r\n                    textureMaterialBack = await this.createTextureMaterial({\r\n                        side: THREE.BackSide, flip: !this._flipped\r\n                    });\r\n                }\r\n                break;\r\n            }\r\n        }\r\n        ((this.object as any).material as any) = this.getMaterials(textureMaterialFront, textureMaterialBack);\r\n    }\r\n\r\n    protected setYPositionBasedOnElevation() {\r\n        this.position.y = this.elevation + this.halfSize.y;\r\n    }\r\n\r\n    protected async addMaterialMap(material: THREE.MeshPhongMaterial, texture: Texture, flip: boolean): Promise<void> {\r\n        const dimensions = this.getMaterialMapDimensions();\r\n        texture.dimensions = dimensions.multiplyScalar(100);\r\n        switch (texture.type) {\r\n            case TextureType.Image:\r\n                if (flip) {\r\n                    material.map = await MaterialUtils.FromFlippedImage(texture, dimensions);\r\n                } else {\r\n                    material.map = await MaterialUtils.FromImage(texture);\r\n                }\r\n                break;\r\n            case TextureType.CustomPattern:\r\n                material.map = await MaterialUtils.CustomTileMapTexture(texture, dimensions);\r\n                break;\r\n            case TextureType.Basic:\r\n                material.map = await MaterialUtils.FromUrl(texture.url, texture.stretch, texture.tileSize, null, null, texture.dimensions, texture.tileRotation);\r\n                break;\r\n        }\r\n        // this.scene.needsUpdate = true;\r\n        // this.scene.textureLoadedCallbacks.fire();\r\n    }\r\n\r\n    protected getMaterialMapDimensions(): THREE.Vector2 {\r\n        return new THREE.Vector2(\r\n            this.getWidth(),\r\n            this.getHeight()\r\n        );\r\n    }\r\n\r\n    protected getMaterials(textureMaterialFront: THREE.Material, textureMaterialBack: THREE.Material): THREE.Material[] {\r\n        return [\r\n            MaterialUtils.defaultWindow.clone(), // Left side\r\n            MaterialUtils.defaultWindow.clone(), // Right side\r\n            MaterialUtils.defaultWindow.clone(), // Top side\r\n            MaterialUtils.defaultWindow.clone(), // Bottom side\r\n            textureMaterialFront || MaterialUtils.defaultWindow.clone(), // Front side\r\n            textureMaterialBack || MaterialUtils.defaultWindow.clone()   // Back side\r\n        ];\r\n    }\r\n\r\n    protected getItemThickness(): number {\r\n        return this.currentWall.thickness - 0.01;\r\n    }\r\n\r\n    /** */\r\n    protected redrawWall() {\r\n        if (this.currentWallEdge && this.currentWallEdge.wall) {\r\n            this.currentWallEdge.wall.fireRedraw();\r\n        }\r\n        // this.updateEdgeVisibility(true, this._onFrontSide);\r\n    }\r\n\r\n    /** */\r\n    private _changeWallEdge(wallEdge: HalfEdge) {\r\n        if (this.currentWallEdge === wallEdge) {\r\n            if (!this.currentWall) {\r\n                this.currentWall = wallEdge.wall;\r\n            }\r\n            return;\r\n        }\r\n        if (!isNill(this.currentWallEdge)) {\r\n            if (this.addToWall) {\r\n                this.currentWallEdge.wall.removeItem(this);\r\n                this.redrawWall();\r\n            } else {\r\n                this.currentWallEdge.wall.removeOnItem(this);\r\n            }\r\n        }\r\n        if (!wallEdge) {\r\n            return;\r\n        }\r\n\r\n        // find angle between wall normals\r\n        const normal2 = new THREE.Vector2();\r\n        const normal3 = Utils.GetFaceNormalFromBufferGeometry(wallEdge.plane.geometry, 0, 0);\r\n        normal2.x = normal3.x;\r\n        normal2.y = normal3.z;\r\n\r\n        const angle = Utils.angle(\r\n            this._refVec.x, this._refVec.y,\r\n            normal2.x, normal2.y);\r\n        this.rotation.y = (this.default180 ? Math.PI : 0) + angle;\r\n        this.traverse(c => c.matrixWorldNeedsUpdate = true);\r\n\r\n        // update currentWall\r\n        this.currentWall = wallEdge.wall;\r\n        this.currentWallEdge = wallEdge;\r\n        if (this.addToWall) {\r\n            wallEdge.wall.addItem(this);\r\n            if (this.metadata.texture) {\r\n                this.updateMaterialVisibility(wallEdge.wall.side);\r\n            }\r\n            this.redrawWall();\r\n        } else {\r\n            wallEdge.wall.addOnItem(this);\r\n        }\r\n    }\r\n\r\n    private _boundToFloorY() {\r\n        return 0.5 * this.getHeight() * this.scale.y + 0.01;\r\n    }\r\n\r\n    /** takes the move vec3, and makes sure object stays bounded on plane */\r\n    private _boundMove(vec3) {\r\n        const edge = this.currentWallEdge;\r\n        vec3.applyMatrix4(edge.interiorTransform);\r\n        edge.wall.itemsChanged = true;\r\n\r\n        if (vec3.x < this._sizeX / 2.0 + this._positionYTolerance) {\r\n            vec3.x = this._sizeX / 2.0 + this._positionYTolerance;\r\n        } else if (vec3.x > (edge.interiorDistance() - this._sizeX / 2.0 - this._positionYTolerance)) {\r\n            vec3.x = edge.interiorDistance() - this._sizeX / 2.0 - this._positionYTolerance;\r\n        }\r\n        if (this.boundToFloor) {\r\n            vec3.y = this._boundToFloorY();\r\n        } else {\r\n            if (this.elevationFixed || !this.elevationAdjustable) {\r\n                // if elevation is higher than the wall, use maxY\r\n                vec3.y = Math.min(this._getMaxY(edge), this.halfSize.y + this.elevation);\r\n            } else {\r\n                const maxY: number = this._getMaxY(edge);\r\n                const minY: number = this._getMinT();\r\n                if (vec3.y < minY) {\r\n                    vec3.y = minY;\r\n                } else if (vec3.y > maxY) {\r\n                    vec3.y = maxY;\r\n                }\r\n                this.elevation = vec3.y - this.halfSize.y;\r\n            }\r\n        }\r\n\r\n        vec3.z = this.getWallOffset();\r\n        vec3.applyMatrix4(edge.invInteriorTransform);\r\n    }\r\n\r\n    private _isWallSame(): boolean {\r\n        let isSame = false;\r\n        if (this.currentWallEdge) {\r\n            const onFrontSide = this.currentWallEdge === this.currentWallEdge.wall.frontEdge;\r\n            if (this._onFrontSide === undefined) {\r\n                this._onFrontSide = onFrontSide;\r\n            }\r\n            isSame = onFrontSide === this._onFrontSide;\r\n        }\r\n        return isSame;\r\n    }\r\n\r\n    private _getMaxY(edge: HalfEdge): number {\r\n        return edge.height - this._sizeY / 2.0 - this._positionYTolerance;\r\n    }\r\n\r\n    private _getMinT(): number {\r\n        return this._sizeY / 2.0 + this._positionYTolerance;\r\n    }\r\n\r\n    private _moveToYPosition(position: number): number {\r\n        const maxY: number = this._getMaxY(this.currentWallEdge);\r\n        const minY: number = this._getMinT();\r\n        if (position > maxY) {\r\n            this.elevation = maxY - this.halfSize.y;\r\n            return maxY;\r\n        }\r\n        if (position < minY) {\r\n            this.elevation = minY - this.halfSize.y;\r\n            return minY;\r\n        }\r\n        return position;\r\n    }\r\n}\r\n\r\nexport class InWallItem extends WallItem {\r\n\r\n    private readonly _frameWidth: number = 0.07;\r\n    private readonly _frameDepth: number = 0.1;\r\n    private readonly _defaultFrameColor: number = 9070146; // RAL-1011\r\n    private readonly _defaultDoorColor: number = 16777215; // RAL-9010\r\n\r\n    public opening = {\r\n        show: false,\r\n        double: false,\r\n        invertDirection: false,\r\n        invertSide: true\r\n    };\r\n\r\n    public frameColor: number = this._defaultFrameColor;\r\n    public doorColor: number = this._defaultDoorColor;\r\n    public windowColor: THREE.Color = new THREE.Color(0.0431, 0.0588, 0.0902);\r\n    public isGlass: boolean = false;\r\n\r\n    protected topFrame: THREE.Mesh;\r\n    protected leftFrame: THREE.Mesh;\r\n    protected rightFrame: THREE.Mesh;\r\n    protected bottomFrame: THREE.Mesh;\r\n    protected customMesh: THREE.Mesh;\r\n    protected frameMaterial: THREE.MeshPhongMaterial;\r\n    protected doorMaterialFront: THREE.MeshPhongMaterial;\r\n\r\n    protected windowMaterial: THREE.MeshPhongMaterial;\r\n    private _isWindow: boolean = false;\r\n    private _doorpost: boolean = false;\r\n\r\n    get doorpost(): boolean {\r\n        return this._doorpost;\r\n    }\r\n\r\n    constructor(\r\n        metadata: Metadata,\r\n        object: Object3D | Mesh,\r\n        texture?: Texture\r\n    ) {\r\n        super(metadata, object, texture);\r\n        this._setDefault();\r\n        this.frameTitle = 'Frame';\r\n        this.customMeshTitle = this._isWindow ? 'Window' : 'Door';\r\n        this.canChangeCustomMeshColor = !this._isWindow;\r\n\r\n        this.receiveShadow = true;\r\n        this.addToWall = true;\r\n        this._glassMaterialCheck();\r\n    }\r\n\r\n    public dispose(): void {\r\n        super.dispose();\r\n        Utils.DisposeObject(this.topFrame);\r\n        Utils.DisposeObject(this.leftFrame);\r\n        Utils.DisposeObject(this.rightFrame);\r\n        Utils.DisposeObject(this.bottomFrame);\r\n        Utils.DisposeObject(this.customMesh);\r\n        Utils.DisposeMaterial(this.frameMaterial);\r\n        Utils.DisposeMaterial(this.doorMaterialFront);\r\n        Utils.DisposeMaterial(this.windowMaterial);\r\n    }\r\n\r\n    public placeOnEdge(edge: HalfEdge) {\r\n        if (this.isCustom) {\r\n            const checkMaterial: THREE.MeshPhongMaterial = this._isWindow ? this.windowMaterial : this.doorMaterialFront;\r\n            if (!checkMaterial) {\r\n                this._createMaterials(THREE.DoubleSide);\r\n            }\r\n            this.createCustomMesh(this.getWidth(), this.getHeight());\r\n        }\r\n        super.placeOnEdge(edge);\r\n    }\r\n\r\n    /** */\r\n    public getWallOffset() {\r\n        return -this.currentWallEdge.offset;\r\n    }\r\n\r\n    public distanceFrom2d(x: number, y: number): number {\r\n        return Utils.pointDistanceFromLine(x, y,\r\n            this.getStartX(), this.getStartY(),\r\n            this.getEndX(), this.getEndY());\r\n    }\r\n\r\n    public onWallUpdated(wall: Wall) {\r\n        if (this.metadata.texture) {\r\n            this.updateMaterialVisibility(wall.side);\r\n        }\r\n    }\r\n\r\n    public updateFrameColor(color: number): void {\r\n        this.frameColor = color;\r\n        this.frameMaterial.color.setHex(color);\r\n        this.frameMaterial.needsUpdate = true;\r\n        // this.scene.needsUpdate = true;\r\n    }\r\n\r\n    public updateDoorColor(color: number): void {\r\n        this.doorColor = color;\r\n        this.doorMaterialFront.color.setHex(color);\r\n        this.doorMaterialFront.transparent = false;\r\n        this.doorMaterialFront.opacity = 1;\r\n        this.doorMaterialFront.map = undefined;\r\n        this.doorMaterialFront.needsUpdate = true;\r\n        // this.scene.needsUpdate = true;\r\n    }\r\n\r\n    public updateGlassMaterial() {\r\n        if (!this.isGlass) {\r\n            this.doorMaterialFront.color.setHex(0xdff0f2);\r\n            this.doorMaterialFront.transparent = true;\r\n            this.doorMaterialFront.alphaTest = 0;\r\n            this.doorMaterialFront.opacity = 0.2;\r\n            this.doorMaterialFront.map = undefined;\r\n            this.doorMaterialFront.needsUpdate = true;\r\n            this.doorMaterialFront.side = THREE.FrontSide;\r\n            this.isGlass = true;\r\n            this.customMesh.castShadow = false;\r\n        } else {\r\n            this.doorMaterialFront.transparent = false;\r\n            this.doorMaterialFront.opacity = 1;\r\n            this.isGlass = false;\r\n            this.customMesh.castShadow = true;\r\n        }\r\n    }\r\n\r\n    public updateGeometry(width: number, height: number): void {\r\n        if (this.isCustom) {\r\n            this.createCustomMesh(width, height);\r\n            // this.calculateHalfSize();\r\n            this.redrawWall();\r\n        } else {\r\n            super.updateGeometry(width, height);\r\n        }\r\n    }\r\n\r\n    public adjustWallBox(geometry: BoxGeometry) {\r\n        geometry.getAttribute('position').needsUpdate = true;\r\n        geometry.computeBoundingBox();\r\n        geometry.applyMatrix4(new Matrix4().makeTranslation(\r\n            -0.5 * (geometry.boundingBox.max.x + geometry.boundingBox.min.x),\r\n            -0.5 * (geometry.boundingBox.max.y + geometry.boundingBox.min.y),\r\n            -0.5 * (geometry.boundingBox.max.z + geometry.boundingBox.min.z)\r\n        ));\r\n        geometry.computeBoundingBox();\r\n        (this.object as Mesh).geometry = geometry;\r\n        this.calculateHalfSize();\r\n    }\r\n\r\n    public getVisibleMeshes(): THREE.Mesh[] {\r\n        if (this.isCustom && this.visible) {\r\n            const meshes: THREE.Mesh[] = [\r\n                this.leftFrame,\r\n                this.topFrame,\r\n                this.rightFrame,\r\n                this.customMesh\r\n            ];\r\n            if (this._isWindow /*|| this._doorpost*/) {\r\n                meshes.push(this.bottomFrame);\r\n            }\r\n            return meshes;\r\n        } else {\r\n            return super.getVisibleMeshes();\r\n        }\r\n    }\r\n\r\n    public async createTextureMaterial(options?): Promise<THREE.MeshPhongMaterial> {\r\n        if (this.isCustom) {\r\n            const {\r\n                side = THREE.DoubleSide,\r\n                flip = false\r\n            } = options || {};\r\n            const checkMaterial: THREE.MeshPhongMaterial = this._isWindow ? this.windowMaterial : this.doorMaterialFront;\r\n            if (!checkMaterial) {\r\n                this._createMaterials(side);\r\n            }\r\n            const texture = this.getTexture();\r\n            if (!texture) {\r\n                // reset to default texture\r\n                this._createMaterials(side);\r\n                this.createCustomMesh(this.getWidth(), this.getHeight());\r\n                return this._isWindow ? this.windowMaterial : this.doorMaterialFront;\r\n            }\r\n            const material: THREE.MeshPhongMaterial = this._isWindow ? this.windowMaterial : this.doorMaterialFront;\r\n            const defaultMaterial: THREE.MeshPhongMaterial = new THREE.MeshPhongMaterial();\r\n\r\n            material.transparent = false;\r\n            material.color = defaultMaterial.color.clone();\r\n            material.opacity = defaultMaterial.opacity;\r\n            material.refractionRatio = defaultMaterial.refractionRatio;\r\n            material.shininess = defaultMaterial.shininess;\r\n            material.specular = defaultMaterial.specular.clone();\r\n\r\n            // Allows for transparency in png's\r\n            material.alphaTest = 0.5;\r\n            // Makes sure the image in only projected once on the mesh\r\n            material.side = THREE.FrontSide;\r\n            // Removes white edges surrounding the image\r\n            material.transparent = true;\r\n\r\n            // material.color = new THREE.Color(1, 1, 1);\r\n            await this.addMaterialMap(material, texture, flip);\r\n            material.needsUpdate = true;\r\n            return material;\r\n        } else {\r\n            return await super.createTextureMaterial(options);\r\n        }\r\n    }\r\n\r\n    public createCustomMesh(width: number, height: number): void {\r\n        const halfWidth: number = width / 2;\r\n        const halfFrame: number = (this._frameWidth / 2);\r\n\r\n        this.leftFrame = this._createFrameSide(this._frameWidth, this._getHeightFrame(height), this._frameDepth);\r\n        this.leftFrame.rotation.set(this._isWindow ? 180 * (Math.PI / 180) : 0, 0, 0);\r\n        this.leftFrame.position.x = -halfWidth + halfFrame;\r\n        this.leftFrame.name = 'leftFrame';\r\n        if (!this._isWindow) {\r\n            this.leftFrame.position.y = -(this._frameWidth / 2) + 0.02;\r\n        }\r\n\r\n        this.topFrame = this._createFrameSide(this._frameWidth, width, this._frameDepth);\r\n        this.topFrame.rotation.set(0, this._isWindow ? 180 * (Math.PI / 180) : 0, -90 * (Math.PI / 180));\r\n        this.topFrame.position.y = (height / 2) - (this._frameWidth / 2);\r\n        this.topFrame.name = 'topFrame';\r\n\r\n        this.rightFrame = this._createFrameSide(this._frameWidth, this._getHeightFrame(height), this._frameDepth);\r\n        this.rightFrame.rotation.set(this._isWindow ? 180 * (Math.PI / 180) : 0, 0, -180 * (Math.PI / 180));\r\n        this.rightFrame.position.x = (width / 2) - (this._frameWidth / 2);\r\n        this.rightFrame.name = 'rightFrame';\r\n        if (!this._isWindow) {\r\n            this.rightFrame.position.y = -(this._frameWidth / 2) + 0.02;\r\n        }\r\n\r\n        if (this._isWindow /*|| this._doorpost*/) {\r\n            this.bottomFrame = this._createFrameSide(this._frameWidth, width, this._frameDepth);\r\n            this.bottomFrame.rotation.set(0, 180 * (Math.PI / 180), 90 * (Math.PI / 180));\r\n            this.bottomFrame.position.y = -(height / 2) + (this._frameWidth / 2);\r\n            this.bottomFrame.name = 'bottomFrame';\r\n        }\r\n\r\n        let customGeo: THREE.BoxGeometry;\r\n        if (this._isWindow) {\r\n            customGeo = new THREE.BoxGeometry(width - (2 * this._frameWidth) + 0.04, height - (2 * this._frameWidth) + 0.04, 0.024);\r\n        } else {\r\n            customGeo = new THREE.BoxGeometry(width - 0.02 * (this._frameWidth - 0.02), height - (this._frameWidth - 0.02), 0.04);\r\n        }\r\n        this.customMesh = new THREE.Mesh(customGeo, this._isWindow ? this.windowMaterial : this.doorMaterialFront);\r\n        this.customMesh.castShadow = this._isWindow ? false : !this.isGlass;\r\n        this.customMesh.renderOrder = -1;\r\n\r\n        this.customMesh.name = 'customMesh';\r\n        if (this._isWindow) {\r\n            this.customMesh.name += 'Window';\r\n        }\r\n        if (this.isGlass) {\r\n            this.customMesh.name += 'Glass';\r\n        }\r\n\r\n        if (this._isWindow) {\r\n            this.customMesh.position.z = -0.012;\r\n        } else {\r\n            this.customMesh.position.y = -(this._frameWidth / 2) + 0.01;\r\n            this.customMesh.position.z = 0.02;\r\n        }\r\n        this._getAdditionalTexture().then((frontAdditionalObj: THREE.Mesh) => {\r\n            if (frontAdditionalObj) {\r\n                const backAdditionalObj = frontAdditionalObj.clone(true);\r\n                backAdditionalObj.rotation.x = 180 * (Math.PI / 180);\r\n                if (this.additionalTexture.data) {\r\n                    frontAdditionalObj.position.set(\r\n                        -(width / 2) + this.additionalTexture.data.x, -(height / 2) + this.additionalTexture.data.y, 0.02);\r\n                    backAdditionalObj.position.set(\r\n                        -(width / 2) + this.additionalTexture.data.x, -(height / 2) + this.additionalTexture.data.y, -0.02);\r\n                }\r\n                this.customMesh.add(frontAdditionalObj);\r\n                this.customMesh.add(backAdditionalObj);\r\n            }\r\n        });\r\n\r\n        this.children.length = 0;\r\n        this.add(this.leftFrame, this.rightFrame, this.topFrame, this.customMesh);\r\n        if (this._isWindow /*|| this._doorpost*/) {\r\n            this.add(this.bottomFrame);\r\n        }\r\n        this.calculateHalfSize();\r\n        // this.scene.needsUpdate = true;\r\n    }\r\n\r\n    public cloneItem(): InWallItem {\r\n        const clone: InWallItem = this.createClass();\r\n        this.cloneProperties(clone);\r\n        clone.name = 'test clone';\r\n        return clone;\r\n    }\r\n\r\n    protected async createMaterial(side = THREE.DoubleSide, isSame = true): Promise<void> {\r\n        if (this.isCustom) {\r\n            await this.createTextureMaterial({side: THREE.FrontSide, flip: false});\r\n        } else {\r\n            await super.createTextureMaterial({side, isSame});\r\n        }\r\n    }\r\n\r\n    protected createClass(): InWallItem {\r\n        // create new object for proper dimensions\r\n        const mesh: Mesh = new Mesh(new BoxGeometry(this.halfSize.x * 2, this.halfSize.y * 2, this.halfSize.z * 2));\r\n        return new InWallItem(this.metadata, mesh);\r\n    }\r\n\r\n    protected cloneProperties(clone: InWallItem): void {\r\n        clone.userData = this.userData;\r\n        clone.doorMaterialFront = this.doorMaterialFront ? <MeshPhongMaterial>this.doorMaterialFront.clone() : undefined;\r\n        if (clone.doorMaterialFront) {\r\n            clone.doorMaterialFront.emissive = new THREE.Color(0x000000);\r\n            clone.doorMaterialFront.needsUpdate = true;\r\n        }\r\n        clone.windowMaterial = this.windowMaterial ? <MeshPhongMaterial>this.windowMaterial.clone() : undefined;\r\n        if (clone.windowMaterial) {\r\n            clone.windowMaterial.emissive = new THREE.Color(0x000000);\r\n            clone.windowMaterial.needsUpdate = true;\r\n        }\r\n        clone.frameMaterial = this.frameMaterial ? <MeshPhongMaterial>this.frameMaterial.clone() : undefined;\r\n        if (clone.frameMaterial) {\r\n            clone.frameMaterial.emissive = new THREE.Color(0x000000);\r\n            clone.frameMaterial.needsUpdate = true;\r\n        }\r\n        clone.frameColor = this.frameColor;\r\n        clone.doorColor = this.doorColor;\r\n        ((clone.object as Mesh).material as any) = [clone.frameMaterial, clone._isWindow ? clone.windowMaterial : clone.doorMaterialFront];\r\n        clone.texture = this.texture;\r\n        clone.additionalTexture = this.additionalTexture;\r\n        clone.isGlass = this.isGlass;\r\n    }\r\n\r\n    protected getMaterials(textureMaterialFront: THREE.Material, textureMaterialBack: THREE.Material): THREE.Material[] {\r\n        if (this.isCustom) {\r\n            return (this.object as Mesh).material as any;\r\n        } else {\r\n            return super.getMaterials(textureMaterialFront, textureMaterialBack);\r\n        }\r\n    }\r\n\r\n    protected getMaterialMapDimensions(): THREE.Vector2 {\r\n        if (this.isCustom) {\r\n            return new THREE.Vector2(\r\n                this.getWidth() - 0.14,\r\n                this.getHeight() - 0.07\r\n            );\r\n        } else {\r\n            return super.getMaterialMapDimensions();\r\n        }\r\n    }\r\n\r\n    protected initiateItemObject(data: any): void {\r\n        if (this.isCustom && data && data.geometry) {\r\n            data.geometry.verticesNeedUpdate = true;\r\n            data.geometry.computeBoundingBox();\r\n            data.geometry.applyMatrix4(new Matrix4().makeTranslation(\r\n                -0.5 * (data.geometry.boundingBox.max.x + data.geometry.boundingBox.min.x),\r\n                -0.5 * (data.geometry.boundingBox.max.y + data.geometry.boundingBox.min.y),\r\n                -0.5 * (data.geometry.boundingBox.max.z + data.geometry.boundingBox.min.z)\r\n            ));\r\n            data.geometry.computeBoundingBox();\r\n            const max = data.geometry.boundingBox.max.clone();\r\n            const min = data.geometry.boundingBox.min.clone();\r\n            this.halfSize = max.sub(min).divideScalar(2);\r\n        }\r\n    }\r\n\r\n    private _setDefault(): void {\r\n        // workaround because properties are not available yet when creating window/door from loading from cloud/local\r\n        this.frameColor = this.metadata.frameColor ? this.metadata.frameColor : this._defaultFrameColor; // RAL-1011\r\n        this.doorColor = this.metadata.doorColor ? this.metadata.doorColor : this._defaultDoorColor; // RAL-9010\r\n        this.windowColor = this.metadata.windowColor ? this.metadata.windowColor : new THREE.Color(0xdff0f2);\r\n        this._isWindow = this.metadata.itemType === ItemType.InWall;\r\n        this._doorpost = this.metadata.doorpost;\r\n        this.isGlass = this.metadata.isGlass ? this.metadata.isGlass : false;\r\n    }\r\n\r\n    private _createMaterials(side: THREE.Side): void {\r\n        this._setDefault();\r\n        this.frameMaterial = new THREE.MeshPhongMaterial({side: side, name: 'frameMaterial'});\r\n        this.frameMaterial.color = new THREE.Color(this.frameColor);\r\n        if (this._isWindow) {\r\n            this.windowMaterial = new THREE.MeshPhongMaterial({side: side, color: this.windowColor, name: 'windowMaterial'});\r\n            this.windowMaterial.transparent = true;\r\n            this.windowMaterial.alphaTest = 0;\r\n            this.windowMaterial.opacity = 0.2;\r\n            this.windowMaterial.map = undefined;\r\n            this.windowMaterial.needsUpdate = true;\r\n            this.windowMaterial.side = THREE.FrontSide;\r\n            ((this.object as Mesh).material as any) = [this.frameMaterial, this.windowMaterial];\r\n        } else {\r\n            this.doorMaterialFront = new THREE.MeshPhongMaterial({side: side, name: 'doorMaterialFront'});\r\n            this.doorMaterialFront.color = new THREE.Color(this.doorColor);\r\n            if (this._doorpost) {\r\n                this.doorMaterialFront.transparent = true;\r\n                this.doorMaterialFront.opacity = 0;\r\n            }\r\n            ((this.object as Mesh).material as any) = [this.frameMaterial, this.doorMaterialFront];\r\n        }\r\n    }\r\n\r\n    private _getHeightFrame(height: number): number {\r\n        return height - (this._isWindow ? 2 * (this._frameWidth - 0.02) : this._frameWidth - 0.02);\r\n    }\r\n\r\n    private _createFrameSide(width: number, height: number, depth: number): THREE.Mesh {\r\n        const outerFrameWidth: number = width - 0.02;\r\n        const outerFrameGeo = new THREE.BoxGeometry(outerFrameWidth, height, depth);\r\n        const outerFrame = new THREE.Mesh(outerFrameGeo, this.frameMaterial);\r\n        outerFrame.castShadow = true;\r\n        outerFrame.receiveShadow = true;\r\n\r\n        const innerFrameGeo = new THREE.BoxGeometry(0.02, height, depth / 2);\r\n        const innerFrame = new THREE.Mesh(innerFrameGeo, this.frameMaterial);\r\n        innerFrame.castShadow = true;\r\n        innerFrame.receiveShadow = true;\r\n        innerFrame.position.x = (outerFrameWidth / 2) + 0.01;\r\n        innerFrame.position.z = -depth / 4;\r\n\r\n        const frameSide = new THREE.Object3D();\r\n        frameSide.add(outerFrame, innerFrame);\r\n        const boundingBox = new THREE.Box3().setFromObject(frameSide);\r\n        const bbCenterPivot = new THREE.Vector3();\r\n        boundingBox.getCenter(bbCenterPivot);\r\n        const delta = new THREE.Vector3().sub(bbCenterPivot).setY(0);\r\n        frameSide.children.forEach((child: any) => {\r\n            child.position.add(delta);\r\n        });\r\n        const frameSideMesh = new Mesh();\r\n        frameSideMesh.add(outerFrame, innerFrame);\r\n        return frameSideMesh;\r\n    }\r\n\r\n    private _getAdditionalTexture(): Promise<THREE.Mesh> {\r\n        return new Promise((resolve: Function, reject: Function) => {\r\n            // if (this.additionalTexture) {\r\n            //     LoaderUtils.LoadObjModel(this.additionalTexture.url).then((obj: THREE.Mesh) => {\r\n            //         const additionalObj: THREE.Mesh = <Mesh>obj.clone(true);\r\n            //         additionalObj.children.map(c => c.position.set(0, 0, 0));\r\n            //         if (this.additionalTexture.scale) {\r\n            //             additionalObj.scale.multiplyScalar(this.additionalTexture.scale);\r\n            //         }\r\n            //         resolve(additionalObj);\r\n            //     });\r\n            // } else {\r\n                resolve(null);\r\n            // }\r\n        });\r\n    }\r\n\r\n    private _glassMaterialCheck() {\r\n        let meshesFound = 0;\r\n        this.traverse((child) => {\r\n            if (child instanceof Mesh && child.material) {\r\n                meshesFound++;\r\n                child.castShadow = true;\r\n                const materials: any = !Array.isArray(child.material) ? [child.material] : child.material;\r\n                materials.forEach(material => {\r\n                    if (material.name && (material.name === 'Fixed_Glass' || material.name === 'Default_Glass')) {\r\n                        child.castShadow = false;\r\n                        material.transparent = true;\r\n                        material.opacity = 0.2;\r\n                        material.format = THREE.RGBAFormat;\r\n                        material.needsUpdate = true;\r\n                    }\r\n                });\r\n            }\r\n        });\r\n\r\n        // Remove to ignore old door models\r\n        if (meshesFound === 1) {\r\n            this.traverse((child) => {\r\n                if (child instanceof Mesh) {\r\n                    child.castShadow = true;\r\n                    const materials: any = !Array.isArray(child.material) ? [child.material] : child.material;\r\n                    materials.forEach(m => {\r\n                        m.visible = m.name && (m.name === 'Fixed_Glass' || m.name === 'Default_Glass') ? m.visible = false : m.visible = true;\r\n                    });\r\n                }\r\n            });\r\n        }\r\n    }\r\n}\r\n\r\nexport class WallItemGroup extends ItemGroup {\r\n\r\n    public currentWallEdge: HalfEdge;\r\n    public currentWall: Wall;\r\n    public elevationAdjustable: boolean = true;\r\n\r\n    private _positionYTolerance = 0.005;\r\n    private _originalRotation: Euler;\r\n    private _onFrontSide: boolean;\r\n    private _wallOffsetScalar = 0;\r\n    private _sizeX = 0;\r\n    private _sizeY = 0;\r\n    private _refVec = new THREE.Vector2(0, 1.0);\r\n\r\n    constructor() {\r\n        super();\r\n        this.metadata = {\r\n            itemType: 22\r\n        };\r\n        this.userData.itemType = this.metadata.itemType;\r\n    }\r\n\r\n    protected redrawWall() {\r\n        if (this.currentWallEdge && this.currentWallEdge.wall) {\r\n            this.currentWallEdge.wall.fireRedraw();\r\n        }\r\n    }\r\n\r\n    public isValidPosition(position: Vector3, rotation?: Euler, options?: any): CollisionInfo {\r\n        return { valid: true };\r\n    }\r\n\r\n    public moveToPosition(vec3: Vector3, intersection?: Intersection) {\r\n        if (intersection) {\r\n            if (!this.currentWallEdge && (this.items[0] as WallItem).currentWallEdge) {\r\n                this.currentWallEdge = (this.items[0] as WallItem).currentWallEdge;\r\n            }\r\n            if (this.currentWallEdge) {\r\n                this._boundMove(vec3);\r\n                this.position.copy(vec3);\r\n                this.redrawWall();\r\n            }\r\n        }\r\n    }\r\n\r\n    public createBoundaryBox(): void {\r\n        this.boundaryBox.setFromObject(this);\r\n        const max = this.boundaryBox.max.clone();\r\n        const min = this.boundaryBox.min.clone();\r\n        this.halfSize = max.sub(min).divideScalar(2);\r\n        this.updateSize();\r\n    }\r\n\r\n    public centerPivot(): void {\r\n        const boundaryBoxCenter = this.boundaryBoxCenter;\r\n        this.position.copy(boundaryBoxCenter);\r\n        this.items.forEach(i => {\r\n            const originalPosition = i.position.clone();\r\n            const newPosition = originalPosition.sub(boundaryBoxCenter);\r\n            i.position.copy(newPosition);\r\n        });\r\n    }\r\n\r\n    public updateSize() {\r\n        this._wallOffsetScalar = this.halfSize.z;\r\n        this._sizeX = this.halfSize.x * 2;\r\n        this._sizeY = this.halfSize.y * 2;\r\n    }\r\n\r\n    public onWallMoved(wall: Wall) {\r\n        if (wall.frontEdge) {\r\n            this.placeOnEdge(wall.frontEdge);\r\n        }\r\n        if (wall.backEdge) {\r\n            this.placeOnEdge(wall.backEdge);\r\n        }\r\n    }\r\n\r\n    public placeOnEdge(edge: HalfEdge) {\r\n        this._originalRotation = this.rotation.clone();\r\n\r\n        if (!edge) { return; }\r\n        this._onFrontSide = edge.wall.frontEdge === edge;\r\n        this._changeWallEdge(edge);\r\n\r\n        const newPos = edge.wall.amountWallMoved ? this.position.add(new Vector3(edge.wall.amountWallMoved.x, 0, 0)) : this.position.clone();\r\n        this._boundMove(newPos);\r\n        this.position.copy(newPos);\r\n        this.redrawWall();\r\n        this.allowRotate = false;\r\n    }\r\n\r\n    public handleGroupCreation(): void {\r\n        this.items.forEach((i) => {\r\n            if (!this.currentWallEdge) {\r\n                this.currentWallEdge = (i as WallItem).currentWallEdge;\r\n                this.currentWall = this.currentWallEdge.wall;\r\n            }\r\n            this.currentWall.removeOnItem(i);\r\n        });\r\n        this.placeOnEdge(this.currentWallEdge);\r\n    }\r\n\r\n    private _changeWallEdge(wallEdge: HalfEdge) {\r\n        // find angle between wall normals\r\n        const normal2 = new THREE.Vector2();\r\n        const normal3 = Utils.GetFaceNormalFromBufferGeometry(wallEdge.plane.geometry, 0, 0);\r\n        normal2.x = normal3.x;\r\n        normal2.y = normal3.z;\r\n\r\n        const wallRotation = Utils.angle(\r\n            this._refVec.x, this._refVec.y,\r\n            normal2.x, normal2.y);\r\n\r\n        // transfer rotation from child to parent and reset boundary box\r\n        if (this.items[0].rotation.y !== 0) {\r\n            this.items.forEach((i) => {\r\n                const itemWorldPosition: Vector3 = i.getWorldPosition(new Vector3());\r\n                this.remove(i);\r\n                this.rotation.y = wallRotation;\r\n                i.position.copy(itemWorldPosition);\r\n                this.attach(i);\r\n                this.rotation.y = 0;\r\n            });\r\n\r\n            this.createBoundaryBox();\r\n        }\r\n\r\n        this.rotation.y = wallRotation;\r\n        this.traverse(c => c.matrixWorldNeedsUpdate = true);\r\n\r\n        // update currentWall\r\n        this.currentWall = wallEdge.wall;\r\n        this.currentWallEdge = wallEdge;\r\n        wallEdge.wall.addOnItem(this as any);\r\n    }\r\n\r\n    public updateEdgeVisibility(edge: Edge) {\r\n        if (this.currentWall) {\r\n            let shouldShow: boolean = false;\r\n            if (this.currentWall.backEdge) {\r\n                this.currentWall.backEdge.edges.forEach((e) => {\r\n                    if (e.visible) {\r\n                        shouldShow = true;\r\n                    }\r\n                });\r\n            }\r\n            if (this.currentWall.frontEdge) {\r\n                this.currentWall.frontEdge.edges.forEach(e => {\r\n                    if (e.visible) {\r\n                        shouldShow = true;\r\n                    }\r\n                });\r\n            }\r\n            this.visible = shouldShow;\r\n        }\r\n    }\r\n\r\n    private _boundMove(vec3: Vector3) {\r\n        const edge = this.currentWallEdge;\r\n        vec3.applyMatrix4(edge.interiorTransform);\r\n        edge.wall.itemsChanged = true;\r\n\r\n        if (vec3.x < this._sizeX / 2.0 + this._positionYTolerance) {\r\n            vec3.x = this._sizeX / 2.0 + this._positionYTolerance;\r\n        } else if (vec3.x > (edge.interiorDistance() - this._sizeX / 2.0 - this._positionYTolerance)) {\r\n            vec3.x = edge.interiorDistance() - this._sizeX / 2.0 - this._positionYTolerance;\r\n        }\r\n\r\n        if (this.elevationFixed || !this.elevationAdjustable) {\r\n            vec3.y = this.position.y;\r\n        } else {\r\n            const maxY: number = this._getMaxY(edge);\r\n            const minY: number = this._getMinY();\r\n            if (vec3.y < minY) {\r\n                vec3.y = minY;\r\n            } else if (vec3.y > maxY) {\r\n                vec3.y = maxY;\r\n            }\r\n            this.elevation = vec3.y - this.halfSize.y;\r\n        }\r\n\r\n        vec3.z = this._wallOffsetScalar;\r\n        vec3.applyMatrix4(edge.invInteriorTransform);\r\n    }\r\n\r\n    private _getMaxY(edge: HalfEdge): number {\r\n        return edge.height - this.halfSize.y - this._positionYTolerance;\r\n    }\r\n\r\n    private _getMinY(): number {\r\n        return this.halfSize.y + this._positionYTolerance;\r\n    }\r\n}\r\n"]}