hart-estate-widget 0.0.49 → 0.0.52

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

@@ -5,306 +5,374 @@ Object.defineProperty(exports, "__esModule", {
 });
 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 = [];
-  }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-  clone() {
-    let csg = new CSG();
-    csg.polygons = this.polygons.map(p => p.clone());
-    return csg;
-  }
+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); } }
 
-  toPolygons() {
-    return this.polygons;
-  }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 
-  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());
-  }
+var CSG = /*#__PURE__*/function () {
+  function CSG() {
+    _classCallCheck(this, CSG);
 
-  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());
+    this.polygons = [];
   }
 
-  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;
-  }
+  _createClass(CSG, [{
+    key: "clone",
+    value: function clone() {
+      var csg = new CSG();
+      csg.polygons = this.polygons.map(function (p) {
+        return p.clone();
+      });
+      return csg;
+    }
+  }, {
+    key: "toPolygons",
+    value: function toPolygons() {
+      return this.polygons;
+    }
+  }, {
+    key: "union",
+    value: function union(csg) {
+      var a = new Node(this.clone().polygons);
+      var 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());
+    }
+  }, {
+    key: "subtract",
+    value: function subtract(csg) {
+      var a = new Node(this.clone().polygons);
+      var 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());
+    }
+  }, {
+    key: "intersect",
+    value: function intersect(csg) {
+      var a = new Node(this.clone().polygons);
+      var 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.
+
+  }, {
+    key: "inverse",
+    value: function inverse() {
+      var csg = this.clone();
+      csg.polygons.forEach(function (p) {
+        return p.flip();
+      });
+      return csg;
+    }
+  }]);
 
-}
+  return CSG;
+}();
 
 exports.CSG = CSG;
 
 CSG.fromPolygons = function (polygons) {
-  let csg = new CSG();
+  var 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;
+var Vector = /*#__PURE__*/function () {
+  function Vector() {
+    var x = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    var y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    var z = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+
+    _classCallCheck(this, Vector);
+
     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,
+  _createClass(Vector, [{
+    key: "copy",
+    value: function copy(v) {
+      this.x = v.x;
+      this.y = v.y;
+      this.z = v.z;
+      return this;
+    }
+  }, {
+    key: "clone",
+    value: function clone() {
+      return new Vector(this.x, this.y, this.z);
+    }
+  }, {
+    key: "negate",
+    value: function negate() {
+      this.x *= -1;
+      this.y *= -1;
+      this.z *= -1;
+      return this;
+    }
+  }, {
+    key: "add",
+    value: function add(a) {
+      this.x += a.x;
+      this.y += a.y;
+      this.z += a.z;
+      return this;
+    }
+  }, {
+    key: "sub",
+    value: function sub(a) {
+      this.x -= a.x;
+      this.y -= a.y;
+      this.z -= a.z;
+      return this;
+    }
+  }, {
+    key: "times",
+    value: function times(a) {
+      this.x *= a;
+      this.y *= a;
+      this.z *= a;
+      return this;
+    }
+  }, {
+    key: "dividedBy",
+    value: function dividedBy(a) {
+      this.x /= a;
+      this.y /= a;
+      this.z /= a;
+      return this;
+    }
+  }, {
+    key: "lerp",
+    value: function lerp(a, t) {
+      return this.add(tv0.copy(a).sub(this).times(t));
+    }
+  }, {
+    key: "unit",
+    value: function unit() {
+      return this.dividedBy(this.length());
+    }
+  }, {
+    key: "length",
+    value: function length() {
+      return Math.sqrt(Math.pow(this.x, 2) + Math.pow(this.y, 2) + Math.pow(this.z, 2));
+    }
+  }, {
+    key: "normalize",
+    value: function normalize() {
+      return this.unit();
+    }
+  }, {
+    key: "cross",
+    value: function cross(b) {
+      var a = this;
+      var ax = a.x,
           ay = a.y,
           az = a.z;
-    const bx = b.x,
+      var 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;
-  }
+      this.x = ay * bz - az * by;
+      this.y = az * bx - ax * bz;
+      this.z = ax * by - ay * bx;
+      return this;
+    }
+  }, {
+    key: "dot",
+    value: function dot(b) {
+      return this.x * b.x + this.y * b.y + this.z * b.z;
+    }
+  }]);
 
-}
+  return Vector;
+}();
 
 exports.Vector = Vector;
-let tv0 = new Vector();
-let tv1 = new Vector();
+var tv0 = new Vector();
+var tv1 = new Vector();
+
+var Vertex = /*#__PURE__*/function () {
+  function Vertex(pos, normal, uv, color) {
+    _classCallCheck(this, Vertex);
 
-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));
-  }
+  _createClass(Vertex, [{
+    key: "clone",
+    value: function clone() {
+      return new Vertex(this.pos, this.normal, this.uv, this.color);
+    }
+  }, {
+    key: "flip",
+    value: function flip() {
+      this.normal.negate();
+    }
+  }, {
+    key: "interpolate",
+    value: function 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));
+    }
+  }]);
 
-}
+  return Vertex;
+}();
 
 exports.Vertex = Vertex;
 
-class Plane {
-  constructor(normal, w) {
+var Plane = /*#__PURE__*/function () {
+  function Plane(normal, w) {
+    _classCallCheck(this, Plane);
+
     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());
+  _createClass(Plane, [{
+    key: "clone",
+    value: function clone() {
+      return new Plane(this.normal.clone(), this.w);
+    }
+  }, {
+    key: "flip",
+    value: function flip() {
+      this.normal.negate();
+      this.w = -this.w;
+    }
+  }, {
+    key: "splitPolygon",
+    value: function splitPolygon(polygon, coplanarFront, coplanarBack, front, back) {
+      var COPLANAR = 0;
+      var FRONT = 1;
+      var BACK = 2;
+      var SPANNING = 3;
+      var polygonType = 0;
+      var types = [];
+
+      for (var i = 0; i < polygon.vertices.length; i++) {
+        var t = this.normal.dot(polygon.vertices[i].pos) - this.w;
+        var 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:
+          var f = [];
+          var b = [];
+
+          for (var _i = 0; _i < polygon.vertices.length; _i++) {
+            var j = (_i + 1) % polygon.vertices.length;
+            var ti = types[_i],
+                tj = types[j];
+            var 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) {
+              var _t = (this.w - this.normal.dot(vi.pos)) / this.normal.dot(tv0.copy(vj.pos).sub(vi.pos));
+
+              var 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;
+          if (f.length >= 3) front.push(new Polygon(f, polygon.shared));
+          if (b.length >= 3) back.push(new Polygon(b, polygon.shared));
+          break;
+      }
     }
-  }
+  }]);
 
-}
+  return Plane;
+}();
 
 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();
+  var 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) {
+var Polygon = /*#__PURE__*/function () {
+  function Polygon(vertices, shared) {
+    _classCallCheck(this, Polygon);
+
     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();
-  }
+  _createClass(Polygon, [{
+    key: "clone",
+    value: function clone() {
+      return new Polygon(this.vertices.map(function (v) {
+        return v.clone();
+      }), this.shared);
+    }
+  }, {
+    key: "flip",
+    value: function flip() {
+      this.vertices.reverse().forEach(function (v) {
+        return v.flip();
+      });
+      this.plane.flip();
+    }
+  }]);
 
-}
+  return Polygon;
+}();
 
 exports.Polygon = Polygon;
 
-class Node {
-  constructor(polygons) {
+var Node = /*#__PURE__*/function () {
+  function Node(polygons) {
+    _classCallCheck(this, Node);
+
     this.plane = null;
     this.front = null;
     this.back = null;
@@ -312,76 +380,93 @@ class Node {
     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);
+  _createClass(Node, [{
+    key: "clone",
+    value: function clone() {
+      var 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(function (p) {
+        return p.clone();
+      });
+      return node;
     }
-
-    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);
+  }, {
+    key: "invert",
+    value: function invert() {
+      for (var 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();
+      var temp = this.front;
+      this.front = this.back;
+      this.back = temp;
     }
-
-    if (front.length) {
-      if (!this.front) this.front = new Node();
-      this.front.build(front);
+  }, {
+    key: "clipPolygons",
+    value: function clipPolygons(polygons) {
+      if (!this.plane) return polygons.slice();
+      var front = [],
+          back = [];
+
+      for (var 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);
     }
-
-    if (back.length) {
-      if (!this.back) this.back = new Node();
-      this.back.build(back);
+  }, {
+    key: "clipTo",
+    value: function clipTo(bsp) {
+      this.polygons = bsp.clipPolygons(this.polygons);
+      if (this.front) this.front.clipTo(bsp);
+      if (this.back) this.back.clipTo(bsp);
     }
-  }
+  }, {
+    key: "allPolygons",
+    value: function allPolygons() {
+      var polygons = this.polygons.slice();
+      if (this.front) polygons = polygons.concat(this.front.allPolygons());
+      if (this.back) polygons = polygons.concat(this.back.allPolygons());
+      return polygons;
+    }
+  }, {
+    key: "build",
+    value: function build(polygons) {
+      if (!polygons.length) return;
+      if (!this.plane) this.plane = polygons[0].plane.clone();
+      var front = [],
+          back = [];
+
+      for (var 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);
+      }
+    }
+  }]);
 
-}
+  return Node;
+}();
 
 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)));
+  return CSG.fromPolygons(json.polygons.map(function (p) {
+    return new Polygon(p.vertices.map(function (v) {
+      return new Vertex(v.pos, v.normal, v.uv);
+    }), p.shared);
+  }));
 };