hart-estate-widget 0.0.10 → 0.0.11

package/build/store/modelStore.js

@@ -0,0 +1,196 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("core-js/modules/web.dom-collections.iterator.js");
+
+var _react = _interopRequireDefault(require("react"));
+
+var _mobx = require("mobx");
+
+var THREE = _interopRequireWildcard(require("three"));
+
+var _cameraControls = _interopRequireDefault(require("camera-controls"));
+
+var _houseStore = _interopRequireDefault(require("./houseStore"));
+
+var _grass = _interopRequireDefault(require("../assets/img/grass.png"));
+
+var _modelHelpers = require("../utils/modelHelpers");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+(0, _mobx.configure)({
+  useProxies: 'never'
+});
+
+class ModelStore {
+  constructor() {
+    _defineProperty(this, "json", null);
+
+    _defineProperty(this, "initialized", false);
+
+    _defineProperty(this, "textureLoader", new THREE.TextureLoader());
+
+    _defineProperty(this, "clock", new THREE.Clock());
+
+    _defineProperty(this, "scene", null);
+
+    _defineProperty(this, "renderer", null);
+
+    _defineProperty(this, "camera", null);
+
+    _defineProperty(this, "controls", null);
+
+    _defineProperty(this, "houseStore", null);
+
+    _defineProperty(this, "sceneScale", 0.025);
+
+    _defineProperty(this, "wallsHeight", 280 * this.sceneScale);
+
+    _defineProperty(this, "init", json => {
+      this.json = json;
+      this.initialized = true;
+      this.houseStore = new _houseStore.default(this);
+      this.scene.add(this.houseStore.houseGroup);
+    });
+
+    _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); // const axesHelper = new THREE.AxesHelper( 50 );
+      // this.scene.add( axesHelper );
+
+      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)'
+        });
+        let groundMesh = new THREE.Mesh(new THREE.PlaneBufferGeometry(300, 300), groundMaterial);
+        groundMesh.position.z = -0.01;
+        this.scene.add(groundMesh);
+      });
+      return this;
+    });
+
+    _defineProperty(this, "createRenderer", () => {
+      this.renderer = new THREE.WebGLRenderer();
+      this.renderer.setPixelRatio(window.devicePixelRatio);
+      this.renderer.setSize(window.innerWidth, window.innerHeight);
+      this.renderer.localClippingEnabled = true;
+      return this;
+    });
+
+    _defineProperty(this, "createCamera", () => {
+      this.camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
+      this.camera.position.set(0, 0, 0);
+      window.addEventListener('resize', () => {
+        this.camera.aspect = window.innerWidth / window.innerHeight;
+        this.camera.updateProjectionMatrix();
+        this.renderer.setSize(window.innerWidth, window.innerHeight);
+      });
+      return this;
+    });
+
+    _defineProperty(this, "createControls", () => {
+      this.controls = new _cameraControls.default(this.camera, this.renderer.domElement);
+      this.controls.minDistance = 0.5;
+      this.controls.maxDistance = 50;
+      this.controls.maxPolarAngle = Math.PI / 2.1;
+      this.setDefaultControls(Math.PI / 4);
+      this.controls.verticalDragToForward = true;
+      this.controls.currentControlsType = 'orbit';
+
+      const animate = () => {
+        this.controls.update(this.clock.getDelta());
+        window.requestAnimationFrame(animate);
+        this.renderer.render(this.scene, this.camera);
+      };
+
+      animate();
+      return this;
+    });
+
+    _defineProperty(this, "setDefaultControls", angle => {
+      this.controls.dollyTo(20, true);
+      this.controls.moveTo(0, 0, 0, true);
+      this.controls.mouseButtons.wheel = _cameraControls.default.ACTION.DOLLY;
+      this.controls.touches.two = _cameraControls.default.ACTION.NONE;
+      this.controls.rotateTo(0, angle, true); // this.destroyNipple();
+    });
+
+    _defineProperty(this, "setCurrentControlsType", type => {
+      this.controls.currentControlsType = type;
+      const EPS = 1e-5;
+
+      if (type === 'orbit') {
+        this.controls.maxPolarAngle = Math.PI / 2.1;
+        this.setDefaultControls(Math.PI / 4);
+        return;
+      }
+
+      if (type === 'plan') {
+        this.setDefaultControls(0);
+        this.controls.maxPolarAngle = 0;
+        return;
+      }
+
+      if (type === 'wasd') {
+        this.camera.position.set(0, 0, EPS);
+        this.controls.maxPolarAngle = Math.PI;
+        this.controls.dollyTo(0, true);
+        this.controls.moveTo(0, this.wallsHeight / 2, 0, true);
+        this.controls.rotateTo(0, Math.PI / 2, true);
+        this.controls.mouseButtons.wheel = _cameraControls.default.ACTION.NONE;
+        this.controls.touches.two = _cameraControls.default.ACTION.NONE;
+      }
+    });
+
+    _defineProperty(this, "addKeyEvents", () => {
+      const keyEvents = (0, _modelHelpers.getKeyEvents)(this.controls);
+      keyEvents.forEach(_ref => {
+        let {
+          keys,
+          callback
+        } = _ref;
+        keys.forEach(key => key.addEventListener('holding', () => {
+          if (this.controls.currentControlsType !== 'wasd') return;
+          callback();
+        }));
+      });
+      return this;
+    });
+
+    (0, _mobx.makeAutoObservable)(this);
+
+    _cameraControls.default.install({
+      THREE: THREE
+    });
+
+    this.createScene().createRenderer().createCamera().createControls().addKeyEvents();
+  }
+
+}
+
+var _default = new ModelStore();
+
+exports.default = _default;

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

@@ -0,0 +1,387 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Vertex = exports.Vector = exports.Polygon = exports.Plane = exports.CSG = void 0;
+
+require("core-js/modules/es.array.reverse.js");
+
+var _react = _interopRequireDefault(require("react"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class CSG {
+  constructor() {
+    this.polygons = [];
+  }
+
+  clone() {
+    let csg = new CSG();
+    csg.polygons = this.polygons.map(p => p.clone());
+    return csg;
+  }
+
+  toPolygons() {
+    return this.polygons;
+  }
+
+  union(csg) {
+    let a = new Node(this.clone().polygons);
+    let b = new Node(csg.clone().polygons);
+    a.clipTo(b);
+    b.clipTo(a);
+    b.invert();
+    b.clipTo(a);
+    b.invert();
+    a.build(b.allPolygons());
+    return CSG.fromPolygons(a.allPolygons());
+  }
+
+  subtract(csg) {
+    let a = new Node(this.clone().polygons);
+    let b = new Node(csg.clone().polygons);
+    a.invert();
+    a.clipTo(b);
+    b.clipTo(a);
+    b.invert();
+    b.clipTo(a);
+    b.invert();
+    a.build(b.allPolygons());
+    a.invert();
+    return CSG.fromPolygons(a.allPolygons());
+  }
+
+  intersect(csg) {
+    let a = new Node(this.clone().polygons);
+    let b = new Node(csg.clone().polygons);
+    a.invert();
+    b.clipTo(a);
+    b.invert();
+    a.clipTo(b);
+    b.clipTo(a);
+    a.build(b.allPolygons());
+    a.invert();
+    return CSG.fromPolygons(a.allPolygons());
+  } // Return a new CSG solid with solid and empty space switched. This solid is
+  // not modified.
+
+
+  inverse() {
+    let csg = this.clone();
+    csg.polygons.forEach(p => p.flip());
+    return csg;
+  }
+
+}
+
+exports.CSG = CSG;
+
+CSG.fromPolygons = function (polygons) {
+  let csg = new CSG();
+  csg.polygons = polygons;
+  return csg;
+};
+
+class Vector {
+  constructor() {
+    let x = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    let y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    let z = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+
+  copy(v) {
+    this.x = v.x;
+    this.y = v.y;
+    this.z = v.z;
+    return this;
+  }
+
+  clone() {
+    return new Vector(this.x, this.y, this.z);
+  }
+
+  negate() {
+    this.x *= -1;
+    this.y *= -1;
+    this.z *= -1;
+    return this;
+  }
+
+  add(a) {
+    this.x += a.x;
+    this.y += a.y;
+    this.z += a.z;
+    return this;
+  }
+
+  sub(a) {
+    this.x -= a.x;
+    this.y -= a.y;
+    this.z -= a.z;
+    return this;
+  }
+
+  times(a) {
+    this.x *= a;
+    this.y *= a;
+    this.z *= a;
+    return this;
+  }
+
+  dividedBy(a) {
+    this.x /= a;
+    this.y /= a;
+    this.z /= a;
+    return this;
+  }
+
+  lerp(a, t) {
+    return this.add(tv0.copy(a).sub(this).times(t));
+  }
+
+  unit() {
+    return this.dividedBy(this.length());
+  }
+
+  length() {
+    return Math.sqrt(this.x ** 2 + this.y ** 2 + this.z ** 2);
+  }
+
+  normalize() {
+    return this.unit();
+  }
+
+  cross(b) {
+    let a = this;
+    const ax = a.x,
+          ay = a.y,
+          az = a.z;
+    const bx = b.x,
+          by = b.y,
+          bz = b.z;
+    this.x = ay * bz - az * by;
+    this.y = az * bx - ax * bz;
+    this.z = ax * by - ay * bx;
+    return this;
+  }
+
+  dot(b) {
+    return this.x * b.x + this.y * b.y + this.z * b.z;
+  }
+
+}
+
+exports.Vector = Vector;
+let tv0 = new Vector();
+let tv1 = new Vector();
+
+class Vertex {
+  constructor(pos, normal, uv, color) {
+    this.pos = new Vector().copy(pos);
+    this.normal = new Vector().copy(normal);
+    uv && (this.uv = new Vector().copy(uv)) && (this.uv.z = 0);
+    color && (this.color = new Vector().copy(color));
+  }
+
+  clone() {
+    return new Vertex(this.pos, this.normal, this.uv, this.color);
+  }
+
+  flip() {
+    this.normal.negate();
+  }
+
+  interpolate(other, t) {
+    return new Vertex(this.pos.clone().lerp(other.pos, t), this.normal.clone().lerp(other.normal, t), this.uv && other.uv && this.uv.clone().lerp(other.uv, t), this.color && other.color && this.color.clone().lerp(other.color, t));
+  }
+
+}
+
+exports.Vertex = Vertex;
+
+class Plane {
+  constructor(normal, w) {
+    this.normal = normal;
+    this.w = w;
+  }
+
+  clone() {
+    return new Plane(this.normal.clone(), this.w);
+  }
+
+  flip() {
+    this.normal.negate();
+    this.w = -this.w;
+  }
+
+  splitPolygon(polygon, coplanarFront, coplanarBack, front, back) {
+    const COPLANAR = 0;
+    const FRONT = 1;
+    const BACK = 2;
+    const SPANNING = 3;
+    let polygonType = 0;
+    let types = [];
+
+    for (let i = 0; i < polygon.vertices.length; i++) {
+      let t = this.normal.dot(polygon.vertices[i].pos) - this.w;
+      let type = t < -Plane.EPSILON ? BACK : t > Plane.EPSILON ? FRONT : COPLANAR;
+      polygonType |= type;
+      types.push(type);
+    }
+
+    switch (polygonType) {
+      case COPLANAR:
+        (this.normal.dot(polygon.plane.normal) > 0 ? coplanarFront : coplanarBack).push(polygon);
+        break;
+
+      case FRONT:
+        front.push(polygon);
+        break;
+
+      case BACK:
+        back.push(polygon);
+        break;
+
+      case SPANNING:
+        let f = [];
+        let b = [];
+
+        for (let i = 0; i < polygon.vertices.length; i++) {
+          let j = (i + 1) % polygon.vertices.length;
+          let ti = types[i],
+              tj = types[j];
+          let vi = polygon.vertices[i],
+              vj = polygon.vertices[j];
+          if (ti != BACK) f.push(vi);
+          if (ti != FRONT) b.push(ti != BACK ? vi.clone() : vi);
+
+          if ((ti | tj) == SPANNING) {
+            let t = (this.w - this.normal.dot(vi.pos)) / this.normal.dot(tv0.copy(vj.pos).sub(vi.pos));
+            let v = vi.interpolate(vj, t);
+            f.push(v);
+            b.push(v.clone());
+          }
+        }
+
+        if (f.length >= 3) front.push(new Polygon(f, polygon.shared));
+        if (b.length >= 3) back.push(new Polygon(b, polygon.shared));
+        break;
+    }
+  }
+
+}
+
+exports.Plane = Plane;
+Plane.EPSILON = 1e-5;
+
+Plane.fromPoints = function (a, b, c) {
+  let n = tv0.copy(b).sub(a).cross(tv1.copy(c).sub(a)).normalize();
+  return new Plane(n.clone(), n.dot(a));
+};
+
+class Polygon {
+  constructor(vertices, shared) {
+    this.vertices = vertices;
+    this.shared = shared;
+    this.plane = Plane.fromPoints(vertices[0].pos, vertices[1].pos, vertices[2].pos);
+  }
+
+  clone() {
+    return new Polygon(this.vertices.map(v => v.clone()), this.shared);
+  }
+
+  flip() {
+    this.vertices.reverse().forEach(v => v.flip());
+    this.plane.flip();
+  }
+
+}
+
+exports.Polygon = Polygon;
+
+class Node {
+  constructor(polygons) {
+    this.plane = null;
+    this.front = null;
+    this.back = null;
+    this.polygons = [];
+    if (polygons) this.build(polygons);
+  }
+
+  clone() {
+    let node = new Node();
+    node.plane = this.plane && this.plane.clone();
+    node.front = this.front && this.front.clone();
+    node.back = this.back && this.back.clone();
+    node.polygons = this.polygons.map(p => p.clone());
+    return node;
+  }
+
+  invert() {
+    for (let i = 0; i < this.polygons.length; i++) this.polygons[i].flip();
+
+    this.plane && this.plane.flip();
+    this.front && this.front.invert();
+    this.back && this.back.invert();
+    let temp = this.front;
+    this.front = this.back;
+    this.back = temp;
+  }
+
+  clipPolygons(polygons) {
+    if (!this.plane) return polygons.slice();
+    let front = [],
+        back = [];
+
+    for (let i = 0; i < polygons.length; i++) {
+      this.plane.splitPolygon(polygons[i], front, back, front, back);
+    }
+
+    if (this.front) front = this.front.clipPolygons(front);
+    if (this.back) back = this.back.clipPolygons(back);else back = [];
+    return front.concat(back);
+  }
+
+  clipTo(bsp) {
+    this.polygons = bsp.clipPolygons(this.polygons);
+    if (this.front) this.front.clipTo(bsp);
+    if (this.back) this.back.clipTo(bsp);
+  }
+
+  allPolygons() {
+    let polygons = this.polygons.slice();
+    if (this.front) polygons = polygons.concat(this.front.allPolygons());
+    if (this.back) polygons = polygons.concat(this.back.allPolygons());
+    return polygons;
+  }
+
+  build(polygons) {
+    if (!polygons.length) return;
+    if (!this.plane) this.plane = polygons[0].plane.clone();
+    let front = [],
+        back = [];
+
+    for (let i = 0; i < polygons.length; i++) {
+      this.plane.splitPolygon(polygons[i], this.polygons, this.polygons, front, back);
+    }
+
+    if (front.length) {
+      if (!this.front) this.front = new Node();
+      this.front.build(front);
+    }
+
+    if (back.length) {
+      if (!this.back) this.back = new Node();
+      this.back.build(back);
+    }
+  }
+
+}
+
+CSG.fromJSON = function (json) {
+  return CSG.fromPolygons(json.polygons.map(p => new Polygon(p.vertices.map(v => new Vertex(v.pos, v.normal, v.uv)), p.shared)));
+};

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

@@ -0,0 +1,94 @@
+"use strict";
+
+require("core-js/modules/es.promise.js");
+
+require("core-js/modules/web.dom-collections.iterator.js");
+
+require("core-js/modules/web.url.js");
+
+require("core-js/modules/web.url-search-params.js");
+
+require("core-js/modules/es.json.stringify.js");
+
+var _react = _interopRequireDefault(require("react"));
+
+var _csgLib = require("./csg-lib.js");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+let gWorkersStarted = false;
+let gWorker;
+let gWorkerUrl;
+let taskId = 0;
+let tasks = {};
+
+let spawnWorker = () => {
+  const worker = new Worker(gWorkerUrl);
+
+  worker.onmessage = function (e) {
+    let rslt = JSON.parse(e.data);
+    let task = tasks[rslt.taskId];
+    delete tasks[rslt.taskId];
+    task.resolve(_csgLib.CSG.fromJSON(rslt.result)); //console.log('Message received from worker');
+
+    gWorker.busy = false;
+  };
+
+  return gWorker = {
+    worker,
+    busy: false
+  };
+};
+
+let getWorker = () => {
+  if (!gWorkersStarted) {
+    gWorkersStarted = true;
+    return fetch('../csg-lib.js').then(function (response) {
+      return response.text().then(function (text) {
+        text = text.slice(0, text.lastIndexOf('export'));
+        const code = text + "\n                    self.onmessage=(message)=>{\n                    let task = JSON.parse(message.data)\n                    //console.log(\"Got task:\"+task.op+' '+task.taskId)\n                    postMessage(JSON.stringify({\n                        taskId:task.taskId,\n                        result : CSG.fromJSON(task.a)[task.op](CSG.fromJSON(task.b))\n                    }))\n                }\n                console.log('CSG worker started!')";
+        const blob = new Blob([code], {
+          type: 'application/javascript'
+        });
+        gWorkerUrl = URL.createObjectURL(blob);
+      }).then(() => {
+        return spawnWorker();
+      });
+    });
+  }
+
+  if (gWorker && !gWorker.busy) {
+    gWorker.busy = true;
+    return {
+      then: fn => {
+        return fn(gWorker);
+      }
+    };
+  }
+
+  return {
+    then: function then() {
+      return this;
+    }
+  };
+};
+
+_csgLib.CSG.doAsync = (a, op, b) => {
+  return getWorker().then(worker => {
+    let task = {
+      a,
+      op,
+      b,
+      taskId
+    };
+    tasks[taskId] = task;
+    taskId++;
+    task.result = new Promise((resolve, reject) => {
+      task.resolve = resolve; //console.log("posting to worker:")
+
+      worker.busy = true;
+      worker.worker.postMessage(JSON.stringify(task));
+    });
+    return task.result;
+  });
+};