hart-estate-widget 0.0.48 → 0.0.51

package/build/store/houseStore.js

@@ -1,18 +1,12 @@
 "use strict";
 
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
 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");
-
-require("core-js/modules/es.string.includes.js");
-
 var _react = _interopRequireDefault(require("react"));
 
 var _mobx = require("mobx");
@@ -39,10 +33,36 @@ var _exteriorWallTextureRoughness = _interopRequireDefault(require("../assets/im
 
 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 _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 _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
 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; }
@@ -52,20 +72,26 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
 (0, _mobx.configure)({
   useProxies: 'never'
 });
-const clippedBuildingConstant = 0.4;
-const doorMaterialOptions = {
+var clippedBuildingConstant = 0.4;
+var doorMaterialOptions = {
   color: '#DADADA',
   side: THREE.DoubleSide
 };
-const modelLoader = new _FBXLoader.FBXLoader();
+var modelLoader = new _FBXLoader.FBXLoader();
+
+var createDefaultMaterial = function createDefaultMaterial(options) {
+  return new THREE.MeshStandardMaterial(_objectSpread({
+    roughness: 1,
+    metalness: 0
+  }, options));
+};
+
+var HouseStore = /*#__PURE__*/function () {
+  function HouseStore(modelStore) {
+    var _this = this;
 
-const createDefaultMaterial = options => new THREE.MeshStandardMaterial(_objectSpread({
-  roughness: 1,
-  metalness: 0
-}, options));
+    _classCallCheck(this, HouseStore);
 
-class HouseStore {
-  constructor(modelStore) {
     _defineProperty(this, "modelStore", null);
 
     _defineProperty(this, "apiStore", new _apiStore.default(_store.default.config.API_URL));
@@ -114,740 +140,813 @@ class HouseStore {
     this.houseGroup.name = 'House-Group';
     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();
-    });
-    this.apiStore.loadFurnitureData().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;
+    this.setCenterPosition().loadTextures().then(function () {
+      _this.createFloors().createSpaceBetweenWalls().createWalls().createDoors();
     });
-  }
+    this.apiStore.loadFurnitureData().then(function (resp) {
+      _this.furnitureData = resp;
 
-  getWallById(wallId) {
-    return this.walls.find(_ref3 => {
-      let {
-        ID
-      } = _ref3;
-      return ID === wallId;
+      _this.loadFurniture(0);
     });
   }
 
-  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
-      }
-    };
-  }
+  _createClass(HouseStore, [{
+    key: "textureLoader",
+    get: function get() {
+      return this.modelStore.textureLoader;
+    }
+  }, {
+    key: "sceneScale",
+    get: function get() {
+      return this.modelStore.sceneScale;
+    }
+  }, {
+    key: "wallsHeight",
+    get: function get() {
+      return this.modelStore.wallsHeight;
+    }
+  }, {
+    key: "json",
+    get: function get() {
+      return this.modelStore.json;
+    }
+  }, {
+    key: "vertices",
+    get: function get() {
+      return this.json.Vertices;
+    }
+  }, {
+    key: "rooms",
+    get: function get() {
+      return this.json.Floors[0].Units[0].Rooms;
+    }
+  }, {
+    key: "walls",
+    get: function get() {
+      return this.json.Floors[0].Walls;
+    }
+  }, {
+    key: "exteriorWalls",
+    get: function get() {
+      return this.json.Floors[0].ExteriorWalls;
+    }
+  }, {
+    key: "doors",
+    get: function get() {
+      var _this2 = this;
 
-  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;
-    }, []);
-  }
+      return this.json.Floors[0].Doors.map(function (door) {
+        return _this2.getParsedAperture(door, 'Door');
+      });
+    }
+  }, {
+    key: "windows",
+    get: function get() {
+      var _this3 = this;
 
-  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 = createDefaultMaterial({
-        color: params.color,
+      return this.json.Floors[0].Windows.map(function (window) {
+        return _this3.getParsedAperture(window, 'Window');
+      });
+    }
+  }, {
+    key: "apertures",
+    get: function get() {
+      return [].concat(_toConsumableArray(this.doors), _toConsumableArray(this.windows));
+    }
+  }, {
+    key: "doorsHeight",
+    get: function get() {
+      return this.wallsHeight / 2 + this.wallsHeight / 4;
+    }
+  }, {
+    key: "wallMaterialOptions",
+    get: function get() {
+      return {
+        clippingPlanes: this.clippingPlanes,
+        color: this.wallsColor,
         side: THREE.DoubleSide
+      };
+    }
+  }, {
+    key: "furniture",
+    get: function get() {
+      return this.rooms.reduce(function (acc, _ref) {
+        var Furniture = _ref.Furniture;
+        if (!Furniture || !Furniture.length) return acc;
+        return [].concat(_toConsumableArray(acc), _toConsumableArray(Furniture));
+      }, []);
+    }
+  }, {
+    key: "getVertexById",
+    value: function getVertexById(vertexId) {
+      return this.vertices.find(function (_ref2) {
+        var ID = _ref2.ID;
+        return ID === vertexId;
+      });
+    }
+  }, {
+    key: "getWallById",
+    value: function getWallById(wallId) {
+      return this.walls.find(function (_ref3) {
+        var ID = _ref3.ID;
+        return ID === wallId;
+      });
+    }
+  }, {
+    key: "getParsedAperture",
+    value: function getParsedAperture(aperture, type) {
+      var Location = aperture.Location,
+          Walls = aperture.Walls;
+      var position = new THREE.Vector3(Location.X, Location.Y, Location.Z);
+      var secondWall = this.getParsedWallById(Walls[1], 1);
+      var line = new THREE.Line3(secondWall.start, secondWall.end);
+      var positionOnFirstWall = new THREE.Vector3();
+      line.closestPointToPoint(position, true, positionOnFirstWall);
+      var lineBetweenWalls = new THREE.Line3(position, positionOnFirstWall);
+      var distanceBetweenWalls = lineBetweenWalls.distance();
+      var positionBetweenWalls = lineBetweenWalls.getCenter(positionOnFirstWall);
+
+      var parsedAperture = _objectSpread(_objectSpread({}, aperture), {}, {
+        Type: type,
+        Depth: distanceBetweenWalls,
+        Location: {
+          X: positionBetweenWalls.x,
+          Y: positionBetweenWalls.y,
+          Z: positionBetweenWalls.z
+        }
       });
-      const mesh = new THREE.Mesh(geometry, material);
-      mesh.receiveShadow = true;
-      mesh.castShadow = false;
-      mesh.name = 'FloorMesh';
 
-      const callback = (texture, roughnessMap) => {
-        const textureMaterial = createDefaultMaterial({
-          color: params.color,
-          side: THREE.DoubleSide,
-          map: texture
-        });
-        mesh.material = textureMaterial;
-        if (roughnessMap) mesh.material.roughnessMap = roughnessMap;
-        this.houseGroup.add(mesh);
+      return parsedAperture;
+    }
+  }, {
+    key: "getParsedWallById",
+    value: function getParsedWallById(wallId) {
+      var _this4 = this;
+
+      var scale = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.sceneScale;
+      var currentWall = this.getWallById(wallId);
+
+      var _currentWall$Vertices = currentWall.Vertices.map(function (vertexId) {
+        return _this4.getVertexById(vertexId).Location;
+      }),
+          _currentWall$Vertices2 = _slicedToArray(_currentWall$Vertices, 2),
+          coord1 = _currentWall$Vertices2[0],
+          coord2 = _currentWall$Vertices2[1];
+
+      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
+        }
       };
+    }
+  }, {
+    key: "getVerticesFromParsedWalls",
+    value: function getVerticesFromParsedWalls(walls) {
+      return walls.reduce(function (acc, _ref4) {
+        var start = _ref4.start,
+            end = _ref4.end;
+        acc.push(new THREE.Vector2(start.x, start.y), new THREE.Vector2(end.x, end.y));
+        return acc;
+      }, []);
+    }
+  }, {
+    key: "createFloors",
+    value: function createFloors() {
+      var _this5 = this;
+
+      this.rooms.forEach(function (_ref5) {
+        var Walls = _ref5.Walls,
+            Type = _ref5.Type;
+        var walls = Walls.map(function (wallId) {
+          return _this5.getParsedWallById(wallId);
+        });
+        var params = (0, _modelHelpers.getFloorParams)(Type);
 
-      this.loadTexture(params.texture, [0.5, 0.5], texture => {
-        if (!params.roughnessMap) {
-          callback(texture);
-          return;
-        }
+        var vertices = _this5.getVerticesFromParsedWalls(walls);
 
-        this.loadTexture(params.roughnessMap, [0.5, 0.5], roughnessMap => callback(texture, roughnessMap));
+        var shape = new THREE.Shape(vertices);
+        var geometry = new THREE.ShapeGeometry(shape);
+        var material = createDefaultMaterial({
+          color: params.color,
+          side: THREE.DoubleSide
+        });
+        var mesh = new THREE.Mesh(geometry, material);
+        mesh.receiveShadow = true;
+        mesh.castShadow = false;
+        mesh.name = 'FloorMesh';
+
+        var callback = function callback(texture, roughnessMap) {
+          var textureMaterial = createDefaultMaterial({
+            color: params.color,
+            side: THREE.DoubleSide,
+            map: texture
+          });
+          mesh.material = textureMaterial;
+          if (roughnessMap) mesh.material.roughnessMap = roughnessMap;
+
+          _this5.houseGroup.add(mesh);
+        };
+
+        _this5.loadTexture(params.texture, [0.5, 0.5], function (texture) {
+          if (!params.roughnessMap) {
+            callback(texture);
+            return;
+          }
+
+          _this5.loadTexture(params.roughnessMap, [0.5, 0.5], function (roughnessMap) {
+            return callback(texture, roughnessMap);
+          });
+        });
       });
-    });
-    return this;
-  }
+      return this;
+    }
+  }, {
+    key: "createSpaceBetweenWalls",
+    value: function createSpaceBetweenWalls() {
+      var _this6 = 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 = createDefaultMaterial({
-      side: THREE.DoubleSide,
-      color: '#5C5C5C'
-    });
-    const material = createDefaultMaterial(_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);
-    flatMesh.receiveShadow = false;
-    flatMesh.castShadow = false;
-    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';
-    clippedMeshWithApertures.receiveShadow = false;
-    clippedMeshWithApertures.castShadow = false;
-    meshWithApertures.receiveShadow = false;
-    meshWithApertures.castShadow = false;
-    this.houseGroup.add(flatMesh, clippedMeshWithApertures, meshWithApertures);
-    return this;
-  }
+      var walls = this.exteriorWalls.map(function (wallId) {
+        return _this6.getParsedWallById(wallId);
+      });
+      var vertices = this.getVerticesFromParsedWalls(walls);
+      var clippedDepth = (this.wallsHeight + 0.5) * clippedBuildingConstant + 0.006;
+      var depth = this.wallsHeight + 0.002;
+      var shapeWithHoles = new THREE.Shape(vertices);
+      var shape = new THREE.Shape(vertices);
+      this.rooms.forEach(function (_ref6) {
+        var Walls = _ref6.Walls;
+        var roomWalls = Walls.map(function (wallId) {
+          return _this6.getParsedWallById(wallId);
+        });
+
+        var roomVertices = _this6.getVerticesFromParsedWalls(roomWalls);
 
-  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,
+        shapeWithHoles.holes.push(new THREE.Shape(roomVertices));
+      });
+      var clippedGeometry = new THREE.ExtrudeGeometry(shapeWithHoles, {
+        depth: clippedDepth,
         bevelEnabled: false
       });
-      const wallPadGeometry = new THREE.ExtrudeGeometry(wallShape, {
+      var flatGeometry = new THREE.ExtrudeGeometry(shape, {
         depth: 0.001,
         bevelEnabled: false
       });
-      const wallMaterial = isExterior ? this.exteriorWallsMaterial : this.wallsMaterial;
-      const wallPadMaterial = createDefaultMaterial(_objectSpread(_objectSpread({}, this.wallMaterialOptions), {}, {
-        color: '#5C5C5C'
-      }));
-      const wallClippedPadMaterial = createDefaultMaterial({
+      var geometry = new THREE.ExtrudeGeometry(shapeWithHoles, {
+        depth: depth,
+        bevelEnabled: false
+      });
+      var clippedMaterial = createDefaultMaterial({
         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);
-      wallMesh.castShadow = true;
-      wallMesh.receiveShadow = !isExterior;
-      wallPadMesh.castShadow = false;
-      wallPadMesh.receiveShadow = false;
-      wallClippedPadMesh.castShadow = false;
-      wallClippedPadMesh.receiveShadow = false;
-      wallPadMesh.position.z = this.wallsHeight;
-      wallClippedPadMesh.position.z = (this.wallsHeight + 0.5) * clippedBuildingConstant + 0.001;
-      const wallClippedPadMeshWithApertures = this.subtractApertures(wallClippedPadMesh, apertures);
-      wallClippedPadMeshWithApertures.visible = false;
-      wallClippedPadMeshWithApertures.castShadow = false;
-      wallClippedPadMeshWithApertures.receiveShadow = 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.exteriorWallsMaterial = createDefaultMaterial(_objectSpread(_objectSpread({}, this.wallMaterialOptions), {}, {
-      map: this.exteriorWallsMaps.map,
-      roughnessMap: this.exteriorWallsMaps.roughnessMap,
-      color: '#FFFFFF'
-    }));
-    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);
-      mesh.receiveShadow = true;
-      mesh.castShadow = true;
-      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 = createDefaultMaterial({
-        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);
-    const centerX = (maxX + minX) / 2;
-    const centerY = (maxY + minY) / 2;
-    const lightsOffset = 25;
-    this.houseGroup.position.set(-centerX, -centerY);
-    const lights = [{
-      x: centerX - lightsOffset,
-      y: centerY - lightsOffset,
-      z: this.wallsHeight * 3,
-      power: 0.4,
-      castShadow: true
-    }, {
-      x: centerX - lightsOffset,
-      y: centerY - lightsOffset,
-      z: this.wallsHeight * 2,
-      power: 1,
-      castShadow: false
-    }, {
-      x: centerX + lightsOffset,
-      y: centerY + lightsOffset,
-      z: this.wallsHeight * 2,
-      power: 1.1,
-      castShadow: false
-    }, {
-      x: centerX,
-      y: centerY,
-      z: this.wallsHeight * 5,
-      power: 0.1,
-      castShadow: false
-    }];
-    const targetObject = new THREE.Object3D();
-    targetObject.position.set(centerX, centerY, 0);
-    this.houseGroup.add(targetObject);
-    lights.forEach(_ref10 => {
-      let {
-        x,
-        y,
-        z,
-        power,
-        castShadow
-      } = _ref10;
-      const light = new THREE.DirectionalLight(0xffffff, power);
-      light.position.set(x, y, z);
-      light.shadowLight = castShadow;
-      light.castShadow = castShadow;
-      light.shadow.camera.left = -centerX * 2;
-      light.shadow.camera.right = centerX * 2;
-      light.shadow.camera.top = centerY * 2;
-      light.shadow.camera.bottom = -centerY * 2;
-      light.shadow.camera.zoom = 1;
-      light.shadow.mapSize = new THREE.Vector2(2048, 2048);
-      light.shadow.normalBias = 1;
-      light.target = targetObject;
-      this.houseGroup.add(light);
-    });
-    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 = createDefaultMaterial(_objectSpread(_objectSpread({}, this.wallMaterialOptions), {}, {
-          map: texture
-        }));
-      }
-    }, {
-      img: _exteriorWallTexture.default,
-      repeat: [1, 1],
-      callback: texture => {
-        this.wallsTextures.push({
-          image: _exteriorWallTexture.default,
-          texture: texture
+      var material = createDefaultMaterial(_objectSpread(_objectSpread({}, this.wallMaterialOptions), {}, {
+        color: '#5C5C5C'
+      }));
+      var clippedMesh = new THREE.Mesh(clippedGeometry, clippedMaterial);
+      var flatMesh = new THREE.Mesh(flatGeometry, material);
+      var mesh = new THREE.Mesh(geometry, material);
+      flatMesh.receiveShadow = false;
+      flatMesh.castShadow = false;
+      clippedMesh.position.z = -0.005;
+      flatMesh.position.z = -0.005;
+      mesh.position.z = -0.001;
+      var additionalApertureWidth = 0.25;
+      var clippedMeshWithApertures = this.subtractApertures(clippedMesh, this.apertures, additionalApertureWidth);
+      var meshWithApertures = this.subtractApertures(mesh, this.apertures, additionalApertureWidth);
+      clippedMeshWithApertures.name = 'ClippedSpaceBetweenWalls';
+      meshWithApertures.name = 'SpaceBetweenWalls';
+      flatMesh.name = 'FlatSpaceBetweenWalls';
+      clippedMeshWithApertures.receiveShadow = false;
+      clippedMeshWithApertures.castShadow = false;
+      meshWithApertures.receiveShadow = false;
+      meshWithApertures.castShadow = false;
+      this.houseGroup.add(flatMesh, clippedMeshWithApertures, meshWithApertures);
+      return this;
+    }
+  }, {
+    key: "createWalls",
+    value: function createWalls() {
+      var _this7 = this;
+
+      var createWall = function createWall(wallId, isExterior) {
+        var _this7$getParsedWallB = _this7.getParsedWallById(wallId),
+            start = _this7$getParsedWallB.start,
+            end = _this7$getParsedWallB.end;
+
+        var wallHalfWidth = 0.005;
+        var 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)]);
+        var wallGeometry = new THREE.ExtrudeGeometry(wallShape, {
+          depth: _this7.wallsHeight,
+          bevelEnabled: false
         });
-        this.exteriorWallsMaps.map = texture;
-      }
-    }, {
-      img: _exteriorWallTextureRoughness.default,
-      repeat: [1, 1],
-      callback: texture => {
-        this.wallsTextures.push({
-          image: _exteriorWallTextureRoughness.default,
-          texture: texture
+        var wallPadGeometry = new THREE.ExtrudeGeometry(wallShape, {
+          depth: 0.001,
+          bevelEnabled: false
         });
-        this.exteriorWallsMaps.roughnessMap = texture;
-      }
-    }, {
-      img: _doorTexture.default,
-      repeat: [1, 1],
-      callback: texture => {
-        this.doorMaterial = createDefaultMaterial(_objectSpread(_objectSpread({}, doorMaterialOptions), {}, {
-          map: texture
+        var wallMaterial = isExterior ? _this7.exteriorWallsMaterial : _this7.wallsMaterial;
+        var wallPadMaterial = createDefaultMaterial(_objectSpread(_objectSpread({}, _this7.wallMaterialOptions), {}, {
+          color: '#5C5C5C'
         }));
-      }
-    }];
-    return Promise.all(assets.map(_ref11 => {
-      let {
-        img,
-        repeat,
-        callback
-      } = _ref11;
-      return new Promise(resolve => {
-        this.loadTexture(img, repeat, texture => {
-          callback(texture);
-          resolve();
+        var wallClippedPadMaterial = createDefaultMaterial({
+          side: THREE.DoubleSide,
+          color: '#5C5C5C'
         });
-      });
-    }));
-  }
 
-  loadFurniture(index) {
-    const furniture = this.furniture[index];
-    if (!furniture) return;
-    const furnitureData = this.furnitureData.find(_ref12 => {
-      let {
-        name,
-        type
-      } = _ref12;
-      return name === furniture.Model && type === furniture.Type;
-    });
+        var apertures = _this7.apertures.filter(function (aperture) {
+          return aperture.Walls.some(function (id) {
+            return wallId === id;
+          });
+        });
 
-    if (!furnitureData) {
-      this.loadFurniture(index + 1);
-      return;
-    }
-
-    const {
-      mesh,
-      textures
-    } = furnitureData;
-    const modelPath = "".concat(this.apiStore.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(this.apiStore.API_URL, "/storage/furniture/").concat(url);
-      return new Promise(resolve => {
-        this.textureLoader.load(texturePath, texture => resolve(texture));
-      });
-    });
+        var wallMesh = _this7.subtractApertures(new THREE.Mesh(wallGeometry, wallMaterial), apertures);
+
+        var wallPadMesh = new THREE.Mesh(wallPadGeometry, wallPadMaterial);
+        var wallClippedPadMesh = new THREE.Mesh(wallPadGeometry, wallClippedPadMaterial);
+        wallMesh.castShadow = true;
+        wallMesh.receiveShadow = !isExterior;
+        wallPadMesh.castShadow = false;
+        wallPadMesh.receiveShadow = false;
+        wallClippedPadMesh.castShadow = false;
+        wallClippedPadMesh.receiveShadow = false;
+        wallPadMesh.position.z = _this7.wallsHeight;
+        wallClippedPadMesh.position.z = (_this7.wallsHeight + 0.5) * clippedBuildingConstant + 0.001;
+
+        var wallClippedPadMeshWithApertures = _this7.subtractApertures(wallClippedPadMesh, apertures);
+
+        wallClippedPadMeshWithApertures.visible = false;
+        wallClippedPadMeshWithApertures.castShadow = false;
+        wallClippedPadMeshWithApertures.receiveShadow = false;
+        var wallGroup = new THREE.Group();
+        wallGroup.name = 'Wall';
+        wallGroup.buildingId = wallId;
+        wallGroup.isExterior = isExterior;
+        wallGroup.add(wallMesh, wallPadMesh, wallClippedPadMeshWithApertures);
+
+        _this7.wallsGroup.add(wallGroup);
+      };
 
-    const onTexturesLoaded = (result, model) => {
-      const materialsCount = result.reduce((acc, _ref13) => {
-        let {
-          image
-        } = _ref13;
-        if (!image.currentSrc.includes('_D.') && !image.currentSrc.includes('_DA.')) return acc;
-        return acc += 1;
-      }, 0);
-
-      const createMaterial = num => {
-        const map = result.find(_ref14 => {
-          let {
-            image
-          } = _ref14;
-          return image.currentSrc.includes("".concat(num, "_D.")) || image.currentSrc.includes("".concat(num, "_DA."));
-        });
-        const envMap = result.find(_ref15 => {
-          let {
-            image
-          } = _ref15;
-          return image.currentSrc.includes("".concat(num, "_RMO."));
-        });
-        const normalMap = result.find(_ref16 => {
-          let {
-            image
-          } = _ref16;
-          return image.currentSrc.includes("".concat(num, "_N."));
+      this.exteriorWallsMaterial = createDefaultMaterial(_objectSpread(_objectSpread({}, this.wallMaterialOptions), {}, {
+        map: this.exteriorWallsMaps.map,
+        roughnessMap: this.exteriorWallsMaps.roughnessMap,
+        color: '#FFFFFF'
+      }));
+      this.rooms.forEach(function (_ref7) {
+        var Walls = _ref7.Walls;
+        return Walls.forEach(function (wallId) {
+          return createWall(wallId, false);
         });
-        const material = new THREE.MeshStandardMaterial({
-          roughness: 1,
-          transparent: true
+      });
+      this.exteriorWalls.forEach(function (wallId) {
+        return createWall(wallId, true);
+      });
+      this.houseGroup.add(this.wallsGroup);
+      return this;
+    }
+  }, {
+    key: "createDoors",
+    value: function createDoors() {
+      var _this8 = this;
+
+      this.doors.forEach(function (_ref8) {
+        var Width = _ref8.Width,
+            Location = _ref8.Location,
+            Rotation = _ref8.Rotation;
+        var geometry = new THREE.BoxGeometry(Width * _this8.sceneScale, 0.1, _this8.doorsHeight);
+        var mesh = new THREE.Mesh(geometry, _this8.doorMaterial);
+        mesh.position.x = Location.X * _this8.sceneScale;
+        mesh.position.y = Location.Y * _this8.sceneScale;
+        mesh.position.z = _this8.doorsHeight / 2;
+        mesh.rotation.z = THREE.Math.degToRad(Rotation.Yaw);
+        mesh.receiveShadow = true;
+        mesh.castShadow = true;
+
+        _this8.doorsGroup.add(mesh);
+      });
+      this.houseGroup.add(this.doorsGroup);
+      return this;
+    }
+  }, {
+    key: "subtractApertures",
+    value: function subtractApertures(mesh, apertures) {
+      var _this9 = this;
+
+      var additionalWidth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+      var resultMesh = mesh;
+      apertures.forEach(function (_ref9) {
+        var Width = _ref9.Width,
+            Depth = _ref9.Depth,
+            Location = _ref9.Location,
+            Rotation = _ref9.Rotation,
+            Type = _ref9.Type;
+        var isDoor = Type === 'Door';
+        var apertureGeometry = new THREE.BoxGeometry((Width + additionalWidth) * _this9.sceneScale, Depth * _this9.sceneScale + 1, (isDoor ? _this9.doorsHeight : _this9.wallsHeight / 2) + additionalWidth * _this9.sceneScale);
+        var apertureMaterial = createDefaultMaterial({
+          color: '#00B4F7'
         });
-        material.depthWrite = !(ModelName === 'Flower' && num === '01');
-        if (map) material.map = map;
-        if (envMap) material.envMap = envMap;
-        if (normalMap) material.normalMap = normalMap;
-        return material;
-      };
+        var apertureMesh = new THREE.Mesh(apertureGeometry, apertureMaterial);
+        apertureMesh.rotation.z = THREE.Math.degToRad(Rotation.Yaw);
+        apertureMesh.position.x = Location.X * _this9.sceneScale;
+        apertureMesh.position.y = Location.Y * _this9.sceneScale;
+        apertureMesh.position.z = isDoor ? _this9.doorsHeight / 2 : _this9.wallsHeight / 2;
+        apertureMesh.updateMatrix();
+        resultMesh.updateMatrix();
 
-      let materials = new THREE.MeshPhysicalMaterial({
-        roughness: 1,
-        clearcoat: 1,
-        clearcoatRoughness: 1,
-        reflectivity: 0,
-        fog: false
-      });
+        var apertureBSP = _threeCsg.default.fromMesh(apertureMesh);
 
-      if (materialsCount === 1) {
-        materials = createMaterial('');
-      }
+        var wallBSP = _threeCsg.default.fromMesh(resultMesh);
 
-      if (materialsCount > 1) {
-        materials = [...Array(materialsCount).keys()].map(i => {
-          const num = i + 1;
-          const realNum = num < 10 ? "0".concat(num) : num;
-          return createMaterial(realNum);
-        });
-      }
+        var resultBSP = wallBSP.subtract(apertureBSP);
+        resultMesh = _threeCsg.default.toMesh(resultBSP, mesh.matrix, resultMesh.material);
+      });
+      return resultMesh;
+    }
+  }, {
+    key: "setCenterPosition",
+    value: function setCenterPosition() {
+      var _this10 = this;
 
-      model.traverse(node => {
-        if (node.isMesh) {
-          node.material = materials;
-          node.receiveShadow = true;
-          node.castShadow = true;
+      var walls = this.exteriorWalls.map(function (wallId) {
+        return _this10.getParsedWallById(wallId);
+      });
+
+      var _getMinMaxCoordinates = (0, _modelHelpers.getMinMaxCoordinates)(walls),
+          maxX = _getMinMaxCoordinates.maxX,
+          minX = _getMinMaxCoordinates.minX,
+          maxY = _getMinMaxCoordinates.maxY,
+          minY = _getMinMaxCoordinates.minY;
+
+      var centerX = (maxX + minX) / 2;
+      var centerY = (maxY + minY) / 2;
+      var lightsOffset = 25;
+      this.houseGroup.position.set(-centerX, -centerY);
+      var lights = [{
+        x: centerX - lightsOffset,
+        y: centerY - lightsOffset,
+        z: this.wallsHeight * 3,
+        power: 0.4,
+        castShadow: true
+      }, {
+        x: centerX - lightsOffset,
+        y: centerY - lightsOffset,
+        z: this.wallsHeight * 2,
+        power: 1,
+        castShadow: false
+      }, {
+        x: centerX + lightsOffset,
+        y: centerY + lightsOffset,
+        z: this.wallsHeight * 2,
+        power: 1.1,
+        castShadow: false
+      }, {
+        x: centerX,
+        y: centerY,
+        z: this.wallsHeight * 5,
+        power: 0.1,
+        castShadow: false
+      }];
+      var targetObject = new THREE.Object3D();
+      targetObject.position.set(centerX, centerY, 0);
+      this.houseGroup.add(targetObject);
+      lights.forEach(function (_ref10) {
+        var x = _ref10.x,
+            y = _ref10.y,
+            z = _ref10.z,
+            power = _ref10.power,
+            castShadow = _ref10.castShadow;
+        var light = new THREE.DirectionalLight(0xffffff, power);
+        light.position.set(x, y, z);
+        light.shadowLight = castShadow;
+        light.castShadow = castShadow;
+        light.shadow.camera.left = -centerX * 2;
+        light.shadow.camera.right = centerX * 2;
+        light.shadow.camera.top = centerY * 2;
+        light.shadow.camera.bottom = -centerY * 2;
+        light.shadow.camera.zoom = 1;
+        light.shadow.mapSize = new THREE.Vector2(2048, 2048);
+        light.shadow.normalBias = 1;
+        light.target = targetObject;
+
+        _this10.houseGroup.add(light);
+      });
+      return this;
+    }
+  }, {
+    key: "loadTexture",
+    value: function loadTexture(img) {
+      var repeat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [1, 1];
+      var callback = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function () {};
+      this.textureLoader.load(img, function (texture) {
+        texture.wrapS = texture.wrapT = THREE.RepeatWrapping;
+        texture.repeat.set(repeat[0], repeat[1]);
+        texture.flipY = false;
+        callback(texture);
+      });
+    }
+  }, {
+    key: "loadTextures",
+    value: function loadTextures() {
+      var _this11 = this;
+
+      var assets = [{
+        img: _wallTexture.default,
+        repeat: [0.5, 0.5],
+        callback: function callback(texture) {
+          _this11.wallsTextures.push({
+            image: _wallTexture.default,
+            texture: texture
+          });
+
+          _this11.wallsMaterial = createDefaultMaterial(_objectSpread(_objectSpread({}, _this11.wallMaterialOptions), {}, {
+            map: texture
+          }));
+        }
+      }, {
+        img: _exteriorWallTexture.default,
+        repeat: [1, 1],
+        callback: function callback(texture) {
+          _this11.wallsTextures.push({
+            image: _exteriorWallTexture.default,
+            texture: texture
+          });
+
+          _this11.exteriorWallsMaps.map = texture;
+        }
+      }, {
+        img: _exteriorWallTextureRoughness.default,
+        repeat: [1, 1],
+        callback: function callback(texture) {
+          _this11.wallsTextures.push({
+            image: _exteriorWallTextureRoughness.default,
+            texture: texture
+          });
+
+          _this11.exteriorWallsMaps.roughnessMap = texture;
         }
+      }, {
+        img: _doorTexture.default,
+        repeat: [1, 1],
+        callback: function callback(texture) {
+          _this11.doorMaterial = createDefaultMaterial(_objectSpread(_objectSpread({}, doorMaterialOptions), {}, {
+            map: texture
+          }));
+        }
+      }];
+      return Promise.all(assets.map(function (_ref11) {
+        var img = _ref11.img,
+            repeat = _ref11.repeat,
+            callback = _ref11.callback;
+        return new Promise(function (resolve) {
+          _this11.loadTexture(img, repeat, function (texture) {
+            callback(texture);
+            resolve();
+          });
+        });
+      }));
+    }
+  }, {
+    key: "loadFurniture",
+    value: function loadFurniture(index) {
+      var _this12 = this;
+
+      var furniture = this.furniture[index];
+      if (!furniture) return;
+      var furnitureData = this.furnitureData.find(function (_ref12) {
+        var name = _ref12.name,
+            type = _ref12.type;
+        return name === furniture.Model && type === furniture.Type;
       });
-      this.houseGroup.add(model);
-      this.loadFurniture(index + 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);
+
+      if (!furnitureData) {
+        this.loadFurniture(index + 1);
         return;
       }
 
-      Promise.all(promises).then(result => {
-        onTexturesLoaded(result, model);
-        this.loadedTextures[ModelName] = result;
+      var mesh = furnitureData.mesh,
+          textures = furnitureData.textures;
+      var modelPath = "".concat(this.apiStore.API_URL, "/storage/furniture/").concat(mesh);
+      var Location = furniture.Location,
+          Rotation = furniture.Rotation,
+          ModelName = furniture.Model;
+      var X = Location.X,
+          Y = Location.Y,
+          Z = Location.Z;
+      var promises = textures.map(function (url) {
+        var texturePath = "".concat(_this12.apiStore.API_URL, "/storage/furniture/").concat(url);
+        return new Promise(function (resolve) {
+          _this12.textureLoader.load(texturePath, function (texture) {
+            return resolve(texture);
+          });
+        });
       });
-    };
 
-    const loadedModel = this.loadedModels[ModelName];
+      var onTexturesLoaded = function onTexturesLoaded(result, model) {
+        var materialsCount = result.reduce(function (acc, _ref13) {
+          var image = _ref13.image;
+          if (!image.currentSrc.includes('_D.') && !image.currentSrc.includes('_DA.')) return acc;
+          return acc += 1;
+        }, 0);
+
+        var createMaterial = function createMaterial(num) {
+          var map = result.find(function (_ref14) {
+            var image = _ref14.image;
+            return image.currentSrc.includes("".concat(num, "_D.")) || image.currentSrc.includes("".concat(num, "_DA."));
+          });
+          var envMap = result.find(function (_ref15) {
+            var image = _ref15.image;
+            return image.currentSrc.includes("".concat(num, "_RMO."));
+          });
+          var normalMap = result.find(function (_ref16) {
+            var image = _ref16.image;
+            return image.currentSrc.includes("".concat(num, "_N."));
+          });
+          var material = new THREE.MeshStandardMaterial({
+            roughness: 1,
+            transparent: true
+          });
+          material.depthWrite = !(ModelName === 'Flower' && num === '01');
+          if (map) material.map = map;
+          if (envMap) material.envMap = envMap;
+          if (normalMap) material.normalMap = normalMap;
+          return material;
+        };
+
+        var materials = new THREE.MeshPhysicalMaterial({
+          roughness: 1,
+          clearcoat: 1,
+          clearcoatRoughness: 1,
+          reflectivity: 0,
+          fog: false
+        });
 
-    if (loadedModel) {
-      onModelLoaded(loadedModel);
-      return;
-    }
+        if (materialsCount === 1) {
+          materials = createMaterial('');
+        }
 
-    modelLoader.load(modelPath, model => {
-      this.loadedModels[ModelName] = model;
-      onModelLoaded(model);
-    });
-  } // Actions
+        if (materialsCount > 1) {
+          materials = _toConsumableArray(Array(materialsCount).keys()).map(function (i) {
+            var num = i + 1;
+            var realNum = num < 10 ? "0".concat(num) : num;
+            return createMaterial(realNum);
+          });
+        }
 
+        model.traverse(function (node) {
+          if (node.isMesh) {
+            node.material = materials;
+            node.receiveShadow = true;
+            node.castShadow = true;
+          }
+        });
 
-  setShadowsVisibility(value) {
-    this.isShadowsVisible = value;
-    this.houseGroup.children.forEach(node => {
-      const isLight = node instanceof THREE.DirectionalLight;
-      if (!isLight) return;
-      if (!node.shadowLight) return;
-      node.castShadow = value;
-    });
-  }
+        _this12.houseGroup.add(model);
 
-  setDoorsVisibility(value) {
-    this.isDoorsVisible = value;
-    this.doorsGroup.children.forEach(door => door.visible = value);
-  }
+        _this12.loadFurniture(index + 1);
+      };
 
-  setCurrentWallsMaterialType(value) {
-    this.wallsMaterialType = value;
-    this.wallsGroup.children.forEach(_ref17 => {
-      let {
-        children,
-        isExterior
-      } = _ref17;
-      const wall = children[0];
-
-      if (value === 'texture') {
-        wall.material = isExterior ? this.exteriorWallsMaterial : this.wallsMaterial;
-        return;
-      }
+      var onModelLoaded = function onModelLoaded(originalModel) {
+        var model = originalModel.clone();
+        model.scale.set(_this12.sceneScale, _this12.sceneScale, _this12.sceneScale);
+        model.position.set(X * _this12.sceneScale, Y * _this12.sceneScale, Z * _this12.sceneScale);
+        model.rotation.set(Math.PI / 2, THREE.Math.degToRad(Rotation.Yaw), 0);
+        var loadedTextures = _this12.loadedTextures[ModelName];
 
-      const color = isExterior ? '#FFFFFF' : this.wallsColor;
-      wall.material = createDefaultMaterial(_objectSpread(_objectSpread({}, this.wallMaterialOptions), {}, {
-        color
-      }));
-    });
-    this.doorsGroup.children.forEach(door => {
-      if (value === 'texture') {
-        door.material = this.doorMaterial;
-        return;
-      }
+        if (loadedTextures) {
+          onTexturesLoaded(loadedTextures, model);
+          return;
+        }
 
-      door.material = createDefaultMaterial(doorMaterialOptions);
-    });
-  }
+        Promise.all(promises).then(function (result) {
+          onTexturesLoaded(result, model);
+          _this12.loadedTextures[ModelName] = result;
+        });
+      };
 
-  setCurrentWallColor(color) {
-    this.wallsColor = color;
-    this.wallsMaterial.color.set(color);
-    this.wallsGroup.children.forEach(_ref18 => {
-      let {
-        children,
-        isExterior
-      } = _ref18;
-      if (isExterior) return;
-      const wall = children[0];
-      wall.material.color.set(color);
-    });
-  }
+      var loadedModel = this.loadedModels[ModelName];
 
-  setCurrentWallTexture(texture) {
-    this.wallsMaterial = createDefaultMaterial(_objectSpread(_objectSpread({}, this.wallMaterialOptions), {}, {
-      map: texture
-    }));
-    this.setCurrentWallsMaterialType('texture');
-  }
+      if (loadedModel) {
+        onModelLoaded(loadedModel);
+        return;
+      }
 
-  addWallTexture(image) {
-    this.loadTexture(image, [0.5, 0.5], texture => {
-      this.wallsTextures.push({
-        image,
-        texture
+      modelLoader.load(modelPath, function (model) {
+        _this12.loadedModels[ModelName] = model;
+        onModelLoaded(model);
       });
-      this.setCurrentWallTexture(texture);
-    });
-  }
+    } // Actions
+
+  }, {
+    key: "setShadowsVisibility",
+    value: function setShadowsVisibility(value) {
+      this.isShadowsVisible = value;
+      this.houseGroup.children.forEach(function (node) {
+        var isLight = node instanceof THREE.DirectionalLight;
+        if (!isLight) return;
+        if (!node.shadowLight) return;
+        node.castShadow = value;
+      });
+    }
+  }, {
+    key: "setDoorsVisibility",
+    value: function setDoorsVisibility(value) {
+      this.isDoorsVisible = value;
+      this.doorsGroup.children.forEach(function (door) {
+        return door.visible = value;
+      });
+    }
+  }, {
+    key: "setCurrentWallsMaterialType",
+    value: function setCurrentWallsMaterialType(value) {
+      var _this13 = this;
+
+      this.wallsMaterialType = value;
+      this.wallsGroup.children.forEach(function (_ref17) {
+        var children = _ref17.children,
+            isExterior = _ref17.isExterior;
+        var wall = children[0];
+
+        if (value === 'texture') {
+          wall.material = isExterior ? _this13.exteriorWallsMaterial : _this13.wallsMaterial;
+          return;
+        }
 
-  setFullBuildingVisibility(value) {
-    this.isFullBuildingVisible = value;
-    this.globalPlane.constant = this.isFullBuildingVisible ? 1 : clippedBuildingConstant;
-    this.wallsGroup.children.forEach(_ref19 => {
-      let {
-        children
-      } = _ref19;
-      return children[2].visible = !value;
-    });
-  }
+        var color = isExterior ? '#FFFFFF' : _this13.wallsColor;
+        wall.material = createDefaultMaterial(_objectSpread(_objectSpread({}, _this13.wallMaterialOptions), {}, {
+          color: color
+        }));
+      });
+      this.doorsGroup.children.forEach(function (door) {
+        if (value === 'texture') {
+          door.material = _this13.doorMaterial;
+          return;
+        }
 
-  setPlanMode() {
-    this.setDoorsVisibility(false);
-    this.setFullBuildingVisibility(false);
-    this.setCurrentWallsMaterialType('color');
-  }
+        door.material = createDefaultMaterial(doorMaterialOptions);
+      });
+    }
+  }, {
+    key: "setCurrentWallColor",
+    value: function setCurrentWallColor(color) {
+      this.wallsColor = color;
+      this.wallsMaterial.color.set(color);
+      this.wallsGroup.children.forEach(function (_ref18) {
+        var children = _ref18.children,
+            isExterior = _ref18.isExterior;
+        if (isExterior) return;
+        var wall = children[0];
+        wall.material.color.set(color);
+      });
+    }
+  }, {
+    key: "setCurrentWallTexture",
+    value: function setCurrentWallTexture(texture) {
+      this.wallsMaterial = createDefaultMaterial(_objectSpread(_objectSpread({}, this.wallMaterialOptions), {}, {
+        map: texture
+      }));
+      this.setCurrentWallsMaterialType('texture');
+    }
+  }, {
+    key: "addWallTexture",
+    value: function addWallTexture(image) {
+      var _this14 = this;
+
+      this.loadTexture(image, [0.5, 0.5], function (texture) {
+        _this14.wallsTextures.push({
+          image: image,
+          texture: texture
+        });
+
+        _this14.setCurrentWallTexture(texture);
+      });
+    }
+  }, {
+    key: "setFullBuildingVisibility",
+    value: function setFullBuildingVisibility(value) {
+      this.isFullBuildingVisible = value;
+      this.globalPlane.constant = this.isFullBuildingVisible ? 1 : clippedBuildingConstant;
+      this.wallsGroup.children.forEach(function (_ref19) {
+        var children = _ref19.children;
+        return children[2].visible = !value;
+      });
+    }
+  }, {
+    key: "setPlanMode",
+    value: function setPlanMode() {
+      this.setDoorsVisibility(false);
+      this.setFullBuildingVisibility(false);
+      this.setCurrentWallsMaterialType('color');
+    }
+  }]);
 
-}
+  return HouseStore;
+}();
 
 var _default = HouseStore;
 exports.default = _default;