hart-estate-widget 0.0.10 → 0.0.11

package/build/utils/csg/three-csg.js

@@ -0,0 +1,280 @@
+"use strict";
+
+require("core-js/modules/web.dom-collections.iterator.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("core-js/modules/es.array-buffer.slice.js");
+
+require("core-js/modules/es.typed-array.float32-array.js");
+
+require("core-js/modules/es.typed-array.set.js");
+
+require("core-js/modules/es.typed-array.sort.js");
+
+require("core-js/modules/es.typed-array.to-locale-string.js");
+
+var _react = _interopRequireDefault(require("react"));
+
+var THREE = _interopRequireWildcard(require("three"));
+
+var _csgLib = require("./csg-lib.js");
+
+require("./csg-worker.js");
+
+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 }; }
+
+let {
+  Geometry,
+  BufferGeometry,
+  Vector3,
+  Vector2
+} = THREE;
+
+_csgLib.CSG.fromGeometry = function (geom, objectIndex) {
+  let polys = [];
+
+  if (geom.isGeometry) {
+    let fs = geom.faces;
+    let vs = geom.vertices;
+    let fm = ['a', 'b', 'c'];
+
+    for (let i = 0; i < fs.length; i++) {
+      let f = fs[i];
+      let vertices = [];
+
+      for (let j = 0; j < 3; j++) vertices.push(new _csgLib.Vertex(vs[f[fm[j]]], f.vertexNormals[j], geom.faceVertexUvs[0][i][j]));
+
+      polys.push(new _csgLib.Polygon(vertices, objectIndex));
+    }
+  } else if (geom.isBufferGeometry) {
+    let vertices, normals, uvs;
+    let posattr = geom.attributes.position;
+    let normalattr = geom.attributes.normal;
+    let uvattr = geom.attributes.uv;
+    let colorattr = geom.attributes.color;
+    let index;
+    if (geom.index) index = geom.index.array;else {
+      index = new Array(posattr.array.length / posattr.itemSize | 0);
+
+      for (let i = 0; i < index.length; i++) index[i] = i;
+    }
+    let triCount = index.length / 3 | 0;
+    polys = new Array(triCount);
+
+    for (let i = 0, pli = 0, l = index.length; i < l; i += 3, pli++) {
+      let vertices = new Array(3);
+
+      for (let j = 0; j < 3; j++) {
+        let vi = index[i + j];
+        let vp = vi * 3;
+        let vt = vi * 2;
+        let x = posattr.array[vp];
+        let y = posattr.array[vp + 1];
+        let z = posattr.array[vp + 2];
+        let nx = normalattr.array[vp];
+        let ny = normalattr.array[vp + 1];
+        let nz = normalattr.array[vp + 2]; //let u = uvattr.array[vt]
+        //let v = uvattr.array[vt + 1]
+
+        vertices[j] = new _csgLib.Vertex({
+          x,
+          y,
+          z
+        }, {
+          x: nx,
+          y: ny,
+          z: nz
+        }, uvattr && {
+          x: uvattr.array[vt],
+          y: uvattr.array[vt + 1],
+          z: 0
+        }, colorattr && {
+          x: colorattr.array[vt],
+          y: colorattr.array[vt + 1],
+          z: colorattr.array[vt + 2]
+        });
+      }
+
+      polys[pli] = new _csgLib.Polygon(vertices, objectIndex);
+    }
+  } else console.error("Unsupported CSG input type:" + geom.type);
+
+  return _csgLib.CSG.fromPolygons(polys);
+};
+
+let ttvv0 = new THREE.Vector3();
+let tmpm3 = new THREE.Matrix3();
+
+_csgLib.CSG.fromMesh = function (mesh, objectIndex) {
+  let csg = _csgLib.CSG.fromGeometry(mesh.geometry, objectIndex);
+
+  tmpm3.getNormalMatrix(mesh.matrix);
+
+  for (let i = 0; i < csg.polygons.length; i++) {
+    let p = csg.polygons[i];
+
+    for (let j = 0; j < p.vertices.length; j++) {
+      let v = p.vertices[j];
+      v.pos.copy(ttvv0.copy(v.pos).applyMatrix4(mesh.matrix));
+      v.normal.copy(ttvv0.copy(v.normal).applyMatrix3(tmpm3));
+    }
+  }
+
+  return csg;
+};
+
+let nbuf3 = ct => {
+  return {
+    top: 0,
+    array: new Float32Array(ct),
+    write: function write(v) {
+      this.array[this.top++] = v.x;
+      this.array[this.top++] = v.y;
+      this.array[this.top++] = v.z;
+    }
+  };
+};
+
+let nbuf2 = ct => {
+  return {
+    top: 0,
+    array: new Float32Array(ct),
+    write: function write(v) {
+      this.array[this.top++] = v.x;
+      this.array[this.top++] = v.y;
+    }
+  };
+};
+
+_csgLib.CSG.toGeometry = function (csg) {
+  let buffered = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  let ps = csg.polygons;
+  let geom;
+  let g2;
+
+  if (!buffered) //Old geometry path...
+    {
+      geom = new Geometry();
+      let vs = geom.vertices;
+      let fvuv = geom.faceVertexUvs[0];
+
+      for (let i = 0; i < ps.length; i++) {
+        let p = ps[i];
+        let pvs = p.vertices;
+        let v0 = vs.length;
+        let pvlen = pvs.length;
+
+        for (let j = 0; j < pvlen; j++) vs.push(new THREE.Vector3().copy(pvs[j].pos));
+
+        for (let j = 3; j <= pvlen; j++) {
+          let fc = new THREE.Face3();
+          let fuv = [];
+          fvuv.push(fuv);
+          let fnml = fc.vertexNormals;
+          fc.a = v0;
+          fc.b = v0 + j - 2;
+          fc.c = v0 + j - 1;
+          fnml.push(new THREE.Vector3().copy(pvs[0].normal));
+          fnml.push(new THREE.Vector3().copy(pvs[j - 2].normal));
+          fnml.push(new THREE.Vector3().copy(pvs[j - 1].normal));
+          fuv.push(new THREE.Vector3().copy(pvs[0].uv));
+          fuv.push(new THREE.Vector3().copy(pvs[j - 2].uv));
+          fuv.push(new THREE.Vector3().copy(pvs[j - 1].uv));
+          fc.normal = new THREE.Vector3().copy(p.plane.normal);
+          geom.faces.push(fc);
+        }
+      }
+
+      geom = new THREE.BufferGeometry().fromGeometry(geom);
+      geom.verticesNeedUpdate = geom.elementsNeedUpdate = geom.normalsNeedUpdate = true;
+    } else {
+    //BufferGeometry path
+    let triCount = 0;
+    ps.forEach(p => triCount += p.vertices.length - 2);
+    geom = new THREE.BufferGeometry();
+    let vertices = nbuf3(triCount * 3 * 3);
+    let normals = nbuf3(triCount * 3 * 3);
+    let uvs; // = nbuf2(triCount * 2 * 3)
+
+    let colors;
+    let grps = [];
+    ps.forEach(p => {
+      let pvs = p.vertices;
+      let pvlen = pvs.length;
+
+      if (p.shared !== undefined) {
+        if (!grps[p.shared]) grps[p.shared] = [];
+      }
+
+      if (pvlen) {
+        if (pvs[0].color !== undefined) {
+          if (!colors) colors = nbuf3(triCount * 3 * 3);
+        }
+
+        if (pvs[0].uv !== undefined) {
+          if (!uvs) uvs = nbuf2(triCount * 2 * 3);
+        }
+      }
+
+      for (let j = 3; j <= pvlen; j++) {
+        p.shared !== undefined && grps[p.shared].push(vertices.top / 3, vertices.top / 3 + 1, vertices.top / 3 + 2);
+        vertices.write(pvs[0].pos);
+        vertices.write(pvs[j - 2].pos);
+        vertices.write(pvs[j - 1].pos);
+        normals.write(pvs[0].normal);
+        normals.write(pvs[j - 2].normal);
+        normals.write(pvs[j - 1].normal);
+        uvs && pvs[0].uv && (uvs.write(pvs[0].uv) || uvs.write(pvs[j - 2].uv) || uvs.write(pvs[j - 1].uv));
+        colors && (colors.write(pvs[0].color) || colors.write(pvs[j - 2].color) || colors.write(pvs[j - 1].color));
+      }
+    });
+    geom.setAttribute('position', new THREE.BufferAttribute(vertices.array, 3));
+    geom.setAttribute('normal', new THREE.BufferAttribute(normals.array, 3));
+    uvs && geom.setAttribute('uv', new THREE.BufferAttribute(uvs.array, 2));
+    colors && geom.setAttribute('color', new THREE.BufferAttribute(colors.array, 3));
+
+    if (grps.length) {
+      let index = [];
+      let gbase = 0;
+
+      for (let gi = 0; gi < grps.length; gi++) {
+        geom.addGroup(gbase, grps[gi].length, gi);
+        gbase += grps[gi].length;
+        index = index.concat(grps[gi]);
+      }
+
+      geom.setIndex(index);
+    }
+
+    g2 = geom;
+  }
+
+  return geom;
+};
+
+_csgLib.CSG.toMesh = function (csg, toMatrix, toMaterial) {
+  let geom = _csgLib.CSG.toGeometry(csg);
+
+  let inv = new THREE.Matrix4().copy(toMatrix).invert();
+  geom.applyMatrix4(inv);
+  geom.computeBoundingSphere();
+  geom.computeBoundingBox();
+  let m = new THREE.Mesh(geom, toMaterial);
+  m.matrix.copy(toMatrix);
+  m.matrix.decompose(m.position, m.quaternion, m.scale);
+  m.rotation.setFromQuaternion(m.quaternion);
+  m.updateMatrixWorld();
+  m.castShadow = m.receiveShadow = true;
+  return m;
+};
+
+var _default = _csgLib.CSG;
+exports.default = _default;

package/build/utils/modelHelpers.js

@@ -5,13 +5,19 @@ require("core-js/modules/web.dom-collections.iterator.js");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.setDefaultControls = exports.addKeyboardControls = void 0;
+exports.getMinMaxCoordinates = exports.getKeyEvents = exports.getFloorParams = void 0;
 
 var _react = _interopRequireDefault(require("react"));
 
 var holdEvent = _interopRequireWildcard(require("hold-event"));
 
-var _cameraControls = _interopRequireDefault(require("camera-controls"));
+var _floor = _interopRequireDefault(require("../assets/img/floor.jpg"));
+
+var _floorDark = _interopRequireDefault(require("../assets/img/floor-dark.png"));
+
+var _floorWhite = _interopRequireDefault(require("../assets/img/floor-white.png"));
+
+var _floorBathroom = _interopRequireDefault(require("../assets/img/floor-bathroom.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); }
 
@@ -19,17 +25,26 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj &&
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-const setDefaultControls = (controls, angle) => {
-  controls.dollyTo(20, true);
-  controls.moveTo(0, 0, 0, true);
-  controls.mouseButtons.wheel = _cameraControls.default.ACTION.DOLLY;
-  controls.touches.two = _cameraControls.default.ACTION.NONE;
-  controls.rotateTo(0, angle, true); // this.destroyNipple();
+const FloorParams = {
+  'default': {
+    texture: _floorDark.default,
+    color: '#FFFFFF'
+  },
+  'Kitchen': {
+    texture: _floorWhite.default,
+    color: '#FFFFFF'
+  },
+  'Balcony': {
+    texture: _floor.default,
+    color: '#DADADA'
+  },
+  'Bathroom': {
+    texture: _floorBathroom.default,
+    color: '#FFFFFF'
+  }
 };
 
-exports.setDefaultControls = setDefaultControls;
-
-const addKeyboardControls = controls => {
+const getKeyEvents = controls => {
   const KEYCODE = {
     W: 87,
     A: 65,
@@ -52,30 +67,59 @@ const addKeyboardControls = controls => {
   const dKey = new holdEvent.KeyboardKeyHold(KEYCODE.D, 100);
   const rightKey = new holdEvent.KeyboardKeyHold(KEYCODE.ARROW_RIGHT, 100);
   const rightArr = [dKey, rightKey];
-  upArr.forEach(key => {
-    key.addEventListener('holding', () => {
-      if ((void 0).currentCONTROL !== 'wasd') return;
-      controls.forward(1, true);
-    });
-  });
-  leftArr.forEach(key => {
-    key.addEventListener('holding', () => {
-      if ((void 0).currentCONTROL !== 'wasd') return;
-      controls.truck(-1, 0, true);
-    });
-  });
-  downArr.forEach(key => {
-    key.addEventListener('holding', () => {
-      if ((void 0).currentCONTROL !== 'wasd') return;
-      controls.forward(-1, true);
-    });
-  });
-  rightArr.forEach(key => {
-    key.addEventListener('holding', () => {
-      if ((void 0).currentCONTROL !== 'wasd') return;
-      controls.truck(1, 0, true);
-    });
+  const keyEvents = [{
+    keys: upArr,
+    callback: () => controls.forward(1, true)
+  }, {
+    keys: leftArr,
+    callback: () => controls.truck(-1, 0, true)
+  }, {
+    keys: downArr,
+    callback: () => controls.forward(-1, true)
+  }, {
+    keys: rightArr,
+    callback: () => controls.truck(1, 0, true)
+  }];
+  return keyEvents;
+};
+
+exports.getKeyEvents = getKeyEvents;
+
+const getFloorParams = type => {
+  const params = FloorParams[type];
+  if (!params) return FloorParams['default'];
+  return params;
+};
+
+exports.getFloorParams = getFloorParams;
+
+const getMinMaxCoordinates = walls => {
+  let maxX = 0;
+  let minX = Infinity;
+  let maxY = 0;
+  let minY = Infinity;
+  walls.forEach(_ref => {
+    let {
+      start,
+      end
+    } = _ref;
+    // CALCULATE MAX COORDS
+    if (start.x > maxX) maxX = start.x;
+    if (start.x > maxX) maxX = start.x;
+    if (end.y > maxY) maxY = end.y;
+    if (end.y > maxY) maxY = end.y; // CALCULATE MIN COORDS
+
+    if (start.x < minX) minX = start.x;
+    if (start.x < minX) minX = start.x;
+    if (end.y < minY) minY = end.y;
+    if (end.y < minY) minY = end.y;
   });
+  return {
+    maxX,
+    minX,
+    maxY,
+    minY
+  };
 };
 
-exports.addKeyboardControls = addKeyboardControls;
+exports.getMinMaxCoordinates = getMinMaxCoordinates;

package/package.json

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