@jgphilpott/polytree 0.0.7 → 0.0.8

package/polytree.bundle.js

@@ -1,23 +1,25 @@
 // Generated by CoffeeScript 2.7.0
-var BACK, Box3, BufferAttribute, BufferGeometry, COPLANAR, CSG_Rules, DoubleSide, EPSILON, FRONT, Matrix3, Mesh, OctreeCSG, Plane, Polygon, RAY_EPSILON, Ray, Raycaster, SPANNING, Triangle, Vector2, Vector3, Vertex, _asyncUnionArrayID, _asyncUnionID, _box3$1, _matrix3, _normal1, _polygonID, _ray, _rayDirection, _raycaster1, _v1, _v2, _wP, _wP_EPS_ARR, _wP_EPS_ARR_COUNT, _wV1, _wV2, _wV3, calcWindingNumber_buffer, disposeOctree, edge1, edge2, h, handleIntersectingOctrees, handleObjectForOp, handleObjectForOp_async, isUniqueTriangle, isValidTriangle, nbuf2, nbuf3, pointRounding, polyInside_WindingNumber_buffer, prepareTriangleBuffer, q, rayIntersectsTriangle, raycastIntersectAscSort, returnXYZ, s, splitPolygonArr, splitPolygonByPlane, tmpm3, ttvv0, tv0, tv1, wNPI;
+var Box3, BufferAttribute, BufferGeometry, DoubleSide, Matrix3, Mesh, Ray, Raycaster, Triangle, Vector2, Vector3;
 
-({Vector2, Vector3, Box3, DoubleSide, Matrix3, Ray, Triangle, BufferGeometry, BufferAttribute, Mesh, Raycaster} = require("three"));
+({Vector2, Vector3, Mesh, Triangle, Box3, Matrix3, DoubleSide, Ray, Raycaster, BufferGeometry, BufferAttribute} = require("three"));
+// Generated by CoffeeScript 2.7.0
+var BACK, COPLANAR, CSG_Rules, EPSILON, FRONT, Plane, Polygon, Polytree, RAY_EPSILON, SPANNING, Vertex, _asyncUnionArrayID, _asyncUnionID, _matrix3, _normal1, _polygonID, _wP, _wP_EPS_ARR, _wP_EPS_ARR_COUNT, _wV1, _wV2, _wV3, calcWindingNumber_buffer, disposePolytree, edge1, edge2, h, handleIntersectingPolytrees, handleObjectForOp, handleObjectForOp_async, isUniqueTriangle, isValidTriangle, nbuf2, nbuf3, pointRounding, polyInside_WindingNumber_buffer, prepareTriangleBuffer, q, rayIntersectsTriangle, raycastIntersectAscSort, returnXYZ, s, splitPolygonArr, splitPolygonByPlane, tempBox3, tempRay, tempRayDirection, tempRaycaster, tempVector1, tempVector2, tmpm3, triangleVertex0, triangleVertex1, ttvv0, wNPI;
 
-_v1 = new Vector3();
+tempVector1 = new Vector3();
 
-_v2 = new Vector3();
+tempVector2 = new Vector3();
 
-_box3$1 = new Box3();
+tempBox3 = new Box3();
 
-tv0 = new Vector3();
+triangleVertex0 = new Vector3();
 
-tv1 = new Vector3();
+triangleVertex1 = new Vector3();
 
-_raycaster1 = new Raycaster();
+tempRaycaster = new Raycaster();
 
-_ray = new Ray();
+tempRay = new Ray();
 
-_rayDirection = new Vector3(0, 0, 1);
+tempRayDirection = new Vector3(0, 0, 1);
 
 EPSILON = 1e-5;
 
@@ -31,7 +33,7 @@ SPANNING = 3;
 
 _polygonID = 0;
 
-OctreeCSG = class OctreeCSG {
+Polytree = class Polytree {
   constructor(box, parent) {
     this.polygons = [];
     this.replacedPolygons = [];
@@ -42,7 +44,7 @@ OctreeCSG = class OctreeCSG {
     this.parent = parent;
     this.level = 0;
     this.polygonArrays = void 0;
-    // @isOctree = true
+    // @isPolytree = true
     this.addPolygonsArrayToRoot(this.polygons);
   }
 
@@ -133,33 +135,33 @@ OctreeCSG = class OctreeCSG {
     return this;
   }
 
-  newOctree(box, parent) {
+  newPolytree(box, parent) {
     return new this.constructor(box, parent);
   }
 
   split(level) {
-    var box, found, halfsize, i, i1, k, l, len, m, o, polygon, ref, ref1, subTrees, v, x, y, z;
+    var box, found, halfsize, i, k, l, len, m, n, o, polygon, ref, ref1, subTrees, vectorPosition, x, y, z;
     if (!this.box) {
       return;
     }
     subTrees = [];
-    halfsize = _v2.copy(this.box.max).sub(this.box.min).multiplyScalar(0.5);
+    halfsize = tempVector2.copy(this.box.max).sub(this.box.min).multiplyScalar(0.5);
     for (x = k = 0; k <= 1; x = ++k) {
       for (y = l = 0; l <= 1; y = ++l) {
         for (z = m = 0; m <= 1; z = ++m) {
           box = new Box3();
-          v = _v1.set(x, y, z);
-          box.min.copy(this.box.min).add(v.multiply(halfsize));
+          vectorPosition = tempVector1.set(x, y, z);
+          box.min.copy(this.box.min).add(vectorPosition.multiply(halfsize));
           box.max.copy(box.min).add(halfsize);
           box.expandByScalar(EPSILON);
-          subTrees.push(this.newOctree(box, this));
+          subTrees.push(this.newPolytree(box, this));
         }
       }
     }
     polygon = void 0;
     while (polygon = this.polygons.pop()) {
       found = false;
-      for (i = o = 0, ref = subTrees.length; (0 <= ref ? o < ref : o > ref); i = 0 <= ref ? ++o : --o) {
+      for (i = n = 0, ref = subTrees.length; (0 <= ref ? n < ref : n > ref); i = 0 <= ref ? ++n : --n) {
         if (subTrees[i].box.containsPoint(polygon.getMidpoint())) {
           subTrees[i].polygons.push(polygon);
           found = true;
@@ -170,15 +172,16 @@ OctreeCSG = class OctreeCSG {
         throw new Error(`Unable to find subtree for triangle at level ${level}`);
       }
     }
-    for (i = i1 = 0, ref1 = subTrees.length; (0 <= ref1 ? i1 < ref1 : i1 > ref1); i = 0 <= ref1 ? ++i1 : --i1) {
+    for (i = o = 0, ref1 = subTrees.length; (0 <= ref1 ? o < ref1 : o > ref1); i = 0 <= ref1 ? ++o : --o) {
       subTrees[i].level = level + 1;
       len = subTrees[i].polygons.length;
       // if (len !== 0) {
-      if (len > OctreeCSG.polygonsPerTree && level < OctreeCSG.maxLevel) {
+      if (len > Polytree.polygonsPerTree && level < Polytree.maxLevel) {
         subTrees[i].split(level + 1);
       }
       this.subTrees.push(subTrees[i]);
     }
+    // }
     return this;
   }
 
@@ -192,7 +195,7 @@ OctreeCSG = class OctreeCSG {
   processTree() {
     var i, k, l, ref, ref1, results1;
     if (!this.isEmpty()) {
-      _box3$1.copy(this.box);
+      tempBox3.copy(this.box);
       for (i = k = 0, ref = this.polygons.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
         this.box.expandByPoint(this.polygons[i].triangle.a);
         this.box.expandByPoint(this.polygons[i].triangle.b);
@@ -273,23 +276,23 @@ OctreeCSG = class OctreeCSG {
     polygons = this.getRayPolygons(ray);
     for (i = k = 0, ref = polygons.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
       result = void 0;
-      if (OctreeCSG.rayIntersectTriangleType === "regular") {
-        result = ray.intersectTriangle(polygons[i].triangle.a, polygons[i].triangle.b, polygons[i].triangle.c, false, _v1);
+      if (Polytree.rayIntersectTriangleType === "regular") {
+        result = ray.intersectTriangle(polygons[i].triangle.a, polygons[i].triangle.b, polygons[i].triangle.c, false, tempVector1);
         if (result) {
-          _v1.applyMatrix4(matrixWorld);
-          distance = _v1.distanceTo(ray.origin);
+          tempVector1.applyMatrix4(matrixWorld);
+          distance = tempVector1.distanceTo(ray.origin);
           if (distance < 0 || distance > 2e308) {
             console.warn("[rayIntersect] Failed ray distance check", ray);
           } else {
             intersects.push({
               distance: distance,
               polygon: polygons[i],
-              position: _v1.clone()
+              position: tempVector1.clone()
             });
           }
         }
       } else {
-        result = rayIntersectsTriangle(ray, polygons[i].triangle, _v1);
+        result = rayIntersectsTriangle(ray, polygons[i].triangle, tempVector1);
         if (result) {
           newdistance = result.clone().sub(ray.origin).length();
           if (distance > newdistance) {
@@ -570,11 +573,11 @@ OctreeCSG = class OctreeCSG {
     return true;
   }
 
-  markIntesectingPolygons(targetOctree) {
+  markIntesectingPolygons(targetPolytree) {
     return this.polygonArrays.forEach(function(polygonsArray) {
       if (polygonsArray.length) {
         return polygonsArray.forEach(function(polygon) {
-          return polygon.intersects = targetOctree.isPolygonIntersecting(polygon);
+          return polygon.intersects = targetPolytree.isPolygonIntersecting(polygon);
         });
       }
     });
@@ -582,9 +585,9 @@ OctreeCSG = class OctreeCSG {
 
   // if @polygons.length > 0
   //     @polygons.forEach (polygon) ->
-  //         polygon.intersects = targetOctree.isPolygonIntersecting(polygon)
+  //         polygon.intersects = targetPolytree.isPolygonIntersecting(polygon)
   // for i in [0...@subTrees.length]
-  //     @subTrees[i].markIntesectingPolygons(targetOctree)
+  //     @subTrees[i].markIntesectingPolygons(targetPolytree)
   resetPolygons(resetOriginal = true) {
     return this.polygonArrays.forEach(function(polygonsArray) {
       if (polygonsArray.length) {
@@ -600,8 +603,8 @@ OctreeCSG = class OctreeCSG {
   //         polygon.reset(resetOriginal)
   // for i in [0...@subTrees.length]
   //     @subTrees[i].resetPolygons(resetOriginal)
-  handleIntersectingPolygons(targetOctree, targetOctreeBuffer) {
-    var currentPolygon, i, i1, inside, intersects, j, k, l, m, o, point, polygon, polygonStack, ref, ref1, ref2, ref3, ref4, results1, splitResults, target, targetPolygons;
+  handleIntersectingPolygons(targetPolytree, targetPolytreeBuffer) {
+    var currentPolygon, i, inside, intersects, j, k, l, m, n, o, point, polygon, polygonStack, ref, ref1, ref2, ref3, ref4, results1, splitResults, target, targetPolygons;
     // if @polygons.length > 0
     //     polygonStack = @polygons.filter (polygon) -> (polygon.valid == true) and (polygon.intersects == true) and (polygon.state == "undecided")
     //     currentPolygon = polygonStack.pop()
@@ -610,7 +613,7 @@ OctreeCSG = class OctreeCSG {
     //             continue
     //         unless currentPolygon.valid
     //             continue
-    //         targetPolygons = targetOctree.getPolygonsIntersectingPolygon(currentPolygon)
+    //         targetPolygons = targetPolytree.getPolygonsIntersectingPolygon(currentPolygon)
     //         if targetPolygons.length > 0
     //             for j in [0...targetPolygons.length]
     //                 target = targetPolygons[j]
@@ -642,42 +645,42 @@ OctreeCSG = class OctreeCSG {
     //         unless currentPolygon.valid
     //             continue
     //         inside = false
-    //         if targetOctree.box.containsPoint(currentPolygon.getMidpoint())
-    //             if OctreeCSG.useWindingNumber is true
-    //                 inside = polyInside_WindingNumber_buffer(targetOctreeBuffer, currentPolygon.getMidpoint(), currentPolygon.coplanar)
+    //         if targetPolytree.box.containsPoint(currentPolygon.getMidpoint())
+    //             if Polytree.useWindingNumber is true
+    //                 inside = polyInside_WindingNumber_buffer(targetPolytreeBuffer, currentPolygon.getMidpoint(), currentPolygon.coplanar)
     //             else
-    //                 point = pointRounding(_v2.copy(currentPolygon.getMidpoint()))
-    //                 if OctreeCSG.useOctreeRay isnt true and targetOctree.mesh
-    //                     _rayDirection.copy(currentPolygon.plane.normal)
-    //                     _raycaster1.set(point, _rayDirection)
-    //                     intersects = _raycaster1.intersectObject(targetOctree.mesh)
+    //                 point = pointRounding(tempVector2.copy(currentPolygon.getMidpoint()))
+    //                 if Polytree.usePolytreeRay isnt true and targetPolytree.mesh
+    //                     tempRayDirection.copy(currentPolygon.plane.normal)
+    //                     tempRaycaster.set(point, tempRayDirection)
+    //                     intersects = tempRaycaster.intersectObject(targetPolytree.mesh)
     //                     if intersects.length
-    //                         if _rayDirection.dot(intersects[0].face.normal) > 0
+    //                         if tempRayDirection.dot(intersects[0].face.normal) > 0
     //                             inside = true
     //                     unless inside or not currentPolygon.coplanar
     //                         for j in [0..._wP_EPS_ARR_COUNT]
-    //                             _raycaster1.ray.origin.copy(point).add(_wP_EPS_ARR[j])
-    //                             intersects = _raycaster1.intersectObject(targetOctree.mesh)
+    //                             tempRaycaster.ray.origin.copy(point).add(_wP_EPS_ARR[j])
+    //                             intersects = tempRaycaster.intersectObject(targetPolytree.mesh)
     //                             if intersects.length
-    //                                 if _rayDirection.dot(intersects[0].face.normal) > 0
+    //                                 if tempRayDirection.dot(intersects[0].face.normal) > 0
     //                                     inside = true
     //                                     break
     //                 else
-    //                     _ray.origin.copy(point)
-    //                     _rayDirection.copy(currentPolygon.plane.normal)
-    //                     _ray.direction.copy(currentPolygon.plane.normal)
-    //                     intersects = targetOctree.rayIntersect(_ray, targetOctree.originalMatrixWorld)
+    //                     tempRay.origin.copy(point)
+    //                     tempRayDirection.copy(currentPolygon.plane.normal)
+    //                     tempRay.direction.copy(currentPolygon.plane.normal)
+    //                     intersects = targetPolytree.rayIntersect(tempRay, targetPolytree.originalMatrixWorld)
     //                     if intersects.length
-    //                         if _rayDirection.dot(intersects[0].polygon.plane.normal) > 0
+    //                         if tempRayDirection.dot(intersects[0].polygon.plane.normal) > 0
     //                             inside = true
     //                     unless inside or not currentPolygon.coplanar
     //                         for j in [0..._wP_EPS_ARR_COUNT]
-    //                             _ray.origin.copy(point).add(_wP_EPS_ARR[j])
-    //                             _rayDirection.copy(currentPolygon.plane.normal)
-    //                             _ray.direction.copy(currentPolygon.plane.normal)
-    //                             intersects = targetOctree.rayIntersect(_ray, targetOctree.originalMatrixWorld)
+    //                             tempRay.origin.copy(point).add(_wP_EPS_ARR[j])
+    //                             tempRayDirection.copy(currentPolygon.plane.normal)
+    //                             tempRay.direction.copy(currentPolygon.plane.normal)
+    //                             intersects = targetPolytree.rayIntersect(tempRay, targetPolytree.originalMatrixWorld)
     //                             if intersects.length
-    //                                 if _rayDirection.dot(intersects[0].polygon.plane.normal) > 0
+    //                                 if tempRayDirection.dot(intersects[0].polygon.plane.normal) > 0
     //                                     inside = true
     //                                     break
     //         if inside is true
@@ -686,7 +689,7 @@ OctreeCSG = class OctreeCSG {
     //             currentPolygon.setState("outside")
     //         currentPolygon = polygonStack.pop()
     // for i in [0...@subTrees.length]
-    //     @subTrees[i].handleIntersectingPolygons(targetOctree, targetOctreeBuffer)
+    //     @subTrees[i].handleIntersectingPolygons(targetPolytree, targetPolytreeBuffer)
     if (this.polygons.length > 0) {
       polygonStack = this.polygons.filter(function(polygon) {
         return (polygon.valid === true) && (polygon.intersects === true) && (polygon.state === "undecided");
@@ -699,7 +702,7 @@ OctreeCSG = class OctreeCSG {
         if (!currentPolygon.valid) {
           continue;
         }
-        targetPolygons = targetOctree.getPolygonsIntersectingPolygon(currentPolygon);
+        targetPolygons = targetPolytree.getPolygonsIntersectingPolygon(currentPolygon);
         if (targetPolygons.length > 0) {
           for (j = k = 0, ref = targetPolygons.length; (0 <= ref ? k < ref : k > ref); j = 0 <= ref ? ++k : --k) {
             target = targetPolygons[j];
@@ -743,26 +746,26 @@ OctreeCSG = class OctreeCSG {
           continue;
         }
         inside = false;
-        if (targetOctree.box.containsPoint(currentPolygon.getMidpoint())) {
-          if (OctreeCSG.useWindingNumber === true) {
-            inside = polyInside_WindingNumber_buffer(targetOctreeBuffer, currentPolygon.getMidpoint(), currentPolygon.coplanar);
+        if (targetPolytree.box.containsPoint(currentPolygon.getMidpoint())) {
+          if (Polytree.useWindingNumber === true) {
+            inside = polyInside_WindingNumber_buffer(targetPolytreeBuffer, currentPolygon.getMidpoint(), currentPolygon.coplanar);
           } else {
-            point = pointRounding(_v2.copy(currentPolygon.getMidpoint()));
-            if (OctreeCSG.useOctreeRay !== true && targetOctree.mesh) {
-              _rayDirection.copy(currentPolygon.plane.normal);
-              _raycaster1.set(point, _rayDirection);
-              intersects = _raycaster1.intersectObject(targetOctree.mesh);
+            point = pointRounding(tempVector2.copy(currentPolygon.getMidpoint()));
+            if (Polytree.usePolytreeRay !== true && targetPolytree.mesh) {
+              tempRayDirection.copy(currentPolygon.plane.normal);
+              tempRaycaster.set(point, tempRayDirection);
+              intersects = tempRaycaster.intersectObject(targetPolytree.mesh);
               if (intersects.length) {
-                if (_rayDirection.dot(intersects[0].face.normal) > 0) {
+                if (tempRayDirection.dot(intersects[0].face.normal) > 0) {
                   inside = true;
                 }
               }
               if (!(inside || !currentPolygon.coplanar)) {
                 for (j = m = 0, ref2 = _wP_EPS_ARR_COUNT; (0 <= ref2 ? m < ref2 : m > ref2); j = 0 <= ref2 ? ++m : --m) {
-                  _raycaster1.ray.origin.copy(point).add(_wP_EPS_ARR[j]);
-                  intersects = _raycaster1.intersectObject(targetOctree.mesh);
+                  tempRaycaster.ray.origin.copy(point).add(_wP_EPS_ARR[j]);
+                  intersects = tempRaycaster.intersectObject(targetPolytree.mesh);
                   if (intersects.length) {
-                    if (_rayDirection.dot(intersects[0].face.normal) > 0) {
+                    if (tempRayDirection.dot(intersects[0].face.normal) > 0) {
                       inside = true;
                       break;
                     }
@@ -770,23 +773,23 @@ OctreeCSG = class OctreeCSG {
                 }
               }
             } else {
-              _ray.origin.copy(point);
-              _rayDirection.copy(currentPolygon.plane.normal);
-              _ray.direction.copy(currentPolygon.plane.normal);
-              intersects = targetOctree.rayIntersect(_ray, targetOctree.originalMatrixWorld);
+              tempRay.origin.copy(point);
+              tempRayDirection.copy(currentPolygon.plane.normal);
+              tempRay.direction.copy(currentPolygon.plane.normal);
+              intersects = targetPolytree.rayIntersect(tempRay, targetPolytree.originalMatrixWorld);
               if (intersects.length) {
-                if (_rayDirection.dot(intersects[0].polygon.plane.normal) > 0) {
+                if (tempRayDirection.dot(intersects[0].polygon.plane.normal) > 0) {
                   inside = true;
                 }
               }
               if (!(inside || !currentPolygon.coplanar)) {
-                for (j = o = 0, ref3 = _wP_EPS_ARR_COUNT; (0 <= ref3 ? o < ref3 : o > ref3); j = 0 <= ref3 ? ++o : --o) {
-                  _ray.origin.copy(point).add(_wP_EPS_ARR[j]);
-                  _rayDirection.copy(currentPolygon.plane.normal);
-                  _ray.direction.copy(currentPolygon.plane.normal);
-                  intersects = targetOctree.rayIntersect(_ray, targetOctree.originalMatrixWorld);
+                for (j = n = 0, ref3 = _wP_EPS_ARR_COUNT; (0 <= ref3 ? n < ref3 : n > ref3); j = 0 <= ref3 ? ++n : --n) {
+                  tempRay.origin.copy(point).add(_wP_EPS_ARR[j]);
+                  tempRayDirection.copy(currentPolygon.plane.normal);
+                  tempRay.direction.copy(currentPolygon.plane.normal);
+                  intersects = targetPolytree.rayIntersect(tempRay, targetPolytree.originalMatrixWorld);
                   if (intersects.length) {
-                    if (_rayDirection.dot(intersects[0].polygon.plane.normal) > 0) {
+                    if (tempRayDirection.dot(intersects[0].polygon.plane.normal) > 0) {
                       inside = true;
                       break;
                     }
@@ -805,8 +808,8 @@ OctreeCSG = class OctreeCSG {
       }
     }
     results1 = [];
-    for (i = i1 = 0, ref4 = this.subTrees.length; (0 <= ref4 ? i1 < ref4 : i1 > ref4); i = 0 <= ref4 ? ++i1 : --i1) {
-      results1.push(this.subTrees[i].handleIntersectingPolygons(targetOctree, targetOctreeBuffer));
+    for (i = o = 0, ref4 = this.subTrees.length; (0 <= ref4 ? o < ref4 : o > ref4); i = 0 <= ref4 ? ++o : --o) {
+      results1.push(this.subTrees[i].handleIntersectingPolygons(targetPolytree, targetPolytreeBuffer));
     }
     return results1;
   }
@@ -939,7 +942,7 @@ OctreeCSG = class OctreeCSG {
 //     @polygons.forEach (p) -> p.shared = index
 // for i in [0...@subTrees.length]
 //     @subTrees[i].setPolygonIndex(index)
-OctreeCSG.prototype.isOctree = true;
+Polytree.prototype.isPolytree = true;
 
 raycastIntersectAscSort = function(a, b) {
   return a.distance - b.distance;
@@ -953,7 +956,7 @@ pointRounding = function(point, num = 15) {
 };
 
 splitPolygonByPlane = function(polygon, plane, result = []) {
-  var b, f, i, j, k, l, m, newPolys, npI, o, polygonType, ref, ref1, ref2, ref3, returnPolygon, t, ti, tj, type, types, v, vi, vj;
+  var backVertices, currentType, currentVertex, distanceToPlane, frontVertices, i, intersectionParameter, k, l, m, n, newPolygons, nextIndex, nextType, nextVertex, polygonIndex, polygonType, ref, ref1, ref2, ref3, returnPolygon, type, types, vertexParameter;
   returnPolygon = {
     polygon: polygon,
     type: "undecided"
@@ -961,8 +964,8 @@ splitPolygonByPlane = function(polygon, plane, result = []) {
   polygonType = 0;
   types = [];
   for (i = k = 0, ref = polygon.vertices.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
-    t = plane.normal.dot(polygon.vertices[i].pos) - plane.w;
-    type = t < -EPSILON ? BACK : t > EPSILON ? FRONT : COPLANAR;
+    distanceToPlane = plane.normal.dot(polygon.vertices[i].pos) - plane.w;
+    type = distanceToPlane < -EPSILON ? BACK : distanceToPlane > EPSILON ? FRONT : COPLANAR;
     polygonType |= type;
     types.push(type);
   }
@@ -980,55 +983,55 @@ splitPolygonByPlane = function(polygon, plane, result = []) {
       result.push(returnPolygon);
       break;
     case SPANNING:
-      f = [];
-      b = [];
+      frontVertices = [];
+      backVertices = [];
       for (i = l = 0, ref1 = polygon.vertices.length; (0 <= ref1 ? l < ref1 : l > ref1); i = 0 <= ref1 ? ++l : --l) {
-        j = (i + 1) % polygon.vertices.length;
-        ti = types[i];
-        tj = types[j];
-        vi = polygon.vertices[i];
-        vj = polygon.vertices[j];
-        if (ti !== BACK) {
-          f.push(vi);
+        nextIndex = (i + 1) % polygon.vertices.length;
+        currentType = types[i];
+        nextType = types[nextIndex];
+        currentVertex = polygon.vertices[i];
+        nextVertex = polygon.vertices[nextIndex];
+        if (currentType !== BACK) {
+          frontVertices.push(currentVertex);
         }
-        if (ti !== FRONT) {
-          b.push(ti !== BACK ? vi.clone() : vi);
+        if (currentType !== FRONT) {
+          backVertices.push(currentType !== BACK ? currentVertex.clone() : currentVertex);
         }
-        if ((ti | tj) === SPANNING) {
-          t = (plane.w - plane.normal.dot(vi.pos)) / plane.normal.dot(tv0.copy(vj.pos).sub(vi.pos));
-          v = vi.interpolate(vj, t);
-          f.push(v);
-          b.push(v.clone());
+        if ((currentType | nextType) === SPANNING) {
+          intersectionParameter = (plane.w - plane.normal.dot(currentVertex.pos)) / plane.normal.dot(triangleVertex0.copy(nextVertex.pos).sub(currentVertex.pos));
+          vertexParameter = currentVertex.interpolate(nextVertex, intersectionParameter);
+          frontVertices.push(vertexParameter);
+          backVertices.push(vertexParameter.clone());
         }
       }
-      if (f.length >= 3) {
-        if (f.length > 3) {
-          newPolys = splitPolygonArr(f);
-          for (npI = m = 0, ref2 = newPolys.length; (0 <= ref2 ? m < ref2 : m > ref2); npI = 0 <= ref2 ? ++m : --m) {
+      if (frontVertices.length >= 3) {
+        if (frontVertices.length > 3) {
+          newPolygons = splitPolygonArr(frontVertices);
+          for (polygonIndex = m = 0, ref2 = newPolygons.length; (0 <= ref2 ? m < ref2 : m > ref2); polygonIndex = 0 <= ref2 ? ++m : --m) {
             result.push({
-              polygon: new Polygon(newPolys[npI], polygon.shared),
+              polygon: new Polygon(newPolygons[polygonIndex], polygon.shared),
               type: "front"
             });
           }
         } else {
           result.push({
-            polygon: new Polygon(f, polygon.shared),
+            polygon: new Polygon(frontVertices, polygon.shared),
             type: "front"
           });
         }
       }
-      if (b.length >= 3) {
-        if (b.length > 3) {
-          newPolys = splitPolygonArr(b);
-          for (npI = o = 0, ref3 = newPolys.length; (0 <= ref3 ? o < ref3 : o > ref3); npI = 0 <= ref3 ? ++o : --o) {
+      if (backVertices.length >= 3) {
+        if (backVertices.length > 3) {
+          newPolygons = splitPolygonArr(backVertices);
+          for (polygonIndex = n = 0, ref3 = newPolygons.length; (0 <= ref3 ? n < ref3 : n > ref3); polygonIndex = 0 <= ref3 ? ++n : --n) {
             result.push({
-              polygon: new Polygon(newPolys[npI], polygon.shared),
+              polygon: new Polygon(newPolygons[polygonIndex], polygon.shared),
               type: "back"
             });
           }
         } else {
           result.push({
-            polygon: new Polygon(b, polygon.shared),
+            polygon: new Polygon(backVertices, polygon.shared),
             type: "back"
           });
         }
@@ -1183,7 +1186,7 @@ CSG_Rules = {
   }
 };
 
-// class OctreeCSG { };
+// class Polytree { };
 /*
 Union:
 - Combine all polygons from A and B, except:
@@ -1209,132 +1212,134 @@ Intersect:
     d. outside and coplanar-back
     e. outside
 */
-OctreeCSG.union = function(octreeA, octreeB, buildTargetOctree = true) {
-  var currentMeshSideA, currentMeshSideB, octree, trianglesSet;
-  octree = new OctreeCSG();
+Polytree.union = function(polytreeA, polytreeB, buildTargetPolytree = true) {
+  var currentMeshSideA, currentMeshSideB, polytree, trianglesSet;
+  polytree = new Polytree();
   trianglesSet = new Set();
-  if (octreeA.box.intersectsBox(octreeB.box)) {
+  if (polytreeA.box.intersectsBox(polytreeB.box)) {
     currentMeshSideA = void 0;
     currentMeshSideB = void 0;
-    if (octreeA.mesh) {
-      currentMeshSideA = octreeA.mesh.material.side;
-      octreeA.mesh.material.side = DoubleSide;
-    }
-    if (octreeB.mesh) {
-      currentMeshSideB = octreeB.mesh.material.side;
-      octreeB.mesh.material.side = DoubleSide;
-    }
-    octreeA.resetPolygons(false);
-    octreeB.resetPolygons(false);
-    octreeA.markIntesectingPolygons(octreeB);
-    octreeB.markIntesectingPolygons(octreeA);
-    handleIntersectingOctrees(octreeA, octreeB);
-    octreeA.deleteReplacedPolygons();
-    octreeB.deleteReplacedPolygons();
-    octreeA.deletePolygonsByStateRules(CSG_Rules.union.a);
-    octreeB.deletePolygonsByStateRules(CSG_Rules.union.b);
-    octreeA.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
-    octreeB.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
-    if (octreeA.mesh && octreeA.mesh.material.side !== currentMeshSideA) {
-      octreeA.mesh.material.side = currentMeshSideA;
-    }
-    if (octreeB.mesh && octreeB.mesh.material.side !== currentMeshSideB) {
-      octreeB.mesh.material.side = currentMeshSideB;
+    if (polytreeA.mesh) {
+      currentMeshSideA = polytreeA.mesh.material.side;
+      polytreeA.mesh.material.side = DoubleSide;
+    }
+    if (polytreeB.mesh) {
+      currentMeshSideB = polytreeB.mesh.material.side;
+      polytreeB.mesh.material.side = DoubleSide;
+    }
+    polytreeA.resetPolygons(false);
+    polytreeB.resetPolygons(false);
+    polytreeA.markIntesectingPolygons(polytreeB);
+    polytreeB.markIntesectingPolygons(polytreeA);
+    handleIntersectingPolytrees(polytreeA, polytreeB);
+    polytreeA.deleteReplacedPolygons();
+    polytreeB.deleteReplacedPolygons();
+    polytreeA.deletePolygonsByStateRules(CSG_Rules.union.a);
+    polytreeB.deletePolygonsByStateRules(CSG_Rules.union.b);
+    polytreeA.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    polytreeB.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    if (polytreeA.mesh && polytreeA.mesh.material.side !== currentMeshSideA) {
+      polytreeA.mesh.material.side = currentMeshSideA;
+    }
+    if (polytreeB.mesh && polytreeB.mesh.material.side !== currentMeshSideB) {
+      polytreeB.mesh.material.side = currentMeshSideB;
     }
   } else {
-    octreeA.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
-    octreeB.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
+    polytreeA.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    polytreeB.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
   }
   trianglesSet.clear();
   trianglesSet = void 0;
-  octree.markPolygonsAsOriginal();
-  buildTargetOctree && octree.buildTree();
-  return octree;
+  polytree.markPolygonsAsOriginal();
+  buildTargetPolytree && polytree.buildTree();
+  return polytree;
 };
 
-OctreeCSG.subtract = function(octreeA, octreeB, buildTargetOctree = true) {
-  var currentMeshSideA, currentMeshSideB, octree, trianglesSet;
-  octree = new OctreeCSG();
+Polytree.subtract = function(polytreeA, polytreeB, buildTargetPolytree = true) {
+  var currentMeshSideA, currentMeshSideB, polytree, trianglesSet;
+  polytree = new Polytree();
   trianglesSet = new Set();
-  if (octreeA.box.intersectsBox(octreeB.box)) {
+  if (polytreeA.box.intersectsBox(polytreeB.box)) {
     currentMeshSideA = void 0;
     currentMeshSideB = void 0;
-    if (octreeA.mesh) {
-      currentMeshSideA = octreeA.mesh.material.side;
-      octreeA.mesh.material.side = DoubleSide;
-    }
-    if (octreeB.mesh) {
-      currentMeshSideB = octreeB.mesh.material.side;
-      octreeB.mesh.material.side = DoubleSide;
-    }
-    octreeA.resetPolygons(false);
-    octreeB.resetPolygons(false);
-    octreeA.markIntesectingPolygons(octreeB);
-    octreeB.markIntesectingPolygons(octreeA);
-    handleIntersectingOctrees(octreeA, octreeB);
-    octreeA.deleteReplacedPolygons();
-    octreeB.deleteReplacedPolygons();
-    octreeA.deletePolygonsByStateRules(CSG_Rules.subtract.a);
-    octreeB.deletePolygonsByStateRules(CSG_Rules.subtract.b);
-    octreeB.deletePolygonsByIntersection(false);
-    octreeB.invert();
-    octreeA.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
-    octreeB.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
-    if (octreeA.mesh && octreeA.mesh.material.side !== currentMeshSideA) {
-      octreeA.mesh.material.side = currentMeshSideA;
-    }
-    if (octreeB.mesh && octreeB.mesh.material.side !== currentMeshSideB) {
-      octreeB.mesh.material.side = currentMeshSideB;
+    if (polytreeA.mesh) {
+      currentMeshSideA = polytreeA.mesh.material.side;
+      polytreeA.mesh.material.side = DoubleSide;
+    }
+    if (polytreeB.mesh) {
+      currentMeshSideB = polytreeB.mesh.material.side;
+      polytreeB.mesh.material.side = DoubleSide;
+    }
+    polytreeA.resetPolygons(false);
+    polytreeB.resetPolygons(false);
+    polytreeA.markIntesectingPolygons(polytreeB);
+    polytreeB.markIntesectingPolygons(polytreeA);
+    handleIntersectingPolytrees(polytreeA, polytreeB);
+    polytreeA.deleteReplacedPolygons();
+    polytreeB.deleteReplacedPolygons();
+    polytreeA.deletePolygonsByStateRules(CSG_Rules.subtract.a);
+    polytreeB.deletePolygonsByStateRules(CSG_Rules.subtract.b);
+    polytreeB.deletePolygonsByIntersection(false);
+    polytreeB.invert();
+    polytreeA.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    polytreeB.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    if (polytreeA.mesh && polytreeA.mesh.material.side !== currentMeshSideA) {
+      polytreeA.mesh.material.side = currentMeshSideA;
+    }
+    if (polytreeB.mesh && polytreeB.mesh.material.side !== currentMeshSideB) {
+      polytreeB.mesh.material.side = currentMeshSideB;
     }
   } else {
-    octreeA.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
+    polytreeA.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
   }
   trianglesSet.clear();
   trianglesSet = void 0;
-  octree.markPolygonsAsOriginal();
-  buildTargetOctree && octree.buildTree();
-  // octree.invert()
-  return octree;
+  polytree.markPolygonsAsOriginal();
+  buildTargetPolytree && polytree.buildTree();
+  // polytree.invert()
+  return polytree;
 };
 
-OctreeCSG.intersect = function(octreeA, octreeB, buildTargetOctree = true) {
-  var currentMeshSideA, currentMeshSideB, octree, trianglesSet;
-  octree = new OctreeCSG();
+Polytree.intersect = function(polytreeA, polytreeB, buildTargetPolytree = true) {
+  var currentMeshSideA, currentMeshSideB, polytree, trianglesSet;
+  polytree = new Polytree();
   trianglesSet = new Set();
-  if (octreeA.box.intersectsBox(octreeB.box)) {
+  if (polytreeA.box.intersectsBox(polytreeB.box)) {
     currentMeshSideA = void 0;
     currentMeshSideB = void 0;
-    if (octreeA.mesh) {
-      currentMeshSideA = octreeA.mesh.material.side;
-      octreeA.mesh.material.side = DoubleSide;
-    }
-    if (octreeB.mesh) {
-      currentMeshSideB = octreeB.mesh.material.side;
-      octreeB.mesh.material.side = DoubleSide;
-    }
-    octreeA.resetPolygons(false);
-    octreeB.resetPolygons(false);
-    octreeA.markIntesectingPolygons(octreeB);
-    octreeB.markIntesectingPolygons(octreeA);
-    handleIntersectingOctrees(octreeA, octreeB);
-    octreeA.deleteReplacedPolygons();
-    octreeB.deleteReplacedPolygons();
-    octreeA.deletePolygonsByStateRules(CSG_Rules.intersect.a);
-    octreeB.deletePolygonsByStateRules(CSG_Rules.intersect.b);
-    octreeA.deletePolygonsByIntersection(false);
-    octreeB.deletePolygonsByIntersection(false);
-    octreeA.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
-    octreeB.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
-    if (octreeA.mesh && octreeA.mesh.material.side !== currentMeshSideA) {
-      octreeA.mesh.material.side = currentMeshSideA;
-    }
-    if (octreeB.mesh && octreeB.mesh.material.side !== currentMeshSideB) {
-      octreeB.mesh.material.side = currentMeshSideB;
+    if (polytreeA.mesh) {
+      currentMeshSideA = polytreeA.mesh.material.side;
+      polytreeA.mesh.material.side = DoubleSide;
+    }
+    if (polytreeB.mesh) {
+      currentMeshSideB = polytreeB.mesh.material.side;
+      polytreeB.mesh.material.side = DoubleSide;
+    }
+    polytreeA.resetPolygons(false);
+    polytreeB.resetPolygons(false);
+    polytreeA.markIntesectingPolygons(polytreeB);
+    polytreeB.markIntesectingPolygons(polytreeA);
+    handleIntersectingPolytrees(polytreeA, polytreeB);
+    polytreeA.deleteReplacedPolygons();
+    polytreeB.deleteReplacedPolygons();
+    polytreeA.deletePolygonsByStateRules(CSG_Rules.intersect.a);
+    polytreeB.deletePolygonsByStateRules(CSG_Rules.intersect.b);
+    polytreeA.deletePolygonsByIntersection(false);
+    polytreeB.deletePolygonsByIntersection(false);
+    polytreeA.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    polytreeB.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    if (polytreeA.mesh && polytreeA.mesh.material.side !== currentMeshSideA) {
+      polytreeA.mesh.material.side = currentMeshSideA;
+    }
+    if (polytreeB.mesh && polytreeB.mesh.material.side !== currentMeshSideB) {
+      polytreeB.mesh.material.side = currentMeshSideB;
     }
   }
   trianglesSet.clear();
   trianglesSet = void 0;
-  return octree.markPolygons;
+  polytree.markPolygonsAsOriginal();
+  buildTargetPolytree && polytree.buildTree();
+  return polytree;
 };
 
 CSG_Rules = {
@@ -1457,7 +1462,7 @@ CSG_Rules = {
   }
 };
 
-// class OctreeCSG { };
+// class Polytree { };
 /*
 Union:
 - Combine all polygons from A and B, except:
@@ -1483,205 +1488,205 @@ Intersect:
     d. outside and coplanar-back
     e. outside
 */
-OctreeCSG.union = function(octreeA, octreeB, buildTargetOctree = true) {
-  var currentMeshSideA, currentMeshSideB, octree, trianglesSet;
-  octree = new OctreeCSG();
+Polytree.union = function(polytreeA, polytreeB, buildTargetPolytree = true) {
+  var currentMeshSideA, currentMeshSideB, polytree, trianglesSet;
+  polytree = new Polytree();
   trianglesSet = new Set();
-  if (octreeA.box.intersectsBox(octreeB.box)) {
+  if (polytreeA.box.intersectsBox(polytreeB.box)) {
     currentMeshSideA = void 0;
     currentMeshSideB = void 0;
-    if (octreeA.mesh) {
-      currentMeshSideA = octreeA.mesh.material.side;
-      octreeA.mesh.material.side = DoubleSide;
-    }
-    if (octreeB.mesh) {
-      currentMeshSideB = octreeB.mesh.material.side;
-      octreeB.mesh.material.side = DoubleSide;
-    }
-    octreeA.resetPolygons(false);
-    octreeB.resetPolygons(false);
-    octreeA.markIntesectingPolygons(octreeB);
-    octreeB.markIntesectingPolygons(octreeA);
-    handleIntersectingOctrees(octreeA, octreeB);
-    octreeA.deleteReplacedPolygons();
-    octreeB.deleteReplacedPolygons();
-    octreeA.deletePolygonsByStateRules(CSG_Rules.union.a);
-    octreeB.deletePolygonsByStateRules(CSG_Rules.union.b);
-    octreeA.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
-    octreeB.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
-    if (octreeA.mesh && octreeA.mesh.material.side !== currentMeshSideA) {
-      octreeA.mesh.material.side = currentMeshSideA;
-    }
-    if (octreeB.mesh && octreeB.mesh.material.side !== currentMeshSideB) {
-      octreeB.mesh.material.side = currentMeshSideB;
+    if (polytreeA.mesh) {
+      currentMeshSideA = polytreeA.mesh.material.side;
+      polytreeA.mesh.material.side = DoubleSide;
+    }
+    if (polytreeB.mesh) {
+      currentMeshSideB = polytreeB.mesh.material.side;
+      polytreeB.mesh.material.side = DoubleSide;
+    }
+    polytreeA.resetPolygons(false);
+    polytreeB.resetPolygons(false);
+    polytreeA.markIntesectingPolygons(polytreeB);
+    polytreeB.markIntesectingPolygons(polytreeA);
+    handleIntersectingPolytrees(polytreeA, polytreeB);
+    polytreeA.deleteReplacedPolygons();
+    polytreeB.deleteReplacedPolygons();
+    polytreeA.deletePolygonsByStateRules(CSG_Rules.union.a);
+    polytreeB.deletePolygonsByStateRules(CSG_Rules.union.b);
+    polytreeA.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    polytreeB.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    if (polytreeA.mesh && polytreeA.mesh.material.side !== currentMeshSideA) {
+      polytreeA.mesh.material.side = currentMeshSideA;
+    }
+    if (polytreeB.mesh && polytreeB.mesh.material.side !== currentMeshSideB) {
+      polytreeB.mesh.material.side = currentMeshSideB;
     }
   } else {
-    octreeA.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
-    octreeB.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
+    polytreeA.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    polytreeB.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
   }
   trianglesSet.clear();
   trianglesSet = void 0;
-  octree.markPolygonsAsOriginal();
-  buildTargetOctree && octree.buildTree();
-  return octree;
+  polytree.markPolygonsAsOriginal();
+  buildTargetPolytree && polytree.buildTree();
+  return polytree;
 };
 
-OctreeCSG.subtract = function(octreeA, octreeB, buildTargetOctree = true) {
-  var currentMeshSideA, currentMeshSideB, octree, trianglesSet;
-  octree = new OctreeCSG();
+Polytree.subtract = function(polytreeA, polytreeB, buildTargetPolytree = true) {
+  var currentMeshSideA, currentMeshSideB, polytree, trianglesSet;
+  polytree = new Polytree();
   trianglesSet = new Set();
-  if (octreeA.box.intersectsBox(octreeB.box)) {
+  if (polytreeA.box.intersectsBox(polytreeB.box)) {
     currentMeshSideA = void 0;
     currentMeshSideB = void 0;
-    if (octreeA.mesh) {
-      currentMeshSideA = octreeA.mesh.material.side;
-      octreeA.mesh.material.side = DoubleSide;
-    }
-    if (octreeB.mesh) {
-      currentMeshSideB = octreeB.mesh.material.side;
-      octreeB.mesh.material.side = DoubleSide;
-    }
-    octreeA.resetPolygons(false);
-    octreeB.resetPolygons(false);
-    octreeA.markIntesectingPolygons(octreeB);
-    octreeB.markIntesectingPolygons(octreeA);
-    handleIntersectingOctrees(octreeA, octreeB);
-    octreeA.deleteReplacedPolygons();
-    octreeB.deleteReplacedPolygons();
-    octreeA.deletePolygonsByStateRules(CSG_Rules.subtract.a);
-    octreeB.deletePolygonsByStateRules(CSG_Rules.subtract.b);
-    octreeB.deletePolygonsByIntersection(false);
-    octreeB.invert();
-    octreeA.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
-    octreeB.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
-    if (octreeA.mesh && octreeA.mesh.material.side !== currentMeshSideA) {
-      octreeA.mesh.material.side = currentMeshSideA;
-    }
-    if (octreeB.mesh && octreeB.mesh.material.side !== currentMeshSideB) {
-      octreeB.mesh.material.side = currentMeshSideB;
+    if (polytreeA.mesh) {
+      currentMeshSideA = polytreeA.mesh.material.side;
+      polytreeA.mesh.material.side = DoubleSide;
+    }
+    if (polytreeB.mesh) {
+      currentMeshSideB = polytreeB.mesh.material.side;
+      polytreeB.mesh.material.side = DoubleSide;
+    }
+    polytreeA.resetPolygons(false);
+    polytreeB.resetPolygons(false);
+    polytreeA.markIntesectingPolygons(polytreeB);
+    polytreeB.markIntesectingPolygons(polytreeA);
+    handleIntersectingPolytrees(polytreeA, polytreeB);
+    polytreeA.deleteReplacedPolygons();
+    polytreeB.deleteReplacedPolygons();
+    polytreeA.deletePolygonsByStateRules(CSG_Rules.subtract.a);
+    polytreeB.deletePolygonsByStateRules(CSG_Rules.subtract.b);
+    polytreeB.deletePolygonsByIntersection(false);
+    polytreeB.invert();
+    polytreeA.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    polytreeB.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    if (polytreeA.mesh && polytreeA.mesh.material.side !== currentMeshSideA) {
+      polytreeA.mesh.material.side = currentMeshSideA;
+    }
+    if (polytreeB.mesh && polytreeB.mesh.material.side !== currentMeshSideB) {
+      polytreeB.mesh.material.side = currentMeshSideB;
     }
   } else {
-    octreeA.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
+    polytreeA.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
   }
   trianglesSet.clear();
   trianglesSet = void 0;
-  octree.markPolygonsAsOriginal();
-  buildTargetOctree && octree.buildTree();
-  // octree.invert()
-  return octree;
+  polytree.markPolygonsAsOriginal();
+  buildTargetPolytree && polytree.buildTree();
+  // polytree.invert()
+  return polytree;
 };
 
 /*
 Intersect:
 1. Delete all polygons in A that are:
-    a. inside and coplanar-back
-    b. outside and coplanar-front
-    c. outside and coplanar-back
-    d. outside
+        a. inside and coplanar-back
+        b. outside and coplanar-front
+        c. outside and coplanar-back
+        d. outside
 2. Delete all polygons in B that are:
-    a. inside and coplanar-front
-    b. inside and coplanar-back
-    c. outside and coplanar-front
-    d. outside and coplanar-back
-    e. outside
+        a. inside and coplanar-front
+        b. inside and coplanar-back
+        c. outside and coplanar-front
+        d. outside and coplanar-back
+        e. outside
 */
-OctreeCSG.intersect = function(octreeA, octreeB, buildTargetOctree = true) {
-  var currentMeshSideA, currentMeshSideB, octree, trianglesSet;
-  octree = new OctreeCSG();
+Polytree.intersect = function(polytreeA, polytreeB, buildTargetPolytree = true) {
+  var currentMeshSideA, currentMeshSideB, polytree, trianglesSet;
+  polytree = new Polytree();
   trianglesSet = new Set();
-  if (octreeA.box.intersectsBox(octreeB.box)) {
+  if (polytreeA.box.intersectsBox(polytreeB.box)) {
     currentMeshSideA = void 0;
     currentMeshSideB = void 0;
-    if (octreeA.mesh) {
-      currentMeshSideA = octreeA.mesh.material.side;
-      octreeA.mesh.material.side = DoubleSide;
-    }
-    if (octreeB.mesh) {
-      currentMeshSideB = octreeB.mesh.material.side;
-      octreeB.mesh.material.side = DoubleSide;
-    }
-    octreeA.resetPolygons(false);
-    octreeB.resetPolygons(false);
-    octreeA.markIntesectingPolygons(octreeB);
-    octreeB.markIntesectingPolygons(octreeA);
-    handleIntersectingOctrees(octreeA, octreeB);
-    octreeA.deleteReplacedPolygons();
-    octreeB.deleteReplacedPolygons();
-    octreeA.deletePolygonsByStateRules(CSG_Rules.intersect.a);
-    octreeB.deletePolygonsByStateRules(CSG_Rules.intersect.b);
-    octreeA.deletePolygonsByIntersection(false);
-    octreeB.deletePolygonsByIntersection(false);
-    octreeA.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
-    octreeB.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
-    if (octreeA.mesh) {
-      if (octreeA.mesh.material.side !== currentMeshSideA) {
-        octreeA.mesh.material.side = currentMeshSideA;
-      }
-    }
-    if (octreeB.mesh) {
-      if (octreeB.mesh.material.side !== currentMeshSideB) {
-        octreeB.mesh.material.side = currentMeshSideB;
+    if (polytreeA.mesh) {
+      currentMeshSideA = polytreeA.mesh.material.side;
+      polytreeA.mesh.material.side = DoubleSide;
+    }
+    if (polytreeB.mesh) {
+      currentMeshSideB = polytreeB.mesh.material.side;
+      polytreeB.mesh.material.side = DoubleSide;
+    }
+    polytreeA.resetPolygons(false);
+    polytreeB.resetPolygons(false);
+    polytreeA.markIntesectingPolygons(polytreeB);
+    polytreeB.markIntesectingPolygons(polytreeA);
+    handleIntersectingPolytrees(polytreeA, polytreeB);
+    polytreeA.deleteReplacedPolygons();
+    polytreeB.deleteReplacedPolygons();
+    polytreeA.deletePolygonsByStateRules(CSG_Rules.intersect.a);
+    polytreeB.deletePolygonsByStateRules(CSG_Rules.intersect.b);
+    polytreeA.deletePolygonsByIntersection(false);
+    polytreeB.deletePolygonsByIntersection(false);
+    polytreeA.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    polytreeB.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    if (polytreeA.mesh) {
+      if (polytreeA.mesh.material.side !== currentMeshSideA) {
+        polytreeA.mesh.material.side = currentMeshSideA;
+      }
+    }
+    if (polytreeB.mesh) {
+      if (polytreeB.mesh.material.side !== currentMeshSideB) {
+        polytreeB.mesh.material.side = currentMeshSideB;
       }
     }
   }
   trianglesSet.clear();
   trianglesSet = void 0;
-  octree.markPolygonsAsOriginal();
-  buildTargetOctree && octree.buildTree();
-  return octree;
+  polytree.markPolygonsAsOriginal();
+  buildTargetPolytree && polytree.buildTree();
+  return polytree;
 };
 
-OctreeCSG.meshUnion = function(mesh1, mesh2, targetMaterial) {
-  var octreeA, octreeB, resultMesh, resultOctree;
-  octreeA = void 0;
-  octreeB = void 0;
+Polytree.meshUnion = function(mesh1, mesh2, targetMaterial) {
+  var polytreeA, polytreeB, resultMesh, resultPolytree;
+  polytreeA = void 0;
+  polytreeB = void 0;
   if (targetMaterial && Array.isArray(targetMaterial)) {
-    octreeA = OctreeCSG.fromMesh(mesh1, 0);
-    octreeB = OctreeCSG.fromMesh(mesh2, 1);
+    polytreeA = Polytree.fromMesh(mesh1, 0);
+    polytreeB = Polytree.fromMesh(mesh2, 1);
   } else {
-    octreeA = OctreeCSG.fromMesh(mesh1);
-    octreeB = OctreeCSG.fromMesh(mesh2);
+    polytreeA = Polytree.fromMesh(mesh1);
+    polytreeB = Polytree.fromMesh(mesh2);
     targetMaterial = targetMaterial !== void 0 ? targetMaterial : (Array.isArray(mesh1.material) ? mesh1.material[0] : mesh1.material).clone();
   }
-  resultOctree = OctreeCSG.union(octreeA, octreeB, false);
-  resultMesh = OctreeCSG.toMesh(resultOctree, targetMaterial);
-  disposeOctree(octreeA, octreeB, resultOctree);
+  resultPolytree = Polytree.union(polytreeA, polytreeB, false);
+  resultMesh = Polytree.toMesh(resultPolytree, targetMaterial);
+  disposePolytree(polytreeA, polytreeB, resultPolytree);
   return resultMesh;
 };
 
-OctreeCSG.meshSubtract = function(mesh1, mesh2, targetMaterial) {
-  var octreeA, octreeB, resultMesh, resultOctree;
-  octreeA = void 0;
-  octreeB = void 0;
+Polytree.meshSubtract = function(mesh1, mesh2, targetMaterial) {
+  var polytreeA, polytreeB, resultMesh, resultPolytree;
+  polytreeA = void 0;
+  polytreeB = void 0;
   if (targetMaterial && Array.isArray(targetMaterial)) {
-    octreeA = OctreeCSG.fromMesh(mesh1, 0);
-    octreeB = OctreeCSG.fromMesh(mesh2, 1);
+    polytreeA = Polytree.fromMesh(mesh1, 0);
+    polytreeB = Polytree.fromMesh(mesh2, 1);
   } else {
-    octreeA = OctreeCSG.fromMesh(mesh1);
-    octreeB = OctreeCSG.fromMesh(mesh2);
+    polytreeA = Polytree.fromMesh(mesh1);
+    polytreeB = Polytree.fromMesh(mesh2);
     targetMaterial = targetMaterial !== void 0 ? targetMaterial : (Array.isArray(mesh1.material) ? mesh1.material[0] : mesh1.material).clone();
   }
-  resultOctree = OctreeCSG.subtract(octreeA, octreeB, false);
-  resultMesh = OctreeCSG.toMesh(resultOctree, targetMaterial);
-  disposeOctree(octreeA, octreeB, resultOctree);
+  resultPolytree = Polytree.subtract(polytreeA, polytreeB, false);
+  resultMesh = Polytree.toMesh(resultPolytree, targetMaterial);
+  disposePolytree(polytreeA, polytreeB, resultPolytree);
   return resultMesh;
 };
 
-OctreeCSG.meshIntersect = function(mesh1, mesh2, targetMaterial) {
-  var octreeA, octreeB, resultMesh, resultOctree;
-  octreeA = void 0;
-  octreeB = void 0;
+Polytree.meshIntersect = function(mesh1, mesh2, targetMaterial) {
+  var polytreeA, polytreeB, resultMesh, resultPolytree;
+  polytreeA = void 0;
+  polytreeB = void 0;
   if (targetMaterial && Array.isArray(targetMaterial)) {
-    octreeA = OctreeCSG.fromMesh(mesh1, 0);
-    octreeB = OctreeCSG.fromMesh(mesh2, 1);
+    polytreeA = Polytree.fromMesh(mesh1, 0);
+    polytreeB = Polytree.fromMesh(mesh2, 1);
   } else {
-    octreeA = OctreeCSG.fromMesh(mesh1);
-    octreeB = OctreeCSG.fromMesh(mesh2);
+    polytreeA = Polytree.fromMesh(mesh1);
+    polytreeB = Polytree.fromMesh(mesh2);
     targetMaterial = targetMaterial !== void 0 ? targetMaterial : (Array.isArray(mesh1.material) ? mesh1.material[0] : mesh1.material).clone();
   }
-  resultOctree = OctreeCSG.intersect(octreeA, octreeB, false);
-  resultMesh = OctreeCSG.toMesh(resultOctree, targetMaterial);
-  disposeOctree(octreeA, octreeB, resultOctree);
+  resultPolytree = Polytree.intersect(polytreeA, polytreeB, false);
+  resultMesh = Polytree.toMesh(resultPolytree, targetMaterial);
+  disposePolytree(polytreeA, polytreeB, resultPolytree);
   return resultMesh;
 };
 
@@ -1689,45 +1694,45 @@ _asyncUnionID = 0;
 
 _asyncUnionArrayID = 0;
 
-OctreeCSG.disposeOctree = true;
+Polytree.disposePolytree = true;
 
-OctreeCSG.async = {
+Polytree.async = {
   batchSize: 100,
-  union: function(octreeA, octreeB, buildTargetOctree = true) {
+  union: function(polytreeA, polytreeB, buildTargetPolytree = true) {
     return new Promise(function(resolve, reject) {
       var e, result;
       try {
         // const id = _asyncUnionID++
         // console.log("Promise Union ##{id} started")
-        result = OctreeCSG.union(octreeA, octreeB, buildTargetOctree);
+        result = Polytree.union(polytreeA, polytreeB, buildTargetPolytree);
         resolve(result);
-        return disposeOctree(octreeA, octreeB);
+        return disposePolytree(polytreeA, polytreeB);
       } catch (error) {
         e = error;
         return reject(e);
       }
     });
   },
-  subtract: function(octreeA, octreeB, buildTargetOctree = true) {
+  subtract: function(polytreeA, polytreeB, buildTargetPolytree = true) {
     return new Promise(function(resolve, reject) {
       var e, result;
       try {
-        result = OctreeCSG.subtract(octreeA, octreeB, buildTargetOctree);
+        result = Polytree.subtract(polytreeA, polytreeB, buildTargetPolytree);
         resolve(result);
-        return disposeOctree(octreeA, octreeB);
+        return disposePolytree(polytreeA, polytreeB);
       } catch (error) {
         e = error;
         return reject(e);
       }
     });
   },
-  intersect: function(octreeA, octreeB, buildTargetOctree = true) {
+  intersect: function(polytreeA, polytreeB, buildTargetPolytree = true) {
     return new Promise(function(resolve, reject) {
       var e, result;
       try {
-        result = OctreeCSG.intersect(octreeA, octreeB, buildTargetOctree);
+        result = Polytree.intersect(polytreeA, polytreeB, buildTargetPolytree);
         resolve(result);
-        return disposeOctree(octreeA, octreeB);
+        return disposePolytree(polytreeA, polytreeB);
       } catch (error) {
         e = error;
         return reject(e);
@@ -1736,89 +1741,89 @@ OctreeCSG.async = {
   },
   unionArray: function(objArr, materialIndexMax = 2e308) {
     return new Promise(function(resolve, reject) {
-      var batch, batches, currentIndex, e, hasLeftOver, i, k, l, leftOverOctree, mainOctree, mainOctreeUsed, materialIndex, octreesArray, promise, promises, ref, ref1, result, tempOctree, usingBatches;
+      var batch, batches, currentIndex, e, hasLeftOver, i, k, l, leftOverPolytree, mainPolytree, mainPolytreeUsed, materialIndex, polytreesArray, promise, promises, ref, ref1, result, tempPolytree, usingBatches;
       try {
-        usingBatches = OctreeCSG.async.batchSize > 4 && OctreeCSG.async.batchSize < objArr.length;
+        usingBatches = Polytree.async.batchSize > 4 && Polytree.async.batchSize < objArr.length;
         // const id = _asyncUnionArrayID++
         // console.log("Promise Union Array ##{id}", usingBatches)
-        mainOctree = void 0;
-        mainOctreeUsed = false;
+        mainPolytree = void 0;
+        mainPolytreeUsed = false;
         promises = [];
         if (usingBatches) {
           batches = [];
           currentIndex = 0;
           while (currentIndex < objArr.length) {
-            batches.push(objArr.slice(currentIndex, currentIndex + OctreeCSG.async.batchSize));
-            currentIndex += OctreeCSG.async.batchSize;
+            batches.push(objArr.slice(currentIndex, currentIndex + Polytree.async.batchSize));
+            currentIndex += Polytree.async.batchSize;
           }
           batch = batches.shift();
           while (batch) {
-            promise = OctreeCSG.async.unionArray(batch, 0);
+            promise = Polytree.async.unionArray(batch, 0);
             promises.push(promise);
             batch = batches.shift();
           }
           usingBatches = true;
-          mainOctreeUsed = true;
+          mainPolytreeUsed = true;
           objArr.length = 0;
         } else {
-          octreesArray = [];
+          polytreesArray = [];
           for (i = k = 0, ref = objArr.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
             materialIndex = i > materialIndexMax ? materialIndexMax : i;
-            tempOctree = void 0;
+            tempPolytree = void 0;
             if (objArr[i].isMesh) {
-              tempOctree = OctreeCSG.fromMesh(objArr[i], materialIndexMax > -1 ? materialIndex : void 0);
+              tempPolytree = Polytree.fromMesh(objArr[i], materialIndexMax > -1 ? materialIndex : void 0);
             } else {
-              tempOctree = objArr[i];
+              tempPolytree = objArr[i];
               if (materialIndexMax > -1) {
-                tempOctree.setPolygonIndex(materialIndex);
+                tempPolytree.setPolygonIndex(materialIndex);
               }
             }
-            tempOctree.octreeIndex = i;
-            octreesArray.push(tempOctree);
+            tempPolytree.polytreeIndex = i;
+            polytreesArray.push(tempPolytree);
           }
-          mainOctree = octreesArray.shift();
+          mainPolytree = polytreesArray.shift();
           result = void 0;
           hasLeftOver = false;
-          leftOverOctree = void 0;
-          for (i = l = 0, ref1 = octreesArray.length; l < ref1; i = l += 2) {
-            if (i + 1 >= octreesArray.length) {
-              leftOverOctree = octreesArray[i];
+          leftOverPolytree = void 0;
+          for (i = l = 0, ref1 = polytreesArray.length; l < ref1; i = l += 2) {
+            if (i + 1 >= polytreesArray.length) {
+              leftOverPolytree = polytreesArray[i];
               hasLeftOver = true;
               break;
             }
-            promise = OctreeCSG.async.union(octreesArray[i], octreesArray[i + 1]);
+            promise = Polytree.async.union(polytreesArray[i], polytreesArray[i + 1]);
             promises.push(promise);
           }
-          if (leftOverOctree) {
-            promise = OctreeCSG.async.union(mainOctree, leftOverOctree);
+          if (leftOverPolytree) {
+            promise = Polytree.async.union(mainPolytree, leftOverPolytree);
             promises.push(promise);
-            mainOctreeUsed = true;
+            mainPolytreeUsed = true;
           }
         }
         return Promise.allSettled(promises).then(function(results) {
-          var octrees;
-          octrees = [];
+          var polytrees;
+          polytrees = [];
           results.forEach(function(r) {
             if (r.status === "fulfilled") {
-              return octrees.push(r.value);
+              return polytrees.push(r.value);
             }
           });
-          if (!mainOctreeUsed) {
-            octrees.unshift(mainOctree);
+          if (!mainPolytreeUsed) {
+            polytrees.unshift(mainPolytree);
           }
-          if (octrees.length > 0) {
-            if (octrees.length === 1) {
-              return resolve(octrees[0]);
-            } else if (octrees.length > 3) {
-              return OctreeCSG.async.unionArray(octrees, usingBatches ? 0 : -1).then(function(result) {
+          if (polytrees.length > 0) {
+            if (polytrees.length === 1) {
+              return resolve(polytrees[0]);
+            } else if (polytrees.length > 3) {
+              return Polytree.async.unionArray(polytrees, usingBatches ? 0 : -1).then(function(result) {
                 return resolve(result);
               }).catch(function(e) {
                 return reject(e);
               });
             } else {
-              return OctreeCSG.async.union(octrees[0], octrees[1]).then(function(result) {
-                if (octrees.length === 3) {
-                  return OctreeCSG.async.union(result, octrees[2]).then(function(result) {
+              return Polytree.async.union(polytrees[0], polytrees[1]).then(function(result) {
+                if (polytrees.length === 3) {
+                  return Polytree.async.union(result, polytrees[2]).then(function(result) {
                     return resolve(result);
                   }).catch(function(e) {
                     return reject(e);
@@ -1831,7 +1836,7 @@ OctreeCSG.async = {
               });
             }
           } else {
-            return reject('Unable to find any result octree');
+            return reject('Unable to find any result polytree');
           }
         });
       } catch (error) {
@@ -1842,87 +1847,87 @@ OctreeCSG.async = {
   },
   subtractArray: function(objArr, materialIndexMax = 2e308) {
     return new Promise(function(resolve, reject) {
-      var batch, batches, currentIndex, e, hasLeftOver, i, k, l, leftOverOctree, mainOctree, mainOctreeUsed, materialIndex, octreesArray, promise, promises, ref, ref1, result, tempOctree, usingBatches;
+      var batch, batches, currentIndex, e, hasLeftOver, i, k, l, leftOverPolytree, mainPolytree, mainPolytreeUsed, materialIndex, polytreesArray, promise, promises, ref, ref1, result, tempPolytree, usingBatches;
       try {
-        usingBatches = OctreeCSG.async.batchSize > 4 && OctreeCSG.async.batchSize < objArr.length;
-        mainOctree = void 0;
-        mainOctreeUsed = false;
+        usingBatches = Polytree.async.batchSize > 4 && Polytree.async.batchSize < objArr.length;
+        mainPolytree = void 0;
+        mainPolytreeUsed = false;
         promises = [];
         if (usingBatches) {
           batches = [];
           currentIndex = 0;
           while (currentIndex < objArr.length) {
-            batches.push(objArr.slice(currentIndex, currentIndex + OctreeCSG.async.batchSize));
-            currentIndex += OctreeCSG.async.batchSize;
+            batches.push(objArr.slice(currentIndex, currentIndex + Polytree.async.batchSize));
+            currentIndex += Polytree.async.batchSize;
           }
           batch = batches.shift();
           while (batch) {
-            promise = OctreeCSG.async.subtractArray(batch, 0);
+            promise = Polytree.async.subtractArray(batch, 0);
             promises.push(promise);
             batch = batches.shift();
           }
           usingBatches = true;
-          mainOctreeUsed = true;
+          mainPolytreeUsed = true;
           objArr.length = 0;
         } else {
-          octreesArray = [];
+          polytreesArray = [];
           for (i = k = 0, ref = objArr.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
             materialIndex = i > materialIndexMax ? materialIndexMax : i;
-            tempOctree = void 0;
+            tempPolytree = void 0;
             if (objArr[i].isMesh) {
-              tempOctree = OctreeCSG.fromMesh(objArr[i], materialIndexMax > -1 ? materialIndex : void 0);
+              tempPolytree = Polytree.fromMesh(objArr[i], materialIndexMax > -1 ? materialIndex : void 0);
             } else {
-              tempOctree = objArr[i];
+              tempPolytree = objArr[i];
               if (materialIndexMax > -1) {
-                tempOctree.setPolygonIndex(materialIndex);
+                tempPolytree.setPolygonIndex(materialIndex);
               }
             }
-            tempOctree.octreeIndex = i;
-            octreesArray.push(tempOctree);
+            tempPolytree.polytreeIndex = i;
+            polytreesArray.push(tempPolytree);
           }
-          mainOctree = octreesArray.shift();
+          mainPolytree = polytreesArray.shift();
           result = void 0;
           hasLeftOver = false;
-          leftOverOctree = void 0;
-          for (i = l = 0, ref1 = octreesArray.length; l < ref1; i = l += 2) {
-            if (i + 1 >= octreesArray.length) {
-              leftOverOctree = octreesArray[i];
+          leftOverPolytree = void 0;
+          for (i = l = 0, ref1 = polytreesArray.length; l < ref1; i = l += 2) {
+            if (i + 1 >= polytreesArray.length) {
+              leftOverPolytree = polytreesArray[i];
               hasLeftOver = true;
               break;
             }
-            promise = OctreeCSG.async.subtract(octreesArray[i], octreesArray[i + 1]);
+            promise = Polytree.async.subtract(polytreesArray[i], polytreesArray[i + 1]);
             promises.push(promise);
           }
-          if (leftOverOctree) {
-            promise = OctreeCSG.async.subtract(mainOctree, leftOverOctree);
+          if (leftOverPolytree) {
+            promise = Polytree.async.subtract(mainPolytree, leftOverPolytree);
             promises.push(promise);
-            mainOctreeUsed = true;
+            mainPolytreeUsed = true;
           }
         }
         return Promise.allSettled(promises).then(function(results) {
-          var octrees;
-          octrees = [];
+          var polytrees;
+          polytrees = [];
           results.forEach(function(r) {
             if (r.status === "fulfilled") {
-              return octrees.push(r.value);
+              return polytrees.push(r.value);
             }
           });
-          if (!mainOctreeUsed) {
-            octrees.unshift(mainOctree);
+          if (!mainPolytreeUsed) {
+            polytrees.unshift(mainPolytree);
           }
-          if (octrees.length > 0) {
-            if (octrees.length === 1) {
-              return resolve(octrees[0]);
-            } else if (octrees.length > 3) {
-              return OctreeCSG.async.subtractArray(octrees, usingBatches ? 0 : -1).then(function(result) {
+          if (polytrees.length > 0) {
+            if (polytrees.length === 1) {
+              return resolve(polytrees[0]);
+            } else if (polytrees.length > 3) {
+              return Polytree.async.subtractArray(polytrees, usingBatches ? 0 : -1).then(function(result) {
                 return resolve(result);
               }).catch(function(e) {
                 return reject(e);
               });
             } else {
-              return OctreeCSG.async.subtract(octrees[0], octrees[1]).then(function(result) {
-                if (octrees.length === 3) {
-                  return OctreeCSG.async.subtract(result, octrees[2]).then(function(result) {
+              return Polytree.async.subtract(polytrees[0], polytrees[1]).then(function(result) {
+                if (polytrees.length === 3) {
+                  return Polytree.async.subtract(result, polytrees[2]).then(function(result) {
                     return resolve(result);
                   }).catch(function(e) {
                     return reject(e);
@@ -1935,7 +1940,7 @@ OctreeCSG.async = {
               });
             }
           } else {
-            return reject('Unable to find any result octree');
+            return reject('Unable to find any result polytree');
           }
         });
       } catch (error) {
@@ -1946,87 +1951,87 @@ OctreeCSG.async = {
   },
   intersectArray: function(objArr, materialIndexMax = 2e308) {
     return new Promise(function(resolve, reject) {
-      var batch, batches, currentIndex, e, hasLeftOver, i, k, l, leftOverOctree, mainOctree, mainOctreeUsed, materialIndex, octreesArray, promise, promises, ref, ref1, result, tempOctree, usingBatches;
+      var batch, batches, currentIndex, e, hasLeftOver, i, k, l, leftOverPolytree, mainPolytree, mainPolytreeUsed, materialIndex, polytreesArray, promise, promises, ref, ref1, result, tempPolytree, usingBatches;
       try {
-        usingBatches = OctreeCSG.async.batchSize > 4 && OctreeCSG.async.batchSize < objArr.length;
-        mainOctree = void 0;
-        mainOctreeUsed = false;
+        usingBatches = Polytree.async.batchSize > 4 && Polytree.async.batchSize < objArr.length;
+        mainPolytree = void 0;
+        mainPolytreeUsed = false;
         promises = [];
         if (usingBatches) {
           batches = [];
           currentIndex = 0;
           while (currentIndex < objArr.length) {
-            batches.push(objArr.slice(currentIndex, currentIndex + OctreeCSG.async.batchSize));
-            currentIndex += OctreeCSG.async.batchSize;
+            batches.push(objArr.slice(currentIndex, currentIndex + Polytree.async.batchSize));
+            currentIndex += Polytree.async.batchSize;
           }
           batch = batches.shift();
           while (batch) {
-            promise = OctreeCSG.async.intersectArray(batch, 0);
+            promise = Polytree.async.intersectArray(batch, 0);
             promises.push(promise);
             batch = batches.shift();
           }
           usingBatches = true;
-          mainOctreeUsed = true;
+          mainPolytreeUsed = true;
           objArr.length = 0;
         } else {
-          octreesArray = [];
+          polytreesArray = [];
           for (i = k = 0, ref = objArr.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
             materialIndex = i > materialIndexMax ? materialIndexMax : i;
-            tempOctree = void 0;
+            tempPolytree = void 0;
             if (objArr[i].isMesh) {
-              tempOctree = OctreeCSG.fromMesh(objArr[i], materialIndexMax > -1 ? materialIndex : void 0);
+              tempPolytree = Polytree.fromMesh(objArr[i], materialIndexMax > -1 ? materialIndex : void 0);
             } else {
-              tempOctree = objArr[i];
+              tempPolytree = objArr[i];
               if (materialIndexMax > -1) {
-                tempOctree.setPolygonIndex(materialIndex);
+                tempPolytree.setPolygonIndex(materialIndex);
               }
             }
-            tempOctree.octreeIndex = i;
-            octreesArray.push(tempOctree);
+            tempPolytree.polytreeIndex = i;
+            polytreesArray.push(tempPolytree);
           }
-          mainOctree = octreesArray.shift();
+          mainPolytree = polytreesArray.shift();
           result = void 0;
           hasLeftOver = false;
-          leftOverOctree = void 0;
-          for (i = l = 0, ref1 = octreesArray.length; l < ref1; i = l += 2) {
-            if (i + 1 >= octreesArray.length) {
-              leftOverOctree = octreesArray[i];
+          leftOverPolytree = void 0;
+          for (i = l = 0, ref1 = polytreesArray.length; l < ref1; i = l += 2) {
+            if (i + 1 >= polytreesArray.length) {
+              leftOverPolytree = polytreesArray[i];
               hasLeftOver = true;
               break;
             }
-            promise = OctreeCSG.async.intersect(octreesArray[i], octreesArray[i + 1]);
+            promise = Polytree.async.intersect(polytreesArray[i], polytreesArray[i + 1]);
             promises.push(promise);
           }
-          if (leftOverOctree) {
-            promise = OctreeCSG.async.intersect(mainOctree, leftOverOctree);
+          if (leftOverPolytree) {
+            promise = Polytree.async.intersect(mainPolytree, leftOverPolytree);
             promises.push(promise);
-            mainOctreeUsed = true;
+            mainPolytreeUsed = true;
           }
         }
         return Promise.allSettled(promises).then(function(results) {
-          var octrees;
-          octrees = [];
+          var polytrees;
+          polytrees = [];
           results.forEach(function(r) {
             if (r.status === "fulfilled") {
-              return octrees.push(r.value);
+              return polytrees.push(r.value);
             }
           });
-          if (!mainOctreeUsed) {
-            octrees.unshift(mainOctree);
+          if (!mainPolytreeUsed) {
+            polytrees.unshift(mainPolytree);
           }
-          if (octrees.length > 0) {
-            if (octrees.length === 1) {
-              return resolve(octrees[0]);
-            } else if (octrees.length > 3) {
-              return OctreeCSG.async.intersectArray(octrees, usingBatches ? 0 : -1).then(function(result) {
+          if (polytrees.length > 0) {
+            if (polytrees.length === 1) {
+              return resolve(polytrees[0]);
+            } else if (polytrees.length > 3) {
+              return Polytree.async.intersectArray(polytrees, usingBatches ? 0 : -1).then(function(result) {
                 return resolve(result);
               }).catch(function(e) {
                 return reject(e);
               });
             } else {
-              return OctreeCSG.async.intersect(octrees[0], octrees[1]).then(function(result) {
-                if (octrees.length === 3) {
-                  return OctreeCSG.async.intersect(result, octrees[2]).then(function(result) {
+              return Polytree.async.intersect(polytrees[0], polytrees[1]).then(function(result) {
+                if (polytrees.length === 3) {
+                  return Polytree.async.intersect(result, polytrees[2]).then(function(result) {
                     return resolve(result);
                   }).catch(function(e) {
                     return reject(e);
@@ -2039,7 +2044,7 @@ OctreeCSG.async = {
               });
             }
           } else {
-            return reject('Unable to find any result octree');
+            return reject('Unable to find any result polytree');
           }
         });
       } catch (error) {
@@ -2048,78 +2053,78 @@ OctreeCSG.async = {
       }
     });
   },
-  operation: function(obj, returnOctrees = false, buildTargetOctree = true, options = {
+  operation: function(obj, returnPolytrees = false, buildTargetPolytree = true, options = {
       objCounter: 0
     }, firstRun = true) {
     return new Promise(function(resolve, reject) {
-      var e, material, octreeA, octreeB, promise, promises, resultOctree;
+      var e, material, polytreeA, polytreeB, promise, promises, resultPolytree;
       try {
-        octreeA = void 0;
-        octreeB = void 0;
-        resultOctree = void 0;
+        polytreeA = void 0;
+        polytreeB = void 0;
+        resultPolytree = void 0;
         material = void 0;
         if (obj.material) {
           material = obj.material;
         }
         promises = [];
         if (obj.objA) {
-          promise = handleObjectForOp_async(obj.objA, returnOctrees, buildTargetOctree, options, 0);
+          promise = handleObjectForOp_async(obj.objA, returnPolytrees, buildTargetPolytree, options, 0);
           promises.push(promise);
         }
         if (obj.objB) {
-          promise = handleObjectForOp_async(obj.objB, returnOctrees, buildTargetOctree, options, 1);
+          promise = handleObjectForOp_async(obj.objB, returnPolytrees, buildTargetPolytree, options, 1);
           promises.push(promise);
         }
         return Promise.allSettled(promises).then(function(results) {
-          var octrees, resultPromise;
-          octrees = [];
+          var polytrees, resultPromise;
+          polytrees = [];
           results.forEach(function(r) {
             if (r.status === "fulfilled") {
               if (r.value.objIndex === 0) {
-                return octreeA = r.value;
+                return polytreeA = r.value;
               } else if (r.value.objIndex === 1) {
-                return octreeB = r.value;
+                return polytreeB = r.value;
               }
             }
           });
-          if (returnOctrees === true) {
-            obj.objA = octreeA.original;
-            octreeA = octreeA.result;
-            obj.objB = octreeB.original;
-            octreeB = octreeB.result;
+          if (returnPolytrees === true) {
+            obj.objA = polytreeA.original;
+            polytreeA = polytreeA.result;
+            obj.objB = polytreeB.original;
+            polytreeB = polytreeB.result;
           }
           resultPromise = void 0;
           switch (obj.op) {
             case 'union':
-              resultPromise = OctreeCSG.async.union(octreeA, octreeB, buildTargetOctree);
+              resultPromise = Polytree.async.union(polytreeA, polytreeB, buildTargetPolytree);
               break;
             case 'subtract':
-              resultPromise = OctreeCSG.async.subtract(octreeA, octreeB, buildTargetOctree);
+              resultPromise = Polytree.async.subtract(polytreeA, polytreeB, buildTargetPolytree);
               break;
             case 'intersect':
-              resultPromise = OctreeCSG.async.intersect(octreeA, octreeB, buildTargetOctree);
+              resultPromise = Polytree.async.intersect(polytreeA, polytreeB, buildTargetPolytree);
           }
-          return resultPromise.then(function(resultOctree) {
+          return resultPromise.then(function(resultPolytree) {
             var mesh;
             if (firstRun && material) {
-              mesh = OctreeCSG.toMesh(resultOctree, material);
-              if (!returnOctrees) {
-                disposeOctree(resultOctree);
+              mesh = Polytree.toMesh(resultPolytree, material);
+              if (!returnPolytrees) {
+                disposePolytree(resultPolytree);
               }
-              resolve(returnOctrees ? {
+              resolve(returnPolytrees ? {
                 result: mesh,
                 operationTree: obj
               } : mesh);
-            } else if (firstRun && returnOctrees) {
+            } else if (firstRun && returnPolytrees) {
               resolve({
-                result: resultOctree,
+                result: resultPolytree,
                 operationTree: obj
               });
             } else {
-              resolve(resultOctree);
+              resolve(resultPolytree);
             }
-            if (!returnOctrees) {
-              return disposeOctree(octreeA, octreeB);
+            if (!returnPolytrees) {
+              return disposePolytree(polytreeA, polytreeB);
             }
           }).catch(function(e) {
             return reject(e);
@@ -2133,126 +2138,126 @@ OctreeCSG.async = {
   }
 };
 
-OctreeCSG.unionArray = function(objArr, materialIndexMax = 2e308) {
-  var i, k, materialIndex, octreeA, octreeB, octreesArray, ref, resultOctree, tempOctree;
-  octreesArray = [];
+Polytree.unionArray = function(objArr, materialIndexMax = 2e308) {
+  var i, k, materialIndex, polytreeA, polytreeB, polytreesArray, ref, resultPolytree, tempPolytree;
+  polytreesArray = [];
   for (i = k = 0, ref = objArr.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
     materialIndex = i > materialIndexMax ? materialIndexMax : i;
-    tempOctree = void 0;
+    tempPolytree = void 0;
     if (objArr[i].isMesh) {
-      tempOctree = OctreeCSG.fromMesh(objArr[i], materialIndex);
+      tempPolytree = Polytree.fromMesh(objArr[i], materialIndex);
     } else {
-      tempOctree = objArr[i];
-      tempOctree.setPolygonIndex(materialIndex);
+      tempPolytree = objArr[i];
+      tempPolytree.setPolygonIndex(materialIndex);
     }
-    tempOctree.octreeIndex = i;
-    octreesArray.push(tempOctree);
+    tempPolytree.polytreeIndex = i;
+    polytreesArray.push(tempPolytree);
   }
-  octreeA = octreesArray.shift();
-  octreeB = octreesArray.shift();
-  while (octreeA && octreeB) {
-    resultOctree = OctreeCSG.union(octreeA, octreeB);
-    disposeOctree(octreeA, octreeB);
-    octreeA = resultOctree;
-    octreeB = octreesArray.shift();
+  polytreeA = polytreesArray.shift();
+  polytreeB = polytreesArray.shift();
+  while (polytreeA && polytreeB) {
+    resultPolytree = Polytree.union(polytreeA, polytreeB);
+    disposePolytree(polytreeA, polytreeB);
+    polytreeA = resultPolytree;
+    polytreeB = polytreesArray.shift();
   }
-  return octreeA;
+  return polytreeA;
 };
 
-OctreeCSG.subtractArray = function(objArr, materialIndexMax = 2e308) {
-  var i, k, materialIndex, octreeA, octreeB, octreesArray, ref, resultOctree, tempOctree;
-  octreesArray = [];
+Polytree.subtractArray = function(objArr, materialIndexMax = 2e308) {
+  var i, k, materialIndex, polytreeA, polytreeB, polytreesArray, ref, resultPolytree, tempPolytree;
+  polytreesArray = [];
   for (i = k = 0, ref = objArr.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
     materialIndex = i > materialIndexMax ? materialIndexMax : i;
-    tempOctree = void 0;
+    tempPolytree = void 0;
     if (objArr[i].isMesh) {
-      tempOctree = OctreeCSG.fromMesh(objArr[i], materialIndex);
+      tempPolytree = Polytree.fromMesh(objArr[i], materialIndex);
     } else {
-      tempOctree = objArr[i];
-      tempOctree.setPolygonIndex(materialIndex);
+      tempPolytree = objArr[i];
+      tempPolytree.setPolygonIndex(materialIndex);
     }
-    tempOctree.octreeIndex = i;
-    octreesArray.push(tempOctree);
+    tempPolytree.polytreeIndex = i;
+    polytreesArray.push(tempPolytree);
   }
-  octreeA = octreesArray.shift();
-  octreeB = octreesArray.shift();
-  while (octreeA && octreeB) {
-    resultOctree = OctreeCSG.subtract(octreeA, octreeB);
-    disposeOctree(octreeA, octreeB);
-    octreeA = resultOctree;
-    octreeB = octreesArray.shift();
+  polytreeA = polytreesArray.shift();
+  polytreeB = polytreesArray.shift();
+  while (polytreeA && polytreeB) {
+    resultPolytree = Polytree.subtract(polytreeA, polytreeB);
+    disposePolytree(polytreeA, polytreeB);
+    polytreeA = resultPolytree;
+    polytreeB = polytreesArray.shift();
   }
-  return octreeA;
+  return polytreeA;
 };
 
-OctreeCSG.intersectArray = function(objArr, materialIndexMax = 2e308) {
-  var i, k, materialIndex, octreeA, octreeB, octreesArray, ref, resultOctree, tempOctree;
-  octreesArray = [];
+Polytree.intersectArray = function(objArr, materialIndexMax = 2e308) {
+  var i, k, materialIndex, polytreeA, polytreeB, polytreesArray, ref, resultPolytree, tempPolytree;
+  polytreesArray = [];
   for (i = k = 0, ref = objArr.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
     materialIndex = i > materialIndexMax ? materialIndexMax : i;
-    tempOctree = void 0;
+    tempPolytree = void 0;
     if (objArr[i].isMesh) {
-      tempOctree = OctreeCSG.fromMesh(objArr[i], materialIndex);
+      tempPolytree = Polytree.fromMesh(objArr[i], materialIndex);
     } else {
-      tempOctree = objArr[i];
-      tempOctree.setPolygonIndex(materialIndex);
+      tempPolytree = objArr[i];
+      tempPolytree.setPolygonIndex(materialIndex);
     }
-    tempOctree.octreeIndex = i;
-    octreesArray.push(tempOctree);
+    tempPolytree.polytreeIndex = i;
+    polytreesArray.push(tempPolytree);
   }
-  octreeA = octreesArray.shift();
-  octreeB = octreesArray.shift();
-  while (octreeA && octreeB) {
-    resultOctree = OctreeCSG.intersect(octreeA, octreeB);
-    disposeOctree(octreeA, octreeB);
-    octreeA = resultOctree;
-    octreeB = octreesArray.shift();
+  polytreeA = polytreesArray.shift();
+  polytreeB = polytreesArray.shift();
+  while (polytreeA && polytreeB) {
+    resultPolytree = Polytree.intersect(polytreeA, polytreeB);
+    disposePolytree(polytreeA, polytreeB);
+    polytreeA = resultPolytree;
+    polytreeB = polytreesArray.shift();
   }
-  return octreeA;
+  return polytreeA;
 };
 
-OctreeCSG.operation = function(obj, returnOctrees = false, buildTargetOctree = true, options = {
+Polytree.operation = function(obj, returnPolytrees = false, buildTargetPolytree = true, options = {
     objCounter: 0
   }, firstRun = true) {
-  var material, mesh, octreeA, octreeB, resultOctree;
-  octreeA = void 0;
-  octreeB = void 0;
-  resultOctree = void 0;
+  var material, mesh, polytreeA, polytreeB, resultPolytree;
+  polytreeA = void 0;
+  polytreeB = void 0;
+  resultPolytree = void 0;
   material = void 0;
   if (obj.material) {
     material = obj.material;
   }
   if (obj.objA) {
-    octreeA = handleObjectForOp(obj.objA, returnOctrees, buildTargetOctree, options);
-    if (returnOctrees === true) {
-      obj.objA = octreeA.original;
-      octreeA = octreeA.result;
+    polytreeA = handleObjectForOp(obj.objA, returnPolytrees, buildTargetPolytree, options);
+    if (returnPolytrees === true) {
+      obj.objA = polytreeA.original;
+      polytreeA = polytreeA.result;
     }
   }
   if (obj.objB) {
-    octreeB = handleObjectForOp(obj.objB, returnOctrees, buildTargetOctree, options);
-    if (returnOctrees === true) {
-      obj.objB = octreeB.original;
-      octreeB = octreeB.result;
+    polytreeB = handleObjectForOp(obj.objB, returnPolytrees, buildTargetPolytree, options);
+    if (returnPolytrees === true) {
+      obj.objB = polytreeB.original;
+      polytreeB = polytreeB.result;
     }
   }
   switch (obj.op) {
     case 'union':
-      resultOctree = OctreeCSG.union(octreeA, octreeB, buildTargetOctree);
+      resultPolytree = Polytree.union(polytreeA, polytreeB, buildTargetPolytree);
       break;
     case 'subtract':
-      resultOctree = OctreeCSG.subtract(octreeA, octreeB, buildTargetOctree);
+      resultPolytree = Polytree.subtract(polytreeA, polytreeB, buildTargetPolytree);
       break;
     case 'intersect':
-      resultOctree = OctreeCSG.intersect(octreeA, octreeB, buildTargetOctree);
+      resultPolytree = Polytree.intersect(polytreeA, polytreeB, buildTargetPolytree);
   }
-  if (!returnOctrees) {
-    disposeOctree(octreeA, octreeB);
+  if (!returnPolytrees) {
+    disposePolytree(polytreeA, polytreeB);
   }
   if (firstRun && material) {
-    mesh = OctreeCSG.toMesh(resultOctree, material);
-    disposeOctree(resultOctree);
-    if (returnOctrees) {
+    mesh = Polytree.toMesh(resultPolytree, material);
+    disposePolytree(resultPolytree);
+    if (returnPolytrees) {
       return {
         result: mesh,
         operationTree: obj
@@ -2261,37 +2266,37 @@ OctreeCSG.operation = function(obj, returnOctrees = false, buildTargetOctree = t
       return mesh;
     }
   }
-  if (firstRun && returnOctrees) {
+  if (firstRun && returnPolytrees) {
     return {
-      result: resultOctree,
+      result: resultPolytree,
       operationTree: obj
     };
   }
-  return resultOctree;
+  return resultPolytree;
 };
 
-handleObjectForOp = function(obj, returnOctrees, buildTargetOctree, options) {
+handleObjectForOp = function(obj, returnPolytrees, buildTargetPolytree, options) {
   var returnObj;
   returnObj = void 0;
   if (obj.isMesh) {
-    returnObj = OctreeCSG.fromMesh(obj, options.objCounter++);
-    if (returnOctrees) {
+    returnObj = Polytree.fromMesh(obj, options.objCounter++);
+    if (returnPolytrees) {
       returnObj = {
         result: returnObj,
         original: returnObj.clone()
       };
     }
-  } else if (obj.isOctree) {
+  } else if (obj.isPolytree) {
     returnObj = obj;
-    if (returnOctrees) {
+    if (returnPolytrees) {
       returnObj = {
         result: obj,
         original: obj.clone()
       };
     }
   } else if (obj.op) {
-    returnObj = OctreeCSG.operation(obj, returnOctrees, buildTargetOctree, options, false);
-    if (returnOctrees) {
+    returnObj = Polytree.operation(obj, returnPolytrees, buildTargetPolytree, options, false);
+    if (returnPolytrees) {
       returnObj = {
         result: returnObj,
         original: obj
@@ -2301,14 +2306,14 @@ handleObjectForOp = function(obj, returnOctrees, buildTargetOctree, options) {
   return returnObj;
 };
 
-handleObjectForOp_async = function(obj, returnOctrees, buildTargetOctree, options, objIndex) {
+handleObjectForOp_async = function(obj, returnPolytrees, buildTargetPolytree, options, objIndex) {
   return new Promise(function(resolve, reject) {
     var e, returnObj;
     try {
       returnObj = void 0;
       if (obj.isMesh) {
-        returnObj = OctreeCSG.fromMesh(obj, options.objCounter++);
-        if (returnOctrees) {
+        returnObj = Polytree.fromMesh(obj, options.objCounter++);
+        if (returnPolytrees) {
           returnObj = {
             result: returnObj,
             original: returnObj.clone()
@@ -2316,9 +2321,9 @@ handleObjectForOp_async = function(obj, returnOctrees, buildTargetOctree, option
         }
         returnObj.objIndex = objIndex;
         return resolve(returnObj);
-      } else if (obj.isOctree) {
+      } else if (obj.isPolytree) {
         returnObj = obj;
-        if (returnOctrees) {
+        if (returnPolytrees) {
           returnObj = {
             result: obj,
             original: obj.clone()
@@ -2327,8 +2332,8 @@ handleObjectForOp_async = function(obj, returnOctrees, buildTargetOctree, option
         returnObj.objIndex = objIndex;
         return resolve(returnObj);
       } else if (obj.op) {
-        return OctreeCSG.async.operation(obj, returnOctrees, buildTargetOctree, options, false).then(function(returnObj) {
-          if (returnOctrees) {
+        return Polytree.async.operation(obj, returnPolytrees, buildTargetPolytree, options, false).then(function(returnObj) {
+          if (returnPolytrees) {
             returnObj = {
               result: returnObj,
               original: obj
@@ -2388,9 +2393,9 @@ tmpm3 = new Matrix3();
 
 ttvv0 = new Vector3();
 
-OctreeCSG.toGeometry = function(octree) {
+Polytree.toGeometry = function(polytree) {
   var colors, defaultGroup, geometry, groupBase, groups, i, index, k, l, len1, m, normals, polygon, polygons, positions, ref, ref1, triangleCount, uvs, vertices, verticesLen;
-  polygons = octree.getPolygons();
+  polygons = polytree.getPolygons();
   triangleCount = polygons.length;
   // let validPolygons = [];
   // let trianglesSet = new Set();
@@ -2472,19 +2477,19 @@ OctreeCSG.toGeometry = function(octree) {
   return geometry;
 };
 
-OctreeCSG.toMesh = function(octree, toMaterial) {
+Polytree.toMesh = function(polytree, toMaterial) {
   var geometry;
-  geometry = OctreeCSG.toGeometry(octree);
+  geometry = Polytree.toGeometry(polytree);
   return new Mesh(geometry, toMaterial);
 };
 
-OctreeCSG.fromMesh = function(obj, objectIndex, octree = new OctreeCSG(), buildTargetOctree = true) {
-  var color, colorattr, geometry, group, groups, i, index, j, k, l, len1, m, normal, normalattr, o, polygon, polys, pos, posattr, ref, ref1, uv, uvattr, vertices, vi, vp, vt;
-  if (obj.isOctree) {
+Polytree.fromMesh = function(obj, objectIndex, polytree = new Polytree(), buildTargetPolytree = true) {
+  var color, colorattr, geometry, group, groups, i, index, j, k, l, len1, m, n, normal, normalattr, polygon, polys, pos, posattr, positionIndex, ref, ref1, uvCoords, uvIndex, uvattr, vertexIndex, vertices;
+  if (obj.isPolytree) {
     return obj;
   }
-  if (OctreeCSG.rayIntersectTriangleType === "regular") {
-    octree.originalMatrixWorld = obj.matrixWorld.clone();
+  if (Polytree.rayIntersectTriangleType === "regular") {
+    polytree.originalMatrixWorld = obj.matrixWorld.clone();
   }
   obj.updateWorldMatrix(true, true);
   geometry = obj.geometry;
@@ -2501,23 +2506,23 @@ OctreeCSG.fromMesh = function(obj, objectIndex, octree = new OctreeCSG(), buildT
   for (i = k = 0, ref = index.length; k < ref; i = k += 3) {
     vertices = [];
     for (j = l = 0; l < 3; j = ++l) {
-      vi = index[i + j];
-      vp = vi * 3;
-      vt = vi * 2;
-      pos = new Vector3(posattr.array[vp], posattr.array[vp + 1], posattr.array[vp + 2]);
-      normal = new Vector3(normalattr.array[vp], normalattr.array[vp + 1], normalattr.array[vp + 2]);
+      vertexIndex = index[i + j];
+      positionIndex = vertexIndex * 3;
+      uvIndex = vertexIndex * 2;
+      pos = new Vector3(posattr.array[positionIndex], posattr.array[positionIndex + 1], posattr.array[positionIndex + 2]);
+      normal = new Vector3(normalattr.array[positionIndex], normalattr.array[positionIndex + 1], normalattr.array[positionIndex + 2]);
       pos.applyMatrix4(obj.matrix);
       normal.applyMatrix3(tmpm3);
-      uv = uvattr ? {
-        x: uvattr.array[vt],
-        y: uvattr.array[vt + 1]
+      uvCoords = uvattr ? {
+        x: uvattr.array[uvIndex],
+        y: uvattr.array[uvIndex + 1]
       } : void 0;
       color = colorattr ? {
-        x: colorattr.array[vt],
-        y: colorattr.array[vt + 1],
-        z: colorattr.array[vt + 2]
+        x: colorattr.array[uvIndex],
+        y: colorattr.array[uvIndex + 1],
+        z: colorattr.array[uvIndex + 2]
       } : void 0;
-      vertices.push(new Vertex(pos, normal, uv, color));
+      vertices.push(new Vertex(pos, normal, uvCoords, color));
     }
     if ((objectIndex === void 0) && groups && groups.length > 0) {
       polygon = void 0;
@@ -2537,18 +2542,18 @@ OctreeCSG.fromMesh = function(obj, objectIndex, octree = new OctreeCSG(), buildT
       polys.push(polygon);
     }
   }
-  for (i = o = 0, ref1 = polys.length; (0 <= ref1 ? o < ref1 : o > ref1); i = 0 <= ref1 ? ++o : --o) {
+  for (i = n = 0, ref1 = polys.length; (0 <= ref1 ? n < ref1 : n > ref1); i = 0 <= ref1 ? ++n : --n) {
     if (isValidTriangle(polys[i].triangle)) {
-      octree.addPolygon(polys[i]);
+      polytree.addPolygon(polys[i]);
     } else {
       polys[i].delete();
     }
   }
-  buildTargetOctree && octree.buildTree();
-  if (OctreeCSG.useOctreeRay !== true) {
-    octree.mesh = obj;
+  buildTargetPolytree && polytree.buildTree();
+  if (Polytree.usePolytreeRay !== true) {
+    polytree.mesh = obj;
   }
-  return octree;
+  return polytree;
 };
 
 isValidTriangle = function(triangle) {
@@ -2622,9 +2627,9 @@ Plane = class Plane {
 };
 
 Plane.fromPoints = function(a, b, c) {
-  var n;
-  n = tv0.copy(b).sub(a).cross(tv1.copy(c).sub(a)).normalize().clone();
-  return new Plane(n, n.dot(a));
+  var planeNormal;
+  planeNormal = triangleVertex0.copy(b).sub(a).cross(triangleVertex1.copy(c).sub(a)).normalize().clone();
+  return new Plane(planeNormal, planeNormal.dot(a));
 };
 
 // class Polygon
@@ -2758,10 +2763,10 @@ Polygon = class Polygon {
 
 };
 
-disposeOctree = function(...octrees) {
-  if (OctreeCSG.disposeOctree) {
-    return octrees.forEach(function(octree) {
-      return octree.delete();
+disposePolytree = function(...polytrees) {
+  if (Polytree.disposePolytree) {
+    return polytrees.forEach(function(polytree) {
+      return polytree.delete();
     });
   }
 };
@@ -2832,23 +2837,23 @@ polyInside_WindingNumber_buffer = function(trianglesArr, point, coplanar) {
 };
 
 // -----
-handleIntersectingOctrees = function(octreeA, octreeB, bothOctrees = true) {
-  var octreeA_buffer, octreeB_buffer;
-  octreeA_buffer = void 0;
-  octreeB_buffer = void 0;
-  if (OctreeCSG.useWindingNumber === true) {
-    if (bothOctrees) {
-      octreeA_buffer = prepareTriangleBuffer(octreeA.getPolygons());
+handleIntersectingPolytrees = function(polytreeA, polytreeB, bothPolytrees = true) {
+  var polytreeA_buffer, polytreeB_buffer;
+  polytreeA_buffer = void 0;
+  polytreeB_buffer = void 0;
+  if (Polytree.useWindingNumber === true) {
+    if (bothPolytrees) {
+      polytreeA_buffer = prepareTriangleBuffer(polytreeA.getPolygons());
     }
-    octreeB_buffer = prepareTriangleBuffer(octreeB.getPolygons());
+    polytreeB_buffer = prepareTriangleBuffer(polytreeB.getPolygons());
   }
-  octreeA.handleIntersectingPolygons(octreeB, octreeB_buffer);
-  if (bothOctrees) {
-    octreeB.handleIntersectingPolygons(octreeA, octreeA_buffer);
+  polytreeA.handleIntersectingPolygons(polytreeB, polytreeB_buffer);
+  if (bothPolytrees) {
+    polytreeB.handleIntersectingPolygons(polytreeA, polytreeA_buffer);
   }
-  if (octreeA_buffer !== void 0) {
-    octreeA_buffer = void 0;
-    return octreeB_buffer = void 0;
+  if (polytreeA_buffer !== void 0) {
+    polytreeA_buffer = void 0;
+    return polytreeB_buffer = void 0;
   }
 };
 
@@ -2912,28 +2917,17 @@ rayIntersectsTriangle = function(ray, triangle, target = new Vector3()) {
   return null;
 };
 
-OctreeCSG.rayIntersectsTriangle = rayIntersectsTriangle;
-
-OctreeCSG.useOctreeRay = true;
+Polytree.rayIntersectsTriangle = rayIntersectsTriangle;
 
-OctreeCSG.useWindingNumber = false;
+Polytree.usePolytreeRay = true;
 
-OctreeCSG.rayIntersectTriangleType = "MollerTrumbore"; // "regular" (three.js' ray.intersectTriangle; "MollerTrumbore" (Moller Trumbore algorithm);
+Polytree.useWindingNumber = false;
 
-OctreeCSG.maxLevel = 16;
+Polytree.rayIntersectTriangleType = "MollerTrumbore"; // "regular" (three.js' ray.intersectTriangle; "MollerTrumbore" (Moller Trumbore algorithm);
 
-OctreeCSG.polygonsPerTree = 100;
+Polytree.maxLevel = 16;
 
-// OctreeCSG.Octree = Octree
-module.exports = {
-  default: OctreeCSG,
-  CSG: OctreeCSG,
-  OctreeCSG: OctreeCSG,
-  Polygon: Polygon,
-  Plane: Plane,
-  Vertex: Vertex,
-  rayIntersectsTriangle: rayIntersectsTriangle
-};
+Polytree.polygonsPerTree = 100;
 // Generated by CoffeeScript 2.7.0
 
 /* Determines the intersection segment (if any) between two triangles in 3D space.
@@ -3324,6 +3318,7 @@ resolveCoplanarTriangleIntersection = function(vertex1TriangleA, vertex2Triangle
 };
 
 trianglesOverlap2D = function(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB) {
+  var aE, aMax, aMin, aS, bE, bMax, bMin, bS, extractSegment, isLineDegenerate, maxAx, maxAy, maxBx, maxBy, minAx, minAy, minBx, minBy, spanAx, spanAy;
   // Early handle point-degenerate cases explicitly and efficiently.
   if (pointsEqual2D(vertex1TriangleB, vertex2TriangleB, EPS2D) && pointsEqual2D(vertex2TriangleB, vertex3TriangleB, EPS2D)) {
     return pointInTriangleInclusive2D(vertex1TriangleB, vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, EPS2D);
@@ -3331,6 +3326,60 @@ trianglesOverlap2D = function(vertex1TriangleA, vertex2TriangleA, vertex3Triangl
   if (pointsEqual2D(vertex1TriangleA, vertex2TriangleA, EPS2D) && pointsEqual2D(vertex2TriangleA, vertex3TriangleA, EPS2D)) {
     return pointInTriangleInclusive2D(vertex1TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, EPS2D);
   }
+  // If both are line-degenerate (not points): reduce to segment overlap test.
+  isLineDegenerate = function(v1, v2, v3) {
+    return (pointsEqual2D(v1, v2, EPS2D) && !pointsEqual2D(v2, v3, EPS2D)) || (pointsEqual2D(v2, v3, EPS2D) && !pointsEqual2D(v1, v2, EPS2D)) || (pointsEqual2D(v3, v1, EPS2D) && !pointsEqual2D(v1, v2, EPS2D));
+  };
+  extractSegment = function(v1, v2, v3) {
+    // Return the two distinct endpoints in stable order.
+    if (pointsEqual2D(v1, v2, EPS2D)) {
+      return [v2, v3];
+    } else if (pointsEqual2D(v2, v3, EPS2D)) {
+      return [v1, v2];
+    } else {
+      return [
+        v1,
+        v2 // fallback (should not reach if collinear case handled earlier)
+      ];
+    }
+  };
+  if (isLineDegenerate(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA) && isLineDegenerate(vertex1TriangleB, vertex2TriangleB, vertex3TriangleB)) {
+    [aS, aE] = extractSegment(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA);
+    [bS, bE] = extractSegment(vertex1TriangleB, vertex2TriangleB, vertex3TriangleB);
+    // Fast reject by axis-aligned bounding boxes.
+    minAx = Math.min(aS.x, aE.x);
+    maxAx = Math.max(aS.x, aE.x);
+    minAy = Math.min(aS.y, aE.y);
+    maxAy = Math.max(aS.y, aE.y);
+    minBx = Math.min(bS.x, bE.x);
+    maxBx = Math.max(bS.x, bE.x);
+    minBy = Math.min(bS.y, bE.y);
+    maxBy = Math.max(bS.y, bE.y);
+    if (maxAx < minBx - EPS2D || maxBx < minAx - EPS2D || maxAy < minBy - EPS2D || maxBy < minAy - EPS2D) {
+      return false;
+    }
+    // Collinear check: orientation of any mixed triple should be ~0; since we know each triangle is a line, test one.
+    if (Math.abs(triangleOrientation2D(aS, aE, bS)) > EPS2D) {
+      return false;
+    }
+    // 1D overlap test along dominant axis (choose axis with larger span to reduce precision issues).
+    spanAx = Math.abs(aE.x - aS.x);
+    spanAy = Math.abs(aE.y - aS.y);
+    if (spanAx >= spanAy) {
+      // Project onto X.
+      aMin = Math.min(aS.x, aE.x) - EPS2D;
+      aMax = Math.max(aS.x, aE.x) + EPS2D;
+      bMin = Math.min(bS.x, bE.x) - EPS2D;
+      bMax = Math.max(bS.x, bE.x) + EPS2D;
+      return !(aMax < bMin || bMax < aMin);
+    } else {
+      aMin = Math.min(aS.y, aE.y) - EPS2D;
+      aMax = Math.max(aS.y, aE.y) + EPS2D;
+      bMin = Math.min(bS.y, bE.y) - EPS2D;
+      bMax = Math.max(bS.y, bE.y) + EPS2D;
+      return !(aMax < bMin || bMax < aMin);
+    }
+  }
   if (triangleOrientation2D(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA) < 0) { // If triangle A is CW.
     if (triangleOrientation2D(vertex1TriangleB, vertex2TriangleB, vertex3TriangleB) < 0) { // If both A and B are CW → reorder both.
       return triangleIntersectionCCW2D(vertex1TriangleA, vertex3TriangleA, vertex2TriangleA, vertex1TriangleB, vertex3TriangleB, vertex2TriangleB); // Only A is CW → reorder A.
@@ -3389,132 +3438,79 @@ triangleIntersectionCCW2D = function(vertex1TriangleA, vertex2TriangleA, vertex3
 };
 
 intersectionTestEdge2D = function(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB) {
-  // If vertex3TriangleB is on or to the left of edge vertex1TriangleB-vertex2TriangleA.
-  if (triangleOrientation2D(vertex3TriangleB, vertex1TriangleB, vertex2TriangleA) >= 0) {
-    // If vertex1TriangleA is on or to the left of edge vertex1TriangleB-vertex2TriangleA.
-    if (triangleOrientation2D(vertex1TriangleA, vertex1TriangleB, vertex2TriangleA) >= 0) {
-      // If vertex1TriangleA is on or to the left of edge vertex2TriangleA-vertex3TriangleB.
-      if (triangleOrientation2D(vertex1TriangleA, vertex2TriangleA, vertex3TriangleB) >= 0) {
-        return true; // Then vertex1TriangleA is outside edge vertex2TriangleA-vertex3TriangleB.
-      } else {
-        return false; // Then vertex1TriangleA is outside edge vertex1TriangleB-vertex2TriangleA.
-      }
-    } else {
-      
-      // If vertex2TriangleA is on or to the left of edge vertex3TriangleA-vertex1TriangleB.
-      if (triangleOrientation2D(vertex2TriangleA, vertex3TriangleA, vertex1TriangleB) >= 0) {
-        // If vertex3TriangleA is on or to the left of edge vertex1TriangleA-vertex1TriangleB.
-        if (triangleOrientation2D(vertex3TriangleA, vertex1TriangleA, vertex1TriangleB) >= 0) {
-          return true; // Then vertex3TriangleA is outside edge vertex1TriangleA-vertex1TriangleB.
-        } else {
-          return false; // Then vertex2TriangleA is outside edge vertex3TriangleA-vertex1TriangleB.
-        }
-      } else {
-        return false; // Then vertex3TriangleB is outside edge vertex1TriangleB-vertex2TriangleA.
-      }
+  var a1, a2, b1, b2, edgesA, edgesB, i, j, len, len1, segmentIntersectsInclusive;
+  segmentIntersectsInclusive = function(a1, a2, b1, b2) {
+    var maxAx, maxAy, maxBx, maxBy, minAx, minAy, minBx, minBy, o1, o2, o3, o4;
+    // Fast reject by bounding boxes.
+    minAx = Math.min(a1.x, a2.x);
+    maxAx = Math.max(a1.x, a2.x);
+    minAy = Math.min(a1.y, a2.y);
+    maxAy = Math.max(a1.y, a2.y);
+    minBx = Math.min(b1.x, b2.x);
+    maxBx = Math.max(b1.x, b2.x);
+    minBy = Math.min(b1.y, b2.y);
+    maxBy = Math.max(b1.y, b2.y);
+    if (maxAx < minBx || maxBx < minAx || maxAy < minBy || maxBy < minAy) {
+      return false;
+    }
+    o1 = triangleOrientation2D(a1, a2, b1);
+    o2 = triangleOrientation2D(a1, a2, b2);
+    o3 = triangleOrientation2D(b1, b2, a1);
+    o4 = triangleOrientation2D(b1, b2, a2);
+    if ((o1 > 0 && o2 < 0 || o1 < 0 && o2 > 0) && (o3 > 0 && o4 < 0 || o3 < 0 && o4 > 0)) {
+      return true; // Proper intersection.
     }
-  } else {
     
-    // If vertex3TriangleB is on or to the left of edge vertex1TriangleB-vertex3TriangleA.
-    if (triangleOrientation2D(vertex3TriangleB, vertex1TriangleB, vertex3TriangleA) >= 0) {
-      // If vertex1TriangleA is on or to the left of edge vertex1TriangleB-vertex3TriangleA.
-      if (triangleOrientation2D(vertex1TriangleA, vertex1TriangleB, vertex3TriangleA) >= 0) {
-        // If vertex1TriangleA is on or to the left of edge vertex3TriangleA-vertex3TriangleB.
-        if (triangleOrientation2D(vertex1TriangleA, vertex3TriangleA, vertex3TriangleB) >= 0) {
-          return true;
-        } else {
-          // Then vertex2TriangleA is on or to the left of edge vertex3TriangleA-vertex3TriangleB.
-          if (triangleOrientation2D(vertex2TriangleA, vertex3TriangleA, vertex3TriangleB) >= 0) {
-            return true; // Then vertex2TriangleA is outside edge vertex3TriangleA-vertex3TriangleB.
-          } else {
-            return false; // Then vertex1TriangleA is outside edge vertex1TriangleB-vertex3TriangleA.
-          }
-        }
-      } else {
-        return false; // Then vertex3TriangleB is outside edge vertex1TriangleB-vertex3TriangleA.
+    // Collinear / endpoint inclusion checks.
+    if (Math.abs(o1) <= EPS2D && pointOnSegmentInclusive2D(b1, a1, a2, EPS2D)) {
+      return true;
+    }
+    if (Math.abs(o2) <= EPS2D && pointOnSegmentInclusive2D(b2, a1, a2, EPS2D)) {
+      return true;
+    }
+    if (Math.abs(o3) <= EPS2D && pointOnSegmentInclusive2D(a1, b1, b2, EPS2D)) {
+      return true;
+    }
+    if (Math.abs(o4) <= EPS2D && pointOnSegmentInclusive2D(a2, b1, b2, EPS2D)) {
+      return true;
+    }
+    return false;
+  };
+  edgesA = [[vertex1TriangleA, vertex2TriangleA], [vertex2TriangleA, vertex3TriangleA], [vertex3TriangleA, vertex1TriangleA]];
+  edgesB = [[vertex1TriangleB, vertex2TriangleB], [vertex2TriangleB, vertex3TriangleB], [vertex3TriangleB, vertex1TriangleB]];
+  for (i = 0, len = edgesA.length; i < len; i++) {
+    [a1, a2] = edgesA[i];
+    for (j = 0, len1 = edgesB.length; j < len1; j++) {
+      [b1, b2] = edgesB[j];
+      if (segmentIntersectsInclusive(a1, a2, b1, b2)) {
+        return true;
       }
-    } else {
-      return false;
     }
   }
+  return false;
 };
 
 intersectionTestVertex2D = function(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB) {
-  // If vertex3TriangleB is on or to the left of edge vertex1TriangleB-vertex2TriangleA.
-  if (triangleOrientation2D(vertex3TriangleB, vertex1TriangleB, vertex2TriangleA) >= 0) {
-    // If vertex3TriangleB is on or to the right of edge vertex2TriangleB-vertex2TriangleA.
-    if (triangleOrientation2D(vertex3TriangleB, vertex2TriangleB, vertex2TriangleA) <= 0) {
-      // If vertex1TriangleA is on the right of edge vertex1TriangleB-vertex2TriangleA.
-      if (triangleOrientation2D(vertex1TriangleA, vertex1TriangleB, vertex2TriangleA) > 0) {
-        // If vertex1TriangleA is on or to the left of edge vertex2TriangleB-vertex2TriangleA.
-        if (triangleOrientation2D(vertex1TriangleA, vertex2TriangleB, vertex2TriangleA) <= 0) {
-          return true; // Then vertex1TriangleA is outside edge vertex2TriangleB-vertex2TriangleA.
-        } else {
-          return false; // Then vertex1TriangleA is on or to the left of edge vertex1TriangleB-vertex2TriangleA.
-        }
-      } else {
-        
-        // If vertex1TriangleA is on or to the left of edge vertex1TriangleB-vertex3TriangleA.
-        if (triangleOrientation2D(vertex1TriangleA, vertex1TriangleB, vertex3TriangleA) >= 0) {
-          // If vertex2TriangleA is on or to the left of edge vertex3TriangleA-vertex1TriangleB.
-          if (triangleOrientation2D(vertex2TriangleA, vertex3TriangleA, vertex1TriangleB) >= 0) {
-            return true; // Then vertex2TriangleA is outside edge vertex3TriangleA-vertex1TriangleB.
-          } else {
-            return false; // Then vertex1TriangleA is outside edge vertex1TriangleB-vertex3TriangleA.
-          }
-        } else {
-          return false; // Then vertex3TriangleB is on the left of edge vertex2TriangleB-vertex2TriangleA.
-        }
-      }
-    } else {
-      
-      // If vertex1TriangleA is on or to the left of edge vertex2TriangleB-vertex2TriangleA.
-      if (triangleOrientation2D(vertex1TriangleA, vertex2TriangleB, vertex2TriangleA) <= 0) {
-        // If vertex3TriangleB is on or to the left of edge vertex2TriangleB-vertex3TriangleA.
-        if (triangleOrientation2D(vertex3TriangleB, vertex2TriangleB, vertex3TriangleA) <= 0) {
-          // If vertex2TriangleA is on or to the left of edge vertex3TriangleA-vertex2TriangleB.
-          if (triangleOrientation2D(vertex2TriangleA, vertex3TriangleA, vertex2TriangleB) >= 0) {
-            return true; // Then vertex2TriangleA is outside edge vertex3TriangleA-vertex2TriangleB.
-          } else {
-            return false; // Then vertex3TriangleB is outside edge vertex2TriangleB-vertex3TriangleA.
-          }
-        } else {
-          return false; // Then vertex1TriangleA is outside edge vertex2TriangleB-vertex2TriangleA.
-        }
-      } else {
-        return false; // Then vertex3TriangleB is outside edge vertex1TriangleB-vertex2TriangleA.
-      }
-    }
-  } else {
-    
-    // If vertex3TriangleB is on or to the left of edge vertex1TriangleB-vertex3TriangleA.
-    if (triangleOrientation2D(vertex3TriangleB, vertex1TriangleB, vertex3TriangleA) >= 0) {
-      // If vertex2TriangleA is on or to the left of edge vertex3TriangleA-vertex3TriangleB.
-      if (triangleOrientation2D(vertex2TriangleA, vertex3TriangleA, vertex3TriangleB) >= 0) {
-        // If vertex1TriangleA is on or to the left of edge vertex1TriangleB-vertex3TriangleA.
-        if (triangleOrientation2D(vertex1TriangleA, vertex1TriangleB, vertex3TriangleA) >= 0) {
-          return true; // Then vertex1TriangleA is outside edge vertex1TriangleB-vertex3TriangleA.
-        } else {
-          return false; // Then vertex2TriangleA is outside edge vertex3TriangleA-vertex3TriangleB.
-        }
-      } else {
-        
-        // If vertex2TriangleA is on or to the left of edge vertex3TriangleA-vertex2TriangleB.
-        if (triangleOrientation2D(vertex2TriangleA, vertex3TriangleA, vertex2TriangleB) >= 0) {
-          // If vertex3TriangleB is on or to the left of edge vertex3TriangleA-vertex2TriangleB.
-          if (triangleOrientation2D(vertex3TriangleB, vertex3TriangleA, vertex2TriangleB) >= 0) {
-            return true; // Then vertex3TriangleB is outside edge vertex3TriangleA-vertex2TriangleB.
-          } else {
-            return false; // Then vertex2TriangleA is outside edge vertex3TriangleA-vertex2TriangleB.
-          }
-        } else {
-          return false; // Then vertex3TriangleB is outside edge vertex1TriangleB-vertex3TriangleA.
-        }
-      }
-    } else {
-      return false;
-    }
+  if (pointInTriangleInclusive2D(vertex1TriangleB, vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, EPS2D)) {
+    // Returns true if any vertex of triangle B lies inside (or on) triangle A OR any vertex of triangle A lies inside (or on) triangle B.
+    return true;
+  }
+  if (pointInTriangleInclusive2D(vertex2TriangleB, vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, EPS2D)) {
+    return true;
+  }
+  if (pointInTriangleInclusive2D(vertex3TriangleB, vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, EPS2D)) {
+    return true;
+  }
+  if (pointInTriangleInclusive2D(vertex1TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, EPS2D)) {
+    return true;
+  }
+  if (pointInTriangleInclusive2D(vertex2TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, EPS2D)) {
+    return true;
+  }
+  if (pointInTriangleInclusive2D(vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, EPS2D)) {
+    return true;
   }
+  return false;
 };
 
 constructIntersection = function(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, additions) {
@@ -3539,11 +3535,17 @@ constructIntersection = function(vertex1TriangleA, vertex2TriangleA, vertex3Tria
         tempVector1.subVectors(vertex1TriangleA, vertex1TriangleB);
         tempVector2.subVectors(vertex1TriangleA, vertex3TriangleA);
         alpha = tempVector1.dot(additions.normal2) / tempVector2.dot(additions.normal2);
+        if (!isFinite(alpha)) {
+          return false;
+        }
         tempVector1.copy(tempVector2).multiplyScalar(alpha);
         additions.source.subVectors(vertex1TriangleA, tempVector1);
         tempVector1.subVectors(vertex1TriangleB, vertex1TriangleA);
         tempVector2.subVectors(vertex1TriangleB, vertex3TriangleB);
         alpha = tempVector1.dot(additions.normal1) / tempVector2.dot(additions.normal1);
+        if (!isFinite(alpha)) {
+          return false;
+        }
         tempVector1.copy(tempVector2).multiplyScalar(alpha);
         additions.target.subVectors(vertex1TriangleB, tempVector1);
         return true;
@@ -3552,11 +3554,17 @@ constructIntersection = function(vertex1TriangleA, vertex2TriangleA, vertex3Tria
         tempVector1.subVectors(vertex1TriangleB, vertex1TriangleA);
         tempVector2.subVectors(vertex1TriangleB, vertex2TriangleB);
         alpha = tempVector1.dot(additions.normal1) / tempVector2.dot(additions.normal1);
+        if (!isFinite(alpha)) {
+          return false;
+        }
         tempVector1.copy(tempVector2).multiplyScalar(alpha);
         additions.source.subVectors(vertex1TriangleB, tempVector1);
         tempVector1.subVectors(vertex1TriangleB, vertex1TriangleA);
         tempVector2.subVectors(vertex1TriangleB, vertex3TriangleB);
         alpha = tempVector1.dot(additions.normal1) / tempVector2.dot(additions.normal1);
+        if (!isFinite(alpha)) {
+          return false;
+        }
         tempVector1.copy(tempVector2).multiplyScalar(alpha);
         additions.target.subVectors(vertex1TriangleB, tempVector1);
         return true;
@@ -3577,11 +3585,17 @@ constructIntersection = function(vertex1TriangleA, vertex2TriangleA, vertex3Tria
         tempVector1.subVectors(vertex1TriangleB, vertex1TriangleA);
         tempVector2.subVectors(vertex1TriangleB, vertex2TriangleB);
         alpha = tempVector1.dot(additions.normal1) / tempVector2.dot(additions.normal1);
+        if (!isFinite(alpha)) {
+          return false;
+        }
         tempVector1.copy(tempVector2).multiplyScalar(alpha);
         additions.source.subVectors(vertex1TriangleB, tempVector1);
         tempVector1.subVectors(vertex1TriangleB, vertex1TriangleA);
         tempVector2.subVectors(vertex1TriangleB, vertex3TriangleB);
         alpha = tempVector1.dot(additions.normal1) / tempVector2.dot(additions.normal1);
+        if (!isFinite(alpha)) {
+          return false;
+        }
         tempVector1.copy(tempVector2).multiplyScalar(alpha);
         additions.target.subVectors(vertex1TriangleB, tempVector1);
         return true;
@@ -3590,11 +3604,17 @@ constructIntersection = function(vertex1TriangleA, vertex2TriangleA, vertex3Tria
         tempVector1.subVectors(vertex1TriangleA, vertex1TriangleB);
         tempVector2.subVectors(vertex1TriangleA, vertex3TriangleA);
         alpha = tempVector1.dot(additions.normal2) / tempVector2.dot(additions.normal2);
+        if (!isFinite(alpha)) {
+          return false;
+        }
         tempVector1.copy(tempVector2).multiplyScalar(alpha);
         additions.source.subVectors(vertex1TriangleA, tempVector1);
         tempVector1.subVectors(vertex1TriangleA, vertex1TriangleB);
         tempVector2.subVectors(vertex1TriangleA, vertex2TriangleA);
         alpha = tempVector1.dot(additions.normal2) / tempVector2.dot(additions.normal2);
+        if (!isFinite(alpha)) {
+          return false;
+        }
         tempVector1.copy(tempVector2).multiplyScalar(alpha);
         additions.target.subVectors(vertex1TriangleA, tempVector1);
         return true;
@@ -3603,5 +3623,31 @@ constructIntersection = function(vertex1TriangleA, vertex2TriangleA, vertex3Tria
   }
   return false; // If none of the above, no intersection found.
 };
+// Generated by CoffeeScript 2.7.0
+module.exports.Polytree = Polytree;
+
+module.exports.Plane = Plane;
+
+module.exports.Vertex = Vertex;
+
+module.exports.Polygon = Polygon;
+
+module.exports.rayIntersectsTriangle = rayIntersectsTriangle;
+
+module.exports.triangleIntersectsTriangle = triangleIntersectsTriangle;
+
+module.exports.resolveTriangleIntersection = resolveTriangleIntersection;
+
+module.exports.resolveCoplanarTriangleIntersection = resolveCoplanarTriangleIntersection;
+
+module.exports.trianglesOverlap2D = trianglesOverlap2D;
+
+module.exports.triangleOrientation2D = triangleOrientation2D;
+
+module.exports.triangleIntersectionCCW2D = triangleIntersectionCCW2D;
+
+module.exports.intersectionTestEdge2D = intersectionTestEdge2D;
+
+module.exports.intersectionTestVertex2D = intersectionTestVertex2D;
 
-module.exports = {triangleIntersectsTriangle, resolveTriangleIntersection, resolveCoplanarTriangleIntersection, trianglesOverlap2D, triangleOrientation2D, triangleIntersectionCCW2D, intersectionTestEdge2D, intersectionTestVertex2D, constructIntersection};
+module.exports.constructIntersection = constructIntersection;