hart-estate-widget 0.0.20 → 0.0.23

package/build/components/ModelTab.js

@@ -109,6 +109,8 @@ const ModelTab = (0, _mobxReactLite.observer)(_ref => {
   }, "View from above"), /*#__PURE__*/_react.default.createElement("li", {
     onClick: () => _modelStore.default.setCurrentControlsType('orbit')
   }, "Free camera"), /*#__PURE__*/_react.default.createElement("li", {
+    onClick: () => houseStore.setShadowsVisibility(!houseStore.isShadowsVisible)
+  }, "Shadows: ", houseStore.isShadowsVisible ? 'On' : 'Off'), /*#__PURE__*/_react.default.createElement("li", {
     onClick: () => houseStore.setPlanMode()
   }, "Plan"), /*#__PURE__*/_react.default.createElement("li", {
     onClick: () => houseStore.setFullBuildingVisibility(!houseStore.isFullBuildingVisible)

package/build/store/houseStore.js

@@ -11,6 +11,8 @@ 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");
@@ -33,6 +35,8 @@ var _doorTexture = _interopRequireDefault(require("../assets/img/door-texture.jp
 
 var _exteriorWallTexture = _interopRequireDefault(require("../assets/img/exterior-wall-texture.jpeg"));
 
+var _exteriorWallTextureRoughness = _interopRequireDefault(require("../assets/img/exterior-wall-texture-roughness.jpg"));
+
 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; }
@@ -55,6 +59,11 @@ const doorMaterialOptions = {
 };
 const modelLoader = new _FBXLoader.FBXLoader();
 
+const createDefaultMaterial = options => new THREE.MeshStandardMaterial(_objectSpread({
+  roughness: 1,
+  metalness: 0
+}, options));
+
 class HouseStore {
   constructor(modelStore) {
     _defineProperty(this, "modelStore", null);
@@ -73,6 +82,11 @@ class HouseStore {
 
     _defineProperty(this, "wallsColor", '#FFFFFF');
 
+    _defineProperty(this, "exteriorWallsMaps", {
+      map: null,
+      roughnessMap: null
+    });
+
     _defineProperty(this, "exteriorWallsMaterial", null);
 
     _defineProperty(this, "wallsTextures", []);
@@ -93,6 +107,8 @@ class HouseStore {
 
     _defineProperty(this, "loadedTextures", {});
 
+    _defineProperty(this, "isShadowsVisible", true);
+
     (0, _mobx.makeAutoObservable)(this);
     this.modelStore = modelStore;
     this.houseGroup.name = 'House-Group';
@@ -259,20 +275,33 @@ class HouseStore {
       const vertices = this.getVerticesFromParsedWalls(walls);
       const shape = new THREE.Shape(vertices);
       const geometry = new THREE.ShapeGeometry(shape);
-      const material = new THREE.MeshBasicMaterial({
+      const material = createDefaultMaterial({
         color: params.color,
         side: THREE.DoubleSide
       });
       const mesh = new THREE.Mesh(geometry, material);
+      mesh.receiveShadow = true;
+      mesh.castShadow = false;
       mesh.name = 'FloorMesh';
-      this.loadTexture(params.texture, [0.5, 0.5], texture => {
-        const textureMaterial = new THREE.MeshBasicMaterial({
+
+      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);
+      };
+
+      this.loadTexture(params.texture, [0.5, 0.5], texture => {
+        if (!params.roughnessMap) {
+          callback(texture);
+          return;
+        }
+
+        this.loadTexture(params.roughnessMap, [0.5, 0.5], roughnessMap => callback(texture, roughnessMap));
       });
     });
     return this;
@@ -305,16 +334,18 @@ class HouseStore {
       depth,
       bevelEnabled: false
     });
-    const clippedMaterial = new THREE.MeshBasicMaterial({
+    const clippedMaterial = createDefaultMaterial({
       side: THREE.DoubleSide,
       color: '#5C5C5C'
     });
-    const material = new THREE.MeshBasicMaterial(_objectSpread(_objectSpread({}, this.wallMaterialOptions), {}, {
+    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;
@@ -324,6 +355,10 @@ class HouseStore {
     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;
   }
@@ -345,10 +380,10 @@ class HouseStore {
         bevelEnabled: false
       });
       const wallMaterial = isExterior ? this.exteriorWallsMaterial : this.wallsMaterial;
-      const wallPadMaterial = new THREE.MeshBasicMaterial(_objectSpread(_objectSpread({}, this.wallMaterialOptions), {}, {
+      const wallPadMaterial = createDefaultMaterial(_objectSpread(_objectSpread({}, this.wallMaterialOptions), {}, {
         color: '#5C5C5C'
       }));
-      const wallClippedPadMaterial = new THREE.MeshBasicMaterial({
+      const wallClippedPadMaterial = createDefaultMaterial({
         side: THREE.DoubleSide,
         color: '#5C5C5C'
       });
@@ -356,10 +391,18 @@ class HouseStore {
       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;
@@ -368,6 +411,11 @@ class HouseStore {
       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
@@ -392,6 +440,8 @@ class HouseStore {
       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);
@@ -411,7 +461,7 @@ class HouseStore {
       } = _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({
+      const apertureMaterial = createDefaultMaterial({
         color: '#00B4F7'
       });
       const apertureMesh = new THREE.Mesh(apertureGeometry, apertureMaterial);
@@ -440,7 +490,60 @@ class HouseStore {
       maxY,
       minY
     } = (0, _modelHelpers.getMinMaxCoordinates)(walls);
-    this.houseGroup.position.set(-(maxX + minX) / 2, -(maxY + minY) / 2);
+    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;
   }
 
@@ -464,7 +567,7 @@ class HouseStore {
           image: _wallTexture.default,
           texture: texture
         });
-        this.wallsMaterial = new THREE.MeshBasicMaterial(_objectSpread(_objectSpread({}, this.wallMaterialOptions), {}, {
+        this.wallsMaterial = createDefaultMaterial(_objectSpread(_objectSpread({}, this.wallMaterialOptions), {}, {
           map: texture
         }));
       }
@@ -476,26 +579,33 @@ class HouseStore {
           image: _exteriorWallTexture.default,
           texture: texture
         });
-        this.exteriorWallsMaterial = new THREE.MeshBasicMaterial(_objectSpread(_objectSpread({}, this.wallMaterialOptions), {}, {
-          map: texture,
-          color: '#FFFFFF'
-        }));
+        this.exteriorWallsMaps.map = texture;
+      }
+    }, {
+      img: _exteriorWallTextureRoughness.default,
+      repeat: [1, 1],
+      callback: texture => {
+        this.wallsTextures.push({
+          image: _exteriorWallTextureRoughness.default,
+          texture: texture
+        });
+        this.exteriorWallsMaps.roughnessMap = texture;
       }
     }, {
       img: _doorTexture.default,
       repeat: [1, 1],
       callback: texture => {
-        this.doorMaterial = new THREE.MeshBasicMaterial(_objectSpread(_objectSpread({}, doorMaterialOptions), {}, {
+        this.doorMaterial = createDefaultMaterial(_objectSpread(_objectSpread({}, doorMaterialOptions), {}, {
           map: texture
         }));
       }
     }];
-    return Promise.all(assets.map(_ref10 => {
+    return Promise.all(assets.map(_ref11 => {
       let {
         img,
         repeat,
         callback
-      } = _ref10;
+      } = _ref11;
       return new Promise(resolve => {
         this.loadTexture(img, repeat, texture => {
           callback(texture);
@@ -522,7 +632,7 @@ class HouseStore {
     const modelPath = "".concat(this.apiStore.API_URL, "/storage/furniture/").concat(mesh);
     const {
       Location,
-      Rotation,
+      WEB_Rotation,
       Model: ModelName
     } = furniture;
     const {
@@ -538,33 +648,80 @@ class HouseStore {
     });
 
     const onTexturesLoaded = (result, model) => {
-      const materials = result.map(texture => new THREE.MeshBasicMaterial({
-        map: texture,
-        opacity: 0,
-        transparent: true
-      }));
+      const materialsCount = result.reduce((acc, _ref12) => {
+        let {
+          image
+        } = _ref12;
+        if (!image.currentSrc.includes('_D.') && !image.currentSrc.includes('_DA.')) return acc;
+        return acc += 1;
+      }, 0);
+
+      const createMaterial = num => {
+        const map = result.find(_ref13 => {
+          let {
+            image
+          } = _ref13;
+          return image.currentSrc.includes("".concat(num, "_D.")) || image.currentSrc.includes("".concat(num, "_DA."));
+        });
+        const envMap = result.find(_ref14 => {
+          let {
+            image
+          } = _ref14;
+          return image.currentSrc.includes("".concat(num, "_RMO."));
+        });
+        const normalMap = result.find(_ref15 => {
+          let {
+            image
+          } = _ref15;
+          return image.currentSrc.includes("".concat(num, "_N."));
+        });
+        const 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;
+      };
+
+      let materials = new THREE.MeshPhysicalMaterial({
+        roughness: 1,
+        clearcoat: 1,
+        clearcoatRoughness: 1,
+        reflectivity: 0,
+        fog: false
+      });
+
+      if (materialsCount === 1) {
+        materials = createMaterial('');
+      }
+
+      if (materialsCount > 1) {
+        materials = [...Array(materialsCount).keys()].map(i => {
+          const num = i + 1;
+          const realNum = num < 10 ? "0".concat(num) : num;
+          return createMaterial(realNum);
+        });
+      }
+
       model.traverse(node => {
-        if (node.isMesh) node.material = materials;
+        if (node.isMesh) {
+          node.material = materials;
+          node.receiveShadow = true;
+          node.castShadow = true;
+        }
       });
       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);
+      model.rotation.set(Math.PI / 2, THREE.Math.degToRad(WEB_Rotation.Yaw), 0);
       const loadedTextures = this.loadedTextures[ModelName];
 
       if (loadedTextures) {
@@ -592,6 +749,16 @@ class HouseStore {
   } // Actions
 
 
+  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;
+    });
+  }
+
   setDoorsVisibility(value) {
     this.isDoorsVisible = value;
     this.doorsGroup.children.forEach(door => door.visible = value);
@@ -599,11 +766,11 @@ class HouseStore {
 
   setCurrentWallsMaterialType(value) {
     this.wallsMaterialType = value;
-    this.wallsGroup.children.forEach(_ref11 => {
+    this.wallsGroup.children.forEach(_ref16 => {
       let {
         children,
         isExterior
-      } = _ref11;
+      } = _ref16;
       const wall = children[0];
 
       if (value === 'texture') {
@@ -612,7 +779,7 @@ class HouseStore {
       }
 
       const color = isExterior ? '#FFFFFF' : this.wallsColor;
-      wall.material = new THREE.MeshBasicMaterial(_objectSpread(_objectSpread({}, this.wallMaterialOptions), {}, {
+      wall.material = createDefaultMaterial(_objectSpread(_objectSpread({}, this.wallMaterialOptions), {}, {
         color
       }));
     });
@@ -622,18 +789,18 @@ class HouseStore {
         return;
       }
 
-      door.material = new THREE.MeshBasicMaterial(doorMaterialOptions);
+      door.material = createDefaultMaterial(doorMaterialOptions);
     });
   }
 
   setCurrentWallColor(color) {
     this.wallsColor = color;
     this.wallsMaterial.color.set(color);
-    this.wallsGroup.children.forEach(_ref12 => {
+    this.wallsGroup.children.forEach(_ref17 => {
       let {
         children,
         isExterior
-      } = _ref12;
+      } = _ref17;
       if (isExterior) return;
       const wall = children[0];
       wall.material.color.set(color);
@@ -641,7 +808,7 @@ class HouseStore {
   }
 
   setCurrentWallTexture(texture) {
-    this.wallsMaterial = new THREE.MeshBasicMaterial(_objectSpread(_objectSpread({}, this.wallMaterialOptions), {}, {
+    this.wallsMaterial = createDefaultMaterial(_objectSpread(_objectSpread({}, this.wallMaterialOptions), {}, {
       map: texture
     }));
     this.setCurrentWallsMaterialType('texture');
@@ -660,10 +827,10 @@ class HouseStore {
   setFullBuildingVisibility(value) {
     this.isFullBuildingVisible = value;
     this.globalPlane.constant = this.isFullBuildingVisible ? 1 : clippedBuildingConstant;
-    this.wallsGroup.children.forEach(_ref13 => {
+    this.wallsGroup.children.forEach(_ref18 => {
       let {
         children
-      } = _ref13;
+      } = _ref18;
       return children[2].visible = !value;
     });
   }

package/build/store/modelStore.js

@@ -5,6 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+require("core-js/modules/es.promise.js");
+
 require("core-js/modules/web.dom-collections.iterator.js");
 
 var _react = _interopRequireDefault(require("react"));
@@ -92,25 +94,30 @@ class ModelStore {
 
     _defineProperty(this, "createScene", () => {
       this.scene = new THREE.Scene();
-      const light = new THREE.AmbientLight(0xffffff);
       this.scene.rotation.x = -Math.PI / 2;
       this.scene.scale.y = -1;
-      this.scene.background = new THREE.Color('#FAFAFA');
-      this.scene.add(light);
+      this.scene.background = new THREE.Color('#E7E7E7');
+      this.scene.fog = new THREE.Fog('#E7E7E7', 5, 200);
       this.createGround();
       return this;
     });
 
     _defineProperty(this, "createGround", () => {
-      this.textureLoader.load(_grass.default, texture => {
-        texture.wrapS = texture.wrapT = THREE.RepeatWrapping;
-        texture.repeat.set(70, 70);
-        let groundMaterial = new THREE.MeshBasicMaterial({
-          map: texture,
-          color: 'rgb(255,255,255)'
+      const textures = {};
+      const assets = [new Promise(resolve => this.loadTexture(_grass.default, [75, 75], texture => {
+        textures.map = texture;
+        resolve();
+      }))];
+      Promise.all(assets).then(() => {
+        let groundMaterial = new THREE.MeshStandardMaterial({
+          map: textures.map,
+          normalMap: textures.normalMap,
+          envMap: textures.envMap,
+          color: 0xe7e7e7
         });
-        let groundMesh = new THREE.Mesh(new THREE.PlaneBufferGeometry(300, 300), groundMaterial);
+        let groundMesh = new THREE.Mesh(new THREE.CircleGeometry(250, 100), groundMaterial);
         groundMesh.position.z = -0.01;
+        groundMesh.receiveShadow = true;
         this.scene.add(groundMesh);
       });
       return this;
@@ -121,6 +128,8 @@ class ModelStore {
       this.renderer.setPixelRatio(window.devicePixelRatio);
       this.updateRendererSize();
       this.renderer.localClippingEnabled = true;
+      this.renderer.shadowMap.enabled = true;
+      this.renderer.shadowMap.type = THREE.PCFSoftShadowMap;
       return this;
     });
 
@@ -187,7 +196,7 @@ class ModelStore {
       this.controls.moveTo(0, 0, 0, true);
       this.controls.mouseButtons.wheel = _cameraControls.default.ACTION.DOLLY;
       this.controls.touches.two = _cameraControls.default.ACTION.TOUCH_DOLLY_TRUCK;
-      this.controls.rotateTo(0, angle, true); // this.destroyNipple();
+      this.controls.rotateTo(0, angle, true);
     });
 
     _defineProperty(this, "setCurrentControlsType", type => {
@@ -253,6 +262,17 @@ class ModelStore {
     return ((_this$container2 = this.container) === null || _this$container2 === void 0 ? void 0 : _this$container2.offsetHeight) || window.innerHeight;
   }
 
+  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);
+    });
+  }
+
 }
 
 var _default = new ModelStore();

package/build/utils/modelHelpers.js

@@ -28,18 +28,22 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 const FloorParams = {
   'default': {
     texture: _floorDark.default,
+    roughnessMap: null,
     color: '#FFFFFF'
   },
   'Kitchen': {
     texture: _floorWhite.default,
+    roughnessMap: null,
     color: '#FFFFFF'
   },
   'Balcony': {
     texture: _floor.default,
+    roughnessMap: null,
     color: '#DADADA'
   },
   'Bathroom': {
     texture: _floorBathroom.default,
+    roughnessMap: null,
     color: '#FFFFFF'
   }
 };

package/package.json

@@ -3,7 +3,7 @@
   "description": "HART Estate widget",
   "author": "HART",
   "keywords": [],
-  "version": "0.0.20",
+  "version": "0.0.23",
   "private": false,
   "main": "build/index.js",
   "module": "build/index.js",