hart-estate-widget 0.0.10 → 0.0.11

package/build/store/houseStore.js

@@ -0,0 +1,675 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("core-js/modules/web.dom-collections.iterator.js");
+
+require("core-js/modules/es.array.reduce.js");
+
+require("core-js/modules/es.promise.js");
+
+var _react = _interopRequireDefault(require("react"));
+
+var _mobx = require("mobx");
+
+var _api = require("../api");
+
+var THREE = _interopRequireWildcard(require("three"));
+
+var _FBXLoader = require("three/examples/jsm/loaders/FBXLoader");
+
+var _modelHelpers = require("../utils/modelHelpers");
+
+var _threeCsg = _interopRequireDefault(require("../utils/csg/three-csg"));
+
+var _wallTexture = _interopRequireDefault(require("../assets/img/wall-texture.jpg"));
+
+var _doorTexture = _interopRequireDefault(require("../assets/img/door-texture.jpeg"));
+
+var _exteriorWallTexture = _interopRequireDefault(require("../assets/img/exterior-wall-texture.jpeg"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+(0, _mobx.configure)({
+  useProxies: 'never'
+});
+const clippedBuildingConstant = 0.4;
+const doorMaterialOptions = {
+  color: '#DADADA',
+  side: THREE.DoubleSide
+};
+const modelLoader = new _FBXLoader.FBXLoader();
+
+class HouseStore {
+  constructor(modelStore) {
+    _defineProperty(this, "modelStore", null);
+
+    _defineProperty(this, "houseGroup", new THREE.Group());
+
+    _defineProperty(this, "wallsGroup", new THREE.Group());
+
+    _defineProperty(this, "doorsGroup", new THREE.Group());
+
+    _defineProperty(this, "doorMaterial", null);
+
+    _defineProperty(this, "wallsMaterial", null);
+
+    _defineProperty(this, "wallsColor", '#FFFFFF');
+
+    _defineProperty(this, "exteriorWallsMaterial", null);
+
+    _defineProperty(this, "wallsTextures", []);
+
+    _defineProperty(this, "isDoorsVisible", true);
+
+    _defineProperty(this, "isFullBuildingVisible", true);
+
+    _defineProperty(this, "wallsMaterialType", 'texture');
+
+    _defineProperty(this, "globalPlane", null);
+
+    _defineProperty(this, "clippingPlanes", []);
+
+    _defineProperty(this, "furnitureData", {});
+
+    _defineProperty(this, "loadedModels", {});
+
+    _defineProperty(this, "loadedTextures", {});
+
+    (0, _mobx.makeAutoObservable)(this);
+    this.modelStore = modelStore;
+    this.globalPlane = new THREE.Plane(new THREE.Vector3(0, -this.wallsHeight - 0.5, 0), 1);
+    this.clippingPlanes = [this.globalPlane];
+    this.setCenterPosition().loadTextures().then(() => {
+      this.createFloors().createSpaceBetweenWalls().createWalls().createDoors();
+    });
+    (0, _api.loadFurnitureData)(this.furniture).then(resp => {
+      this.furnitureData = resp;
+      this.loadFurniture(0);
+    });
+  }
+
+  get textureLoader() {
+    return this.modelStore.textureLoader;
+  }
+
+  get sceneScale() {
+    return this.modelStore.sceneScale;
+  }
+
+  get wallsHeight() {
+    return this.modelStore.wallsHeight;
+  }
+
+  get json() {
+    return this.modelStore.json;
+  }
+
+  get vertices() {
+    return this.json.Vertices;
+  }
+
+  get rooms() {
+    return this.json.Floors[0].Units[0].Rooms;
+  }
+
+  get walls() {
+    return this.json.Floors[0].Walls;
+  }
+
+  get exteriorWalls() {
+    return this.json.Floors[0].ExteriorWalls;
+  }
+
+  get doors() {
+    return this.json.Floors[0].Doors.map(door => this.getParsedAperture(door, 'Door'));
+  }
+
+  get windows() {
+    return this.json.Floors[0].Windows.map(window => this.getParsedAperture(window, 'Window'));
+  }
+
+  get apertures() {
+    return [...this.doors, ...this.windows];
+  }
+
+  get doorsHeight() {
+    return this.wallsHeight / 2 + this.wallsHeight / 4;
+  }
+
+  get wallMaterialOptions() {
+    return {
+      clippingPlanes: this.clippingPlanes,
+      color: this.wallsColor,
+      side: THREE.DoubleSide
+    };
+  }
+
+  get furniture() {
+    return this.rooms.reduce((acc, _ref) => {
+      let {
+        Furniture
+      } = _ref;
+      if (!Furniture || !Furniture.length) return acc;
+      return [...acc, ...Furniture];
+    }, []);
+  }
+
+  getVertexById(vertexId) {
+    return this.vertices.find(_ref2 => {
+      let {
+        ID
+      } = _ref2;
+      return ID === vertexId;
+    });
+  }
+
+  getWallById(wallId) {
+    return this.walls.find(_ref3 => {
+      let {
+        ID
+      } = _ref3;
+      return ID === wallId;
+    });
+  }
+
+  getParsedAperture(aperture, type) {
+    const {
+      Location,
+      Walls
+    } = aperture;
+    const position = new THREE.Vector3(Location.X, Location.Y, Location.Z);
+    const secondWall = this.getParsedWallById(Walls[1], 1);
+    const line = new THREE.Line3(secondWall.start, secondWall.end);
+    const positionOnFirstWall = new THREE.Vector3();
+    line.closestPointToPoint(position, true, positionOnFirstWall);
+    const lineBetweenWalls = new THREE.Line3(position, positionOnFirstWall);
+    const distanceBetweenWalls = lineBetweenWalls.distance();
+    const positionBetweenWalls = lineBetweenWalls.getCenter(positionOnFirstWall);
+
+    const parsedAperture = _objectSpread(_objectSpread({}, aperture), {}, {
+      Type: type,
+      Depth: distanceBetweenWalls,
+      Location: {
+        X: positionBetweenWalls.x,
+        Y: positionBetweenWalls.y,
+        Z: positionBetweenWalls.z
+      }
+    });
+
+    return parsedAperture;
+  }
+
+  getParsedWallById(wallId) {
+    let scale = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.sceneScale;
+    const currentWall = this.getWallById(wallId);
+    const [coord1, coord2] = currentWall.Vertices.map(vertexId => this.getVertexById(vertexId).Location);
+    return {
+      id: wallId,
+      start: {
+        x: coord1.X * scale,
+        y: coord1.Y * scale,
+        z: 0
+      },
+      end: {
+        x: coord2.X * scale,
+        y: coord2.Y * scale,
+        z: 0
+      }
+    };
+  }
+
+  getVerticesFromParsedWalls(walls) {
+    return walls.reduce((acc, _ref4) => {
+      let {
+        start,
+        end
+      } = _ref4;
+      acc.push(new THREE.Vector2(start.x, start.y), new THREE.Vector2(end.x, end.y));
+      return acc;
+    }, []);
+  }
+
+  createFloors() {
+    this.rooms.forEach(_ref5 => {
+      let {
+        Walls,
+        Type
+      } = _ref5;
+      const walls = Walls.map(wallId => this.getParsedWallById(wallId));
+      const params = (0, _modelHelpers.getFloorParams)(Type);
+      const vertices = this.getVerticesFromParsedWalls(walls);
+      const shape = new THREE.Shape(vertices);
+      const geometry = new THREE.ShapeGeometry(shape);
+      const material = new THREE.MeshBasicMaterial({
+        color: params.color,
+        side: THREE.DoubleSide
+      });
+      const mesh = new THREE.Mesh(geometry, material);
+      mesh.name = 'FloorMesh';
+      this.loadTexture(params.texture, [0.5, 0.5], texture => {
+        const textureMaterial = new THREE.MeshBasicMaterial({
+          color: params.color,
+          side: THREE.DoubleSide,
+          map: texture
+        });
+        mesh.material = textureMaterial;
+        this.houseGroup.add(mesh);
+      });
+    });
+    return this;
+  }
+
+  createSpaceBetweenWalls() {
+    const walls = this.exteriorWalls.map(wallId => this.getParsedWallById(wallId));
+    const vertices = this.getVerticesFromParsedWalls(walls);
+    const clippedDepth = (this.wallsHeight + 0.5) * clippedBuildingConstant + 0.006;
+    const depth = this.wallsHeight + 0.002;
+    const shapeWithHoles = new THREE.Shape(vertices);
+    const shape = new THREE.Shape(vertices);
+    this.rooms.forEach(_ref6 => {
+      let {
+        Walls
+      } = _ref6;
+      const roomWalls = Walls.map(wallId => this.getParsedWallById(wallId));
+      const roomVertices = this.getVerticesFromParsedWalls(roomWalls);
+      shapeWithHoles.holes.push(new THREE.Shape(roomVertices));
+    });
+    const clippedGeometry = new THREE.ExtrudeGeometry(shapeWithHoles, {
+      depth: clippedDepth,
+      bevelEnabled: false
+    });
+    const flatGeometry = new THREE.ExtrudeGeometry(shape, {
+      depth: 0.001,
+      bevelEnabled: false
+    });
+    const geometry = new THREE.ExtrudeGeometry(shapeWithHoles, {
+      depth,
+      bevelEnabled: false
+    });
+    const clippedMaterial = new THREE.MeshBasicMaterial({
+      side: THREE.DoubleSide,
+      color: '#5C5C5C'
+    });
+    const material = new THREE.MeshBasicMaterial(_objectSpread(_objectSpread({}, this.wallMaterialOptions), {}, {
+      color: '#5C5C5C'
+    }));
+    const clippedMesh = new THREE.Mesh(clippedGeometry, clippedMaterial);
+    const flatMesh = new THREE.Mesh(flatGeometry, material);
+    const mesh = new THREE.Mesh(geometry, material);
+    clippedMesh.position.z = -0.005;
+    flatMesh.position.z = -0.005;
+    mesh.position.z = -0.001;
+    const additionalApertureWidth = 0.25;
+    const clippedMeshWithApertures = this.subtractApertures(clippedMesh, this.apertures, additionalApertureWidth);
+    const meshWithApertures = this.subtractApertures(mesh, this.apertures, additionalApertureWidth);
+    clippedMeshWithApertures.name = 'ClippedSpaceBetweenWalls';
+    meshWithApertures.name = 'SpaceBetweenWalls';
+    flatMesh.name = 'FlatSpaceBetweenWalls';
+    this.houseGroup.add(flatMesh, clippedMeshWithApertures, meshWithApertures);
+    return this;
+  }
+
+  createWalls() {
+    const createWall = (wallId, isExterior) => {
+      const {
+        start,
+        end
+      } = this.getParsedWallById(wallId);
+      const wallHalfWidth = 0.005;
+      const wallShape = new THREE.Shape([new THREE.Vector2(start.x + wallHalfWidth, start.y - wallHalfWidth), new THREE.Vector2(end.x + wallHalfWidth, end.y - wallHalfWidth), new THREE.Vector2(end.x - wallHalfWidth, end.y + wallHalfWidth), new THREE.Vector2(start.x - wallHalfWidth, start.y + wallHalfWidth)]);
+      const wallGeometry = new THREE.ExtrudeGeometry(wallShape, {
+        depth: this.wallsHeight,
+        bevelEnabled: false
+      });
+      const wallPadGeometry = new THREE.ExtrudeGeometry(wallShape, {
+        depth: 0.001,
+        bevelEnabled: false
+      });
+      const wallMaterial = isExterior ? this.exteriorWallsMaterial : this.wallsMaterial;
+      const wallPadMaterial = new THREE.MeshBasicMaterial(_objectSpread(_objectSpread({}, this.wallMaterialOptions), {}, {
+        color: '#5C5C5C'
+      }));
+      const wallClippedPadMaterial = new THREE.MeshBasicMaterial({
+        side: THREE.DoubleSide,
+        color: '#5C5C5C'
+      });
+      const apertures = this.apertures.filter(aperture => aperture.Walls.some(id => wallId === id));
+      const wallMesh = this.subtractApertures(new THREE.Mesh(wallGeometry, wallMaterial), apertures);
+      const wallPadMesh = new THREE.Mesh(wallPadGeometry, wallPadMaterial);
+      const wallClippedPadMesh = new THREE.Mesh(wallPadGeometry, wallClippedPadMaterial);
+      wallPadMesh.position.z = this.wallsHeight;
+      wallClippedPadMesh.position.z = (this.wallsHeight + 0.5) * clippedBuildingConstant + 0.001;
+      const wallClippedPadMeshWithApertures = this.subtractApertures(wallClippedPadMesh, apertures);
+      wallClippedPadMeshWithApertures.visible = false;
+      const wallGroup = new THREE.Group();
+      wallGroup.name = 'Wall';
+      wallGroup.buildingId = wallId;
+      wallGroup.isExterior = isExterior;
+      wallGroup.add(wallMesh, wallPadMesh, wallClippedPadMeshWithApertures);
+      this.wallsGroup.add(wallGroup);
+    };
+
+    this.rooms.forEach(_ref7 => {
+      let {
+        Walls
+      } = _ref7;
+      return Walls.forEach(wallId => createWall(wallId, false));
+    });
+    this.exteriorWalls.forEach(wallId => createWall(wallId, true));
+    this.houseGroup.add(this.wallsGroup);
+    return this;
+  }
+
+  createDoors() {
+    this.doors.forEach(_ref8 => {
+      let {
+        Width,
+        Location,
+        Rotation
+      } = _ref8;
+      const geometry = new THREE.BoxGeometry(Width * this.sceneScale, 0.1, this.doorsHeight);
+      let mesh = new THREE.Mesh(geometry, this.doorMaterial);
+      mesh.position.x = Location.X * this.sceneScale;
+      mesh.position.y = Location.Y * this.sceneScale;
+      mesh.position.z = this.doorsHeight / 2;
+      mesh.rotation.z = THREE.Math.degToRad(Rotation.Yaw);
+      this.doorsGroup.add(mesh);
+    });
+    this.houseGroup.add(this.doorsGroup);
+    return this;
+  }
+
+  subtractApertures(mesh, apertures) {
+    let additionalWidth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    let resultMesh = mesh;
+    apertures.forEach(_ref9 => {
+      let {
+        Width,
+        Depth,
+        Location,
+        Rotation,
+        Type
+      } = _ref9;
+      const isDoor = Type === 'Door';
+      const apertureGeometry = new THREE.BoxGeometry((Width + additionalWidth) * this.sceneScale, Depth * this.sceneScale + 1, (isDoor ? this.doorsHeight : this.wallsHeight / 2) + additionalWidth * this.sceneScale);
+      const apertureMaterial = new THREE.MeshBasicMaterial({
+        color: '#00B4F7'
+      });
+      const apertureMesh = new THREE.Mesh(apertureGeometry, apertureMaterial);
+      apertureMesh.rotation.z = THREE.Math.degToRad(Rotation.Yaw);
+      apertureMesh.position.x = Location.X * this.sceneScale;
+      apertureMesh.position.y = Location.Y * this.sceneScale;
+      apertureMesh.position.z = isDoor ? this.doorsHeight / 2 : this.wallsHeight / 2;
+      apertureMesh.updateMatrix();
+      resultMesh.updateMatrix();
+
+      const apertureBSP = _threeCsg.default.fromMesh(apertureMesh);
+
+      const wallBSP = _threeCsg.default.fromMesh(resultMesh);
+
+      const resultBSP = wallBSP.subtract(apertureBSP);
+      resultMesh = _threeCsg.default.toMesh(resultBSP, mesh.matrix, resultMesh.material);
+    });
+    return resultMesh;
+  }
+
+  setCenterPosition() {
+    const walls = this.exteriorWalls.map(wallId => this.getParsedWallById(wallId));
+    const {
+      maxX,
+      minX,
+      maxY,
+      minY
+    } = (0, _modelHelpers.getMinMaxCoordinates)(walls);
+    this.houseGroup.position.set(-(maxX + minX) / 2, -(maxY + minY) / 2);
+    return this;
+  }
+
+  loadTexture(img) {
+    let repeat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [1, 1];
+    let callback = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : () => {};
+    this.textureLoader.load(img, texture => {
+      texture.wrapS = texture.wrapT = THREE.RepeatWrapping;
+      texture.repeat.set(repeat[0], repeat[1]);
+      texture.flipY = false;
+      callback(texture);
+    });
+  }
+
+  loadTextures() {
+    const assets = [{
+      img: _wallTexture.default,
+      repeat: [0.5, 0.5],
+      callback: texture => {
+        this.wallsTextures.push({
+          image: _wallTexture.default,
+          texture: texture
+        });
+        this.wallsMaterial = new THREE.MeshBasicMaterial(_objectSpread(_objectSpread({}, this.wallMaterialOptions), {}, {
+          map: texture
+        }));
+      }
+    }, {
+      img: _exteriorWallTexture.default,
+      repeat: [1, 1],
+      callback: texture => {
+        this.wallsTextures.push({
+          image: _exteriorWallTexture.default,
+          texture: texture
+        });
+        this.exteriorWallsMaterial = new THREE.MeshBasicMaterial(_objectSpread(_objectSpread({}, this.wallMaterialOptions), {}, {
+          map: texture,
+          color: '#FFFFFF'
+        }));
+      }
+    }, {
+      img: _doorTexture.default,
+      repeat: [1, 1],
+      callback: texture => {
+        this.doorMaterial = new THREE.MeshBasicMaterial(_objectSpread(_objectSpread({}, doorMaterialOptions), {}, {
+          map: texture
+        }));
+      }
+    }];
+    return Promise.all(assets.map(_ref10 => {
+      let {
+        img,
+        repeat,
+        callback
+      } = _ref10;
+      return new Promise(resolve => {
+        this.loadTexture(img, repeat, texture => {
+          callback(texture);
+          resolve();
+        });
+      });
+    }));
+  }
+
+  loadFurniture(index) {
+    const furniture = this.furniture[index];
+    if (!furniture) return;
+    const furnitureData = this.furnitureData[furniture.Model];
+
+    if (!furnitureData) {
+      this.loadFurniture(index + 1);
+      return;
+    }
+
+    const {
+      mesh,
+      textures
+    } = furnitureData;
+    const modelPath = "".concat(_api.API_URL, "/storage/furniture/").concat(mesh);
+    const {
+      Location,
+      Rotation,
+      Model: ModelName
+    } = furniture;
+    const {
+      X,
+      Y,
+      Z
+    } = Location;
+    const promises = textures.map(url => {
+      const texturePath = "".concat(_api.API_URL, "/storage/furniture/").concat(url);
+      return new Promise(resolve => {
+        this.textureLoader.load(texturePath, texture => resolve(texture));
+      });
+    });
+
+    const onTexturesLoaded = (result, model) => {
+      const materials = result.map(texture => new THREE.MeshBasicMaterial({
+        map: texture,
+        opacity: 0,
+        transparent: true
+      }));
+      model.traverse(node => {
+        if (node.isMesh) node.material = materials;
+      });
+      this.houseGroup.add(model);
+      this.loadFurniture(index + 1);
+      const opacityInterval = setInterval(() => {
+        model.children[0].material.forEach(material => {
+          material.opacity += 0.01;
+
+          if (material.opacity >= 1) {
+            clearInterval(opacityInterval);
+            material.opacity = 1;
+          }
+        });
+      }, 1);
+    };
+
+    const onModelLoaded = originalModel => {
+      const model = originalModel.clone();
+      model.scale.set(this.sceneScale, this.sceneScale, this.sceneScale);
+      model.position.set(X * this.sceneScale, Y * this.sceneScale, Z * this.sceneScale);
+      model.rotation.set(Math.PI / 2, THREE.Math.degToRad(Rotation.Yaw), 0);
+      const loadedTextures = this.loadedTextures[ModelName];
+
+      if (loadedTextures) {
+        onTexturesLoaded(loadedTextures, model);
+        return;
+      }
+
+      Promise.all(promises).then(result => {
+        onTexturesLoaded(result, model);
+        this.loadedTextures[ModelName] = result;
+      });
+    };
+
+    const loadedModel = this.loadedModels[ModelName];
+
+    if (loadedModel) {
+      onModelLoaded(loadedModel);
+      return;
+    }
+
+    modelLoader.load(modelPath, model => {
+      this.loadedModels[ModelName] = model;
+      onModelLoaded(model);
+    });
+  } // Actions
+
+
+  setDoorsVisibility(value) {
+    this.isDoorsVisible = value;
+    this.doorsGroup.children.forEach(door => door.visible = value);
+  }
+
+  setCurrentWallsMaterialType(value) {
+    this.wallsMaterialType = value;
+    this.wallsGroup.children.forEach(_ref11 => {
+      let {
+        children,
+        isExterior
+      } = _ref11;
+      const wall = children[0];
+
+      if (value === 'texture') {
+        wall.material = isExterior ? this.exteriorWallsMaterial : this.wallsMaterial;
+        return;
+      }
+
+      const color = isExterior ? '#FFFFFF' : this.wallsColor;
+      wall.material = new THREE.MeshBasicMaterial(_objectSpread(_objectSpread({}, this.wallMaterialOptions), {}, {
+        color
+      }));
+    });
+    this.doorsGroup.children.forEach(door => {
+      if (value === 'texture') {
+        door.material = this.doorMaterial;
+        return;
+      }
+
+      door.material = new THREE.MeshBasicMaterial(doorMaterialOptions);
+    });
+  }
+
+  setCurrentWallColor(color) {
+    this.wallsColor = color;
+    this.wallsMaterial.color.set(color);
+    this.wallsGroup.children.forEach(_ref12 => {
+      let {
+        children,
+        isExterior
+      } = _ref12;
+      if (isExterior) return;
+      const wall = children[0];
+      wall.material.color.set(color);
+    });
+  }
+
+  setCurrentWallTexture(texture) {
+    this.wallsMaterial = new THREE.MeshBasicMaterial(_objectSpread(_objectSpread({}, this.wallMaterialOptions), {}, {
+      map: texture
+    }));
+    this.setCurrentWallsMaterialType('texture');
+  }
+
+  addWallTexture(image) {
+    this.loadTexture(image, [0.5, 0.5], texture => {
+      this.wallsTextures.push({
+        image,
+        texture
+      });
+      this.setCurrentWallTexture(texture);
+    });
+  }
+
+  setFullBuildingVisibility(value) {
+    this.isFullBuildingVisible = value;
+    this.globalPlane.constant = this.isFullBuildingVisible ? 1 : clippedBuildingConstant;
+    this.wallsGroup.children.forEach(_ref13 => {
+      let {
+        children
+      } = _ref13;
+      return children[2].visible = !value;
+    });
+  }
+
+  setPlanMode() {
+    this.setDoorsVisibility(false);
+    this.setFullBuildingVisibility(false);
+    this.setCurrentWallsMaterialType('color');
+  }
+
+}
+
+var _default = HouseStore;
+exports.default = _default;