opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/renderers/Projector.js

@@ -0,0 +1,733 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three);
+    global.Projector = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.RenderableVertex = _exports.RenderableSprite = _exports.RenderableObject = _exports.RenderableLine = _exports.RenderableFace = _exports.Projector = void 0;
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  var RenderableObject = /*#__PURE__*/_createClass(function RenderableObject() {
+    _classCallCheck(this, RenderableObject);
+
+    this.id = 0;
+    this.object = null;
+    this.z = 0;
+    this.renderOrder = 0;
+  }); //
+
+
+  _exports.RenderableObject = RenderableObject;
+
+  var RenderableFace = /*#__PURE__*/_createClass(function RenderableFace() {
+    _classCallCheck(this, RenderableFace);
+
+    this.id = 0;
+    this.v1 = new RenderableVertex();
+    this.v2 = new RenderableVertex();
+    this.v3 = new RenderableVertex();
+    this.normalModel = new _three.Vector3();
+    this.vertexNormalsModel = [new _three.Vector3(), new _three.Vector3(), new _three.Vector3()];
+    this.vertexNormalsLength = 0;
+    this.color = new _three.Color();
+    this.material = null;
+    this.uvs = [new _three.Vector2(), new _three.Vector2(), new _three.Vector2()];
+    this.z = 0;
+    this.renderOrder = 0;
+  }); //
+
+
+  _exports.RenderableFace = RenderableFace;
+
+  var RenderableVertex = /*#__PURE__*/function () {
+    function RenderableVertex() {
+      _classCallCheck(this, RenderableVertex);
+
+      this.position = new _three.Vector3();
+      this.positionWorld = new _three.Vector3();
+      this.positionScreen = new _three.Vector4();
+      this.visible = true;
+    }
+
+    _createClass(RenderableVertex, [{
+      key: "copy",
+      value: function copy(vertex) {
+        this.positionWorld.copy(vertex.positionWorld);
+        this.positionScreen.copy(vertex.positionScreen);
+      }
+    }]);
+
+    return RenderableVertex;
+  }(); //
+
+
+  _exports.RenderableVertex = RenderableVertex;
+
+  var RenderableLine = /*#__PURE__*/_createClass(function RenderableLine() {
+    _classCallCheck(this, RenderableLine);
+
+    this.id = 0;
+    this.v1 = new RenderableVertex();
+    this.v2 = new RenderableVertex();
+    this.vertexColors = [new _three.Color(), new _three.Color()];
+    this.material = null;
+    this.z = 0;
+    this.renderOrder = 0;
+  }); //
+
+
+  _exports.RenderableLine = RenderableLine;
+
+  var RenderableSprite = /*#__PURE__*/_createClass(function RenderableSprite() {
+    _classCallCheck(this, RenderableSprite);
+
+    this.id = 0;
+    this.object = null;
+    this.x = 0;
+    this.y = 0;
+    this.z = 0;
+    this.rotation = 0;
+    this.scale = new _three.Vector2();
+    this.material = null;
+    this.renderOrder = 0;
+  }); //
+
+
+  _exports.RenderableSprite = RenderableSprite;
+
+  var Projector = /*#__PURE__*/_createClass(function Projector() {
+    _classCallCheck(this, Projector);
+
+    var _object,
+        _objectCount,
+        _objectPoolLength = 0,
+        _vertex,
+        _vertexCount,
+        _vertexPoolLength = 0,
+        _face,
+        _faceCount,
+        _facePoolLength = 0,
+        _line,
+        _lineCount,
+        _linePoolLength = 0,
+        _sprite,
+        _spriteCount,
+        _spritePoolLength = 0,
+        _modelMatrix;
+
+    var _renderData = {
+      objects: [],
+      lights: [],
+      elements: []
+    },
+        _vector3 = new _three.Vector3(),
+        _vector4 = new _three.Vector4(),
+        _clipBox = new _three.Box3(new _three.Vector3(-1, -1, -1), new _three.Vector3(1, 1, 1)),
+        _boundingBox = new _three.Box3(),
+        _points3 = new Array(3),
+        _viewMatrix = new _three.Matrix4(),
+        _viewProjectionMatrix = new _three.Matrix4(),
+        _modelViewProjectionMatrix = new _three.Matrix4(),
+        _frustum = new _three.Frustum(),
+        _objectPool = [],
+        _vertexPool = [],
+        _facePool = [],
+        _linePool = [],
+        _spritePool = []; //
+
+
+    this.projectVector = function (vector, camera) {
+      console.warn('THREE.Projector: .projectVector() is now vector.project().');
+      vector.project(camera);
+    };
+
+    this.unprojectVector = function (vector, camera) {
+      console.warn('THREE.Projector: .unprojectVector() is now vector.unproject().');
+      vector.unproject(camera);
+    };
+
+    this.pickingRay = function () {
+      console.error('THREE.Projector: .pickingRay() is now raycaster.setFromCamera().');
+    }; //
+
+
+    function RenderList() {
+      var normals = [];
+      var colors = [];
+      var uvs = [];
+      var object = null;
+      var normalMatrix = new _three.Matrix3();
+
+      function setObject(value) {
+        object = value;
+        normalMatrix.getNormalMatrix(object.matrixWorld);
+        normals.length = 0;
+        colors.length = 0;
+        uvs.length = 0;
+      }
+
+      function projectVertex(vertex) {
+        var position = vertex.position;
+        var positionWorld = vertex.positionWorld;
+        var positionScreen = vertex.positionScreen;
+        positionWorld.copy(position).applyMatrix4(_modelMatrix);
+        positionScreen.copy(positionWorld).applyMatrix4(_viewProjectionMatrix);
+        var invW = 1 / positionScreen.w;
+        positionScreen.x *= invW;
+        positionScreen.y *= invW;
+        positionScreen.z *= invW;
+        vertex.visible = positionScreen.x >= -1 && positionScreen.x <= 1 && positionScreen.y >= -1 && positionScreen.y <= 1 && positionScreen.z >= -1 && positionScreen.z <= 1;
+      }
+
+      function pushVertex(x, y, z) {
+        _vertex = getNextVertexInPool();
+
+        _vertex.position.set(x, y, z);
+
+        projectVertex(_vertex);
+      }
+
+      function pushNormal(x, y, z) {
+        normals.push(x, y, z);
+      }
+
+      function pushColor(r, g, b) {
+        colors.push(r, g, b);
+      }
+
+      function pushUv(x, y) {
+        uvs.push(x, y);
+      }
+
+      function checkTriangleVisibility(v1, v2, v3) {
+        if (v1.visible === true || v2.visible === true || v3.visible === true) return true;
+        _points3[0] = v1.positionScreen;
+        _points3[1] = v2.positionScreen;
+        _points3[2] = v3.positionScreen;
+        return _clipBox.intersectsBox(_boundingBox.setFromPoints(_points3));
+      }
+
+      function checkBackfaceCulling(v1, v2, v3) {
+        return (v3.positionScreen.x - v1.positionScreen.x) * (v2.positionScreen.y - v1.positionScreen.y) - (v3.positionScreen.y - v1.positionScreen.y) * (v2.positionScreen.x - v1.positionScreen.x) < 0;
+      }
+
+      function pushLine(a, b) {
+        var v1 = _vertexPool[a];
+        var v2 = _vertexPool[b]; // Clip
+
+        v1.positionScreen.copy(v1.position).applyMatrix4(_modelViewProjectionMatrix);
+        v2.positionScreen.copy(v2.position).applyMatrix4(_modelViewProjectionMatrix);
+
+        if (clipLine(v1.positionScreen, v2.positionScreen) === true) {
+          // Perform the perspective divide
+          v1.positionScreen.multiplyScalar(1 / v1.positionScreen.w);
+          v2.positionScreen.multiplyScalar(1 / v2.positionScreen.w);
+          _line = getNextLineInPool();
+          _line.id = object.id;
+
+          _line.v1.copy(v1);
+
+          _line.v2.copy(v2);
+
+          _line.z = Math.max(v1.positionScreen.z, v2.positionScreen.z);
+          _line.renderOrder = object.renderOrder;
+          _line.material = object.material;
+
+          if (object.material.vertexColors) {
+            _line.vertexColors[0].fromArray(colors, a * 3);
+
+            _line.vertexColors[1].fromArray(colors, b * 3);
+          }
+
+          _renderData.elements.push(_line);
+        }
+      }
+
+      function pushTriangle(a, b, c, material) {
+        var v1 = _vertexPool[a];
+        var v2 = _vertexPool[b];
+        var v3 = _vertexPool[c];
+        if (checkTriangleVisibility(v1, v2, v3) === false) return;
+
+        if (material.side === _three.DoubleSide || checkBackfaceCulling(v1, v2, v3) === true) {
+          _face = getNextFaceInPool();
+          _face.id = object.id;
+
+          _face.v1.copy(v1);
+
+          _face.v2.copy(v2);
+
+          _face.v3.copy(v3);
+
+          _face.z = (v1.positionScreen.z + v2.positionScreen.z + v3.positionScreen.z) / 3;
+          _face.renderOrder = object.renderOrder; // face normal
+
+          _vector3.subVectors(v3.position, v2.position);
+
+          _vector4.subVectors(v1.position, v2.position);
+
+          _vector3.cross(_vector4);
+
+          _face.normalModel.copy(_vector3);
+
+          _face.normalModel.applyMatrix3(normalMatrix).normalize();
+
+          for (var i = 0; i < 3; i++) {
+            var normal = _face.vertexNormalsModel[i];
+            normal.fromArray(normals, arguments[i] * 3);
+            normal.applyMatrix3(normalMatrix).normalize();
+            var uv = _face.uvs[i];
+            uv.fromArray(uvs, arguments[i] * 2);
+          }
+
+          _face.vertexNormalsLength = 3;
+          _face.material = material;
+
+          if (material.vertexColors) {
+            _face.color.fromArray(colors, a * 3);
+          }
+
+          _renderData.elements.push(_face);
+        }
+      }
+
+      return {
+        setObject: setObject,
+        projectVertex: projectVertex,
+        checkTriangleVisibility: checkTriangleVisibility,
+        checkBackfaceCulling: checkBackfaceCulling,
+        pushVertex: pushVertex,
+        pushNormal: pushNormal,
+        pushColor: pushColor,
+        pushUv: pushUv,
+        pushLine: pushLine,
+        pushTriangle: pushTriangle
+      };
+    }
+
+    var renderList = new RenderList();
+
+    function projectObject(object) {
+      if (object.visible === false) return;
+
+      if (object.isLight) {
+        _renderData.lights.push(object);
+      } else if (object.isMesh || object.isLine || object.isPoints) {
+        if (object.material.visible === false) return;
+        if (object.frustumCulled === true && _frustum.intersectsObject(object) === false) return;
+        addObject(object);
+      } else if (object.isSprite) {
+        if (object.material.visible === false) return;
+        if (object.frustumCulled === true && _frustum.intersectsSprite(object) === false) return;
+        addObject(object);
+      }
+
+      var children = object.children;
+
+      for (var i = 0, l = children.length; i < l; i++) {
+        projectObject(children[i]);
+      }
+    }
+
+    function addObject(object) {
+      _object = getNextObjectInPool();
+      _object.id = object.id;
+      _object.object = object;
+
+      _vector3.setFromMatrixPosition(object.matrixWorld);
+
+      _vector3.applyMatrix4(_viewProjectionMatrix);
+
+      _object.z = _vector3.z;
+      _object.renderOrder = object.renderOrder;
+
+      _renderData.objects.push(_object);
+    }
+
+    this.projectScene = function (scene, camera, sortObjects, sortElements) {
+      _faceCount = 0;
+      _lineCount = 0;
+      _spriteCount = 0;
+      _renderData.elements.length = 0;
+      if (scene.autoUpdate === true) scene.updateMatrixWorld();
+      if (camera.parent === null) camera.updateMatrixWorld();
+
+      _viewMatrix.copy(camera.matrixWorldInverse);
+
+      _viewProjectionMatrix.multiplyMatrices(camera.projectionMatrix, _viewMatrix);
+
+      _frustum.setFromProjectionMatrix(_viewProjectionMatrix); //
+
+
+      _objectCount = 0;
+      _renderData.objects.length = 0;
+      _renderData.lights.length = 0;
+      projectObject(scene);
+
+      if (sortObjects === true) {
+        _renderData.objects.sort(painterSort);
+      } //
+
+
+      var objects = _renderData.objects;
+
+      for (var o = 0, ol = objects.length; o < ol; o++) {
+        var object = objects[o].object;
+        var geometry = object.geometry;
+        renderList.setObject(object);
+        _modelMatrix = object.matrixWorld;
+        _vertexCount = 0;
+
+        if (object.isMesh) {
+          if (geometry.isBufferGeometry) {
+            var material = object.material;
+            var isMultiMaterial = Array.isArray(material);
+            var attributes = geometry.attributes;
+            var groups = geometry.groups;
+            if (attributes.position === undefined) continue;
+            var positions = attributes.position.array;
+
+            for (var i = 0, l = positions.length; i < l; i += 3) {
+              var x = positions[i];
+              var y = positions[i + 1];
+              var z = positions[i + 2];
+              var morphTargets = geometry.morphAttributes.position;
+
+              if (morphTargets !== undefined) {
+                var morphTargetsRelative = geometry.morphTargetsRelative;
+                var morphInfluences = object.morphTargetInfluences;
+
+                for (var t = 0, tl = morphTargets.length; t < tl; t++) {
+                  var influence = morphInfluences[t];
+                  if (influence === 0) continue;
+                  var target = morphTargets[t];
+
+                  if (morphTargetsRelative) {
+                    x += target.getX(i / 3) * influence;
+                    y += target.getY(i / 3) * influence;
+                    z += target.getZ(i / 3) * influence;
+                  } else {
+                    x += (target.getX(i / 3) - positions[i]) * influence;
+                    y += (target.getY(i / 3) - positions[i + 1]) * influence;
+                    z += (target.getZ(i / 3) - positions[i + 2]) * influence;
+                  }
+                }
+              }
+
+              renderList.pushVertex(x, y, z);
+            }
+
+            if (attributes.normal !== undefined) {
+              var normals = attributes.normal.array;
+
+              for (var _i = 0, _l = normals.length; _i < _l; _i += 3) {
+                renderList.pushNormal(normals[_i], normals[_i + 1], normals[_i + 2]);
+              }
+            }
+
+            if (attributes.color !== undefined) {
+              var colors = attributes.color.array;
+
+              for (var _i2 = 0, _l2 = colors.length; _i2 < _l2; _i2 += 3) {
+                renderList.pushColor(colors[_i2], colors[_i2 + 1], colors[_i2 + 2]);
+              }
+            }
+
+            if (attributes.uv !== undefined) {
+              var uvs = attributes.uv.array;
+
+              for (var _i3 = 0, _l3 = uvs.length; _i3 < _l3; _i3 += 2) {
+                renderList.pushUv(uvs[_i3], uvs[_i3 + 1]);
+              }
+            }
+
+            if (geometry.index !== null) {
+              var indices = geometry.index.array;
+
+              if (groups.length > 0) {
+                for (var g = 0; g < groups.length; g++) {
+                  var group = groups[g];
+                  material = isMultiMaterial === true ? object.material[group.materialIndex] : object.material;
+                  if (material === undefined) continue;
+
+                  for (var _i4 = group.start, _l4 = group.start + group.count; _i4 < _l4; _i4 += 3) {
+                    renderList.pushTriangle(indices[_i4], indices[_i4 + 1], indices[_i4 + 2], material);
+                  }
+                }
+              } else {
+                for (var _i5 = 0, _l5 = indices.length; _i5 < _l5; _i5 += 3) {
+                  renderList.pushTriangle(indices[_i5], indices[_i5 + 1], indices[_i5 + 2], material);
+                }
+              }
+            } else {
+              if (groups.length > 0) {
+                for (var _g = 0; _g < groups.length; _g++) {
+                  var _group = groups[_g];
+                  material = isMultiMaterial === true ? object.material[_group.materialIndex] : object.material;
+                  if (material === undefined) continue;
+
+                  for (var _i6 = _group.start, _l6 = _group.start + _group.count; _i6 < _l6; _i6 += 3) {
+                    renderList.pushTriangle(_i6, _i6 + 1, _i6 + 2, material);
+                  }
+                }
+              } else {
+                for (var _i7 = 0, _l7 = positions.length / 3; _i7 < _l7; _i7 += 3) {
+                  renderList.pushTriangle(_i7, _i7 + 1, _i7 + 2, material);
+                }
+              }
+            }
+          } else if (geometry.isGeometry) {
+            console.error('THREE.Projector no longer supports Geometry. Use THREE.BufferGeometry instead.');
+            return;
+          }
+        } else if (object.isLine) {
+          _modelViewProjectionMatrix.multiplyMatrices(_viewProjectionMatrix, _modelMatrix);
+
+          if (geometry.isBufferGeometry) {
+            var _attributes = geometry.attributes;
+
+            if (_attributes.position !== undefined) {
+              var _positions = _attributes.position.array;
+
+              for (var _i8 = 0, _l8 = _positions.length; _i8 < _l8; _i8 += 3) {
+                renderList.pushVertex(_positions[_i8], _positions[_i8 + 1], _positions[_i8 + 2]);
+              }
+
+              if (_attributes.color !== undefined) {
+                var _colors = _attributes.color.array;
+
+                for (var _i9 = 0, _l9 = _colors.length; _i9 < _l9; _i9 += 3) {
+                  renderList.pushColor(_colors[_i9], _colors[_i9 + 1], _colors[_i9 + 2]);
+                }
+              }
+
+              if (geometry.index !== null) {
+                var _indices = geometry.index.array;
+
+                for (var _i10 = 0, _l10 = _indices.length; _i10 < _l10; _i10 += 2) {
+                  renderList.pushLine(_indices[_i10], _indices[_i10 + 1]);
+                }
+              } else {
+                var step = object.isLineSegments ? 2 : 1;
+
+                for (var _i11 = 0, _l11 = _positions.length / 3 - 1; _i11 < _l11; _i11 += step) {
+                  renderList.pushLine(_i11, _i11 + 1);
+                }
+              }
+            }
+          } else if (geometry.isGeometry) {
+            console.error('THREE.Projector no longer supports Geometry. Use THREE.BufferGeometry instead.');
+            return;
+          }
+        } else if (object.isPoints) {
+          _modelViewProjectionMatrix.multiplyMatrices(_viewProjectionMatrix, _modelMatrix);
+
+          if (geometry.isGeometry) {
+            console.error('THREE.Projector no longer supports Geometry. Use THREE.BufferGeometry instead.');
+            return;
+          } else if (geometry.isBufferGeometry) {
+            var _attributes2 = geometry.attributes;
+
+            if (_attributes2.position !== undefined) {
+              var _positions2 = _attributes2.position.array;
+
+              for (var _i12 = 0, _l12 = _positions2.length; _i12 < _l12; _i12 += 3) {
+                _vector4.set(_positions2[_i12], _positions2[_i12 + 1], _positions2[_i12 + 2], 1);
+
+                _vector4.applyMatrix4(_modelViewProjectionMatrix);
+
+                pushPoint(_vector4, object, camera);
+              }
+            }
+          }
+        } else if (object.isSprite) {
+          object.modelViewMatrix.multiplyMatrices(camera.matrixWorldInverse, object.matrixWorld);
+
+          _vector4.set(_modelMatrix.elements[12], _modelMatrix.elements[13], _modelMatrix.elements[14], 1);
+
+          _vector4.applyMatrix4(_viewProjectionMatrix);
+
+          pushPoint(_vector4, object, camera);
+        }
+      }
+
+      if (sortElements === true) {
+        _renderData.elements.sort(painterSort);
+      }
+
+      return _renderData;
+    };
+
+    function pushPoint(_vector4, object, camera) {
+      var invW = 1 / _vector4.w;
+      _vector4.z *= invW;
+
+      if (_vector4.z >= -1 && _vector4.z <= 1) {
+        _sprite = getNextSpriteInPool();
+        _sprite.id = object.id;
+        _sprite.x = _vector4.x * invW;
+        _sprite.y = _vector4.y * invW;
+        _sprite.z = _vector4.z;
+        _sprite.renderOrder = object.renderOrder;
+        _sprite.object = object;
+        _sprite.rotation = object.rotation;
+        _sprite.scale.x = object.scale.x * Math.abs(_sprite.x - (_vector4.x + camera.projectionMatrix.elements[0]) / (_vector4.w + camera.projectionMatrix.elements[12]));
+        _sprite.scale.y = object.scale.y * Math.abs(_sprite.y - (_vector4.y + camera.projectionMatrix.elements[5]) / (_vector4.w + camera.projectionMatrix.elements[13]));
+        _sprite.material = object.material;
+
+        _renderData.elements.push(_sprite);
+      }
+    } // Pools
+
+
+    function getNextObjectInPool() {
+      if (_objectCount === _objectPoolLength) {
+        var object = new RenderableObject();
+
+        _objectPool.push(object);
+
+        _objectPoolLength++;
+        _objectCount++;
+        return object;
+      }
+
+      return _objectPool[_objectCount++];
+    }
+
+    function getNextVertexInPool() {
+      if (_vertexCount === _vertexPoolLength) {
+        var vertex = new RenderableVertex();
+
+        _vertexPool.push(vertex);
+
+        _vertexPoolLength++;
+        _vertexCount++;
+        return vertex;
+      }
+
+      return _vertexPool[_vertexCount++];
+    }
+
+    function getNextFaceInPool() {
+      if (_faceCount === _facePoolLength) {
+        var face = new RenderableFace();
+
+        _facePool.push(face);
+
+        _facePoolLength++;
+        _faceCount++;
+        return face;
+      }
+
+      return _facePool[_faceCount++];
+    }
+
+    function getNextLineInPool() {
+      if (_lineCount === _linePoolLength) {
+        var line = new RenderableLine();
+
+        _linePool.push(line);
+
+        _linePoolLength++;
+        _lineCount++;
+        return line;
+      }
+
+      return _linePool[_lineCount++];
+    }
+
+    function getNextSpriteInPool() {
+      if (_spriteCount === _spritePoolLength) {
+        var sprite = new RenderableSprite();
+
+        _spritePool.push(sprite);
+
+        _spritePoolLength++;
+        _spriteCount++;
+        return sprite;
+      }
+
+      return _spritePool[_spriteCount++];
+    } //
+
+
+    function painterSort(a, b) {
+      if (a.renderOrder !== b.renderOrder) {
+        return a.renderOrder - b.renderOrder;
+      } else if (a.z !== b.z) {
+        return b.z - a.z;
+      } else if (a.id !== b.id) {
+        return a.id - b.id;
+      } else {
+        return 0;
+      }
+    }
+
+    function clipLine(s1, s2) {
+      var alpha1 = 0,
+          alpha2 = 1; // Calculate the boundary coordinate of each vertex for the near and far clip planes,
+      // Z = -1 and Z = +1, respectively.
+
+      var bc1near = s1.z + s1.w,
+          bc2near = s2.z + s2.w,
+          bc1far = -s1.z + s1.w,
+          bc2far = -s2.z + s2.w;
+
+      if (bc1near >= 0 && bc2near >= 0 && bc1far >= 0 && bc2far >= 0) {
+        // Both vertices lie entirely within all clip planes.
+        return true;
+      } else if (bc1near < 0 && bc2near < 0 || bc1far < 0 && bc2far < 0) {
+        // Both vertices lie entirely outside one of the clip planes.
+        return false;
+      } else {
+        // The line segment spans at least one clip plane.
+        if (bc1near < 0) {
+          // v1 lies outside the near plane, v2 inside
+          alpha1 = Math.max(alpha1, bc1near / (bc1near - bc2near));
+        } else if (bc2near < 0) {
+          // v2 lies outside the near plane, v1 inside
+          alpha2 = Math.min(alpha2, bc1near / (bc1near - bc2near));
+        }
+
+        if (bc1far < 0) {
+          // v1 lies outside the far plane, v2 inside
+          alpha1 = Math.max(alpha1, bc1far / (bc1far - bc2far));
+        } else if (bc2far < 0) {
+          // v2 lies outside the far plane, v2 inside
+          alpha2 = Math.min(alpha2, bc1far / (bc1far - bc2far));
+        }
+
+        if (alpha2 < alpha1) {
+          // The line segment spans two boundaries, but is outside both of them.
+          // (This can't happen when we're only clipping against just near/far but good
+          //  to leave the check here for future usage if other clip planes are added.)
+          return false;
+        } else {
+          // Update the s1 and s2 vertices to match the clipped line segment.
+          s1.lerp(s2, alpha1);
+          s2.lerp(s1, 1 - alpha2);
+          return true;
+        }
+      }
+    }
+  });
+
+  _exports.Projector = Projector;
+});