opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/lines/LineSegments2.js

@@ -0,0 +1,312 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "../lines/LineSegmentsGeometry.js", "../lines/LineMaterial.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("../lines/LineSegmentsGeometry.js"), require("../lines/LineMaterial.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.LineSegmentsGeometry, global.LineMaterial);
+    global.LineSegments2 = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, _LineSegmentsGeometry, _LineMaterial) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.LineSegments2 = void 0;
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  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 _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  var _start = new _three.Vector3();
+
+  var _end = new _three.Vector3();
+
+  var _start4 = new _three.Vector4();
+
+  var _end4 = new _three.Vector4();
+
+  var _ssOrigin = new _three.Vector4();
+
+  var _ssOrigin3 = new _three.Vector3();
+
+  var _mvMatrix = new _three.Matrix4();
+
+  var _line = new _three.Line3();
+
+  var _closestPoint = new _three.Vector3();
+
+  var _box = new _three.Box3();
+
+  var _sphere = new _three.Sphere();
+
+  var _clipToWorldVector = new _three.Vector4(); // Returns the margin required to expand by in world space given the distance from the camera,
+  // line width, resolution, and camera projection
+
+
+  function getWorldSpaceHalfWidth(camera, distance, lineWidth, resolution) {
+    // transform into clip space, adjust the x and y values by the pixel width offset, then
+    // transform back into world space to get world offset. Note clip space is [-1, 1] so full
+    // width does not need to be halved.
+    _clipToWorldVector.set(0, 0, -distance, 1.0).applyMatrix4(camera.projectionMatrix);
+
+    _clipToWorldVector.multiplyScalar(1.0 / _clipToWorldVector.w);
+
+    _clipToWorldVector.x = lineWidth / resolution.width;
+    _clipToWorldVector.y = lineWidth / resolution.height;
+
+    _clipToWorldVector.applyMatrix4(camera.projectionMatrixInverse);
+
+    _clipToWorldVector.multiplyScalar(1.0 / _clipToWorldVector.w);
+
+    return Math.abs(Math.max(_clipToWorldVector.x, _clipToWorldVector.y));
+  }
+
+  var LineSegments2 = /*#__PURE__*/function (_Mesh) {
+    _inherits(LineSegments2, _Mesh);
+
+    var _super = _createSuper(LineSegments2);
+
+    function LineSegments2() {
+      var _this;
+
+      var geometry = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new _LineSegmentsGeometry.LineSegmentsGeometry();
+      var material = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new _LineMaterial.LineMaterial({
+        color: Math.random() * 0xffffff
+      });
+
+      _classCallCheck(this, LineSegments2);
+
+      _this = _super.call(this, geometry, material);
+      _this.type = 'LineSegments2';
+      return _this;
+    } // for backwards-compatability, but could be a method of LineSegmentsGeometry...
+
+
+    _createClass(LineSegments2, [{
+      key: "computeLineDistances",
+      value: function computeLineDistances() {
+        var geometry = this.geometry;
+        var instanceStart = geometry.attributes.instanceStart;
+        var instanceEnd = geometry.attributes.instanceEnd;
+        var lineDistances = new Float32Array(2 * instanceStart.count);
+
+        for (var i = 0, j = 0, l = instanceStart.count; i < l; i++, j += 2) {
+          _start.fromBufferAttribute(instanceStart, i);
+
+          _end.fromBufferAttribute(instanceEnd, i);
+
+          lineDistances[j] = j === 0 ? 0 : lineDistances[j - 1];
+          lineDistances[j + 1] = lineDistances[j] + _start.distanceTo(_end);
+        }
+
+        var instanceDistanceBuffer = new _three.InstancedInterleavedBuffer(lineDistances, 2, 1); // d0, d1
+
+        geometry.setAttribute('instanceDistanceStart', new _three.InterleavedBufferAttribute(instanceDistanceBuffer, 1, 0)); // d0
+
+        geometry.setAttribute('instanceDistanceEnd', new _three.InterleavedBufferAttribute(instanceDistanceBuffer, 1, 1)); // d1
+
+        return this;
+      }
+    }, {
+      key: "raycast",
+      value: function raycast(raycaster, intersects) {
+        if (raycaster.camera === null) {
+          console.error('LineSegments2: "Raycaster.camera" needs to be set in order to raycast against LineSegments2.');
+        }
+
+        var threshold = raycaster.params.Line2 !== undefined ? raycaster.params.Line2.threshold || 0 : 0;
+        var ray = raycaster.ray;
+        var camera = raycaster.camera;
+        var projectionMatrix = camera.projectionMatrix;
+        var matrixWorld = this.matrixWorld;
+        var geometry = this.geometry;
+        var material = this.material;
+        var resolution = material.resolution;
+        var lineWidth = material.linewidth + threshold;
+        var instanceStart = geometry.attributes.instanceStart;
+        var instanceEnd = geometry.attributes.instanceEnd; // camera forward is negative
+
+        var near = -camera.near; //
+        // check if we intersect the sphere bounds
+
+        if (geometry.boundingSphere === null) {
+          geometry.computeBoundingSphere();
+        }
+
+        _sphere.copy(geometry.boundingSphere).applyMatrix4(matrixWorld);
+
+        var distanceToSphere = Math.max(camera.near, _sphere.distanceToPoint(ray.origin)); // increase the sphere bounds by the worst case line screen space width
+
+        var sphereMargin = getWorldSpaceHalfWidth(camera, distanceToSphere, lineWidth, resolution);
+        _sphere.radius += sphereMargin;
+
+        if (raycaster.ray.intersectsSphere(_sphere) === false) {
+          return;
+        } //
+        // check if we intersect the box bounds
+
+
+        if (geometry.boundingBox === null) {
+          geometry.computeBoundingBox();
+        }
+
+        _box.copy(geometry.boundingBox).applyMatrix4(matrixWorld);
+
+        var distanceToBox = Math.max(camera.near, _box.distanceToPoint(ray.origin)); // increase the box bounds by the worst case line screen space width
+
+        var boxMargin = getWorldSpaceHalfWidth(camera, distanceToBox, lineWidth, resolution);
+        _box.max.x += boxMargin;
+        _box.max.y += boxMargin;
+        _box.max.z += boxMargin;
+        _box.min.x -= boxMargin;
+        _box.min.y -= boxMargin;
+        _box.min.z -= boxMargin;
+
+        if (raycaster.ray.intersectsBox(_box) === false) {
+          return;
+        } //
+        // pick a point 1 unit out along the ray to avoid the ray origin
+        // sitting at the camera origin which will cause "w" to be 0 when
+        // applying the projection matrix.
+
+
+        ray.at(1, _ssOrigin); // ndc space [ - 1.0, 1.0 ]
+
+        _ssOrigin.w = 1;
+
+        _ssOrigin.applyMatrix4(camera.matrixWorldInverse);
+
+        _ssOrigin.applyMatrix4(projectionMatrix);
+
+        _ssOrigin.multiplyScalar(1 / _ssOrigin.w); // screen space
+
+
+        _ssOrigin.x *= resolution.x / 2;
+        _ssOrigin.y *= resolution.y / 2;
+        _ssOrigin.z = 0;
+
+        _ssOrigin3.copy(_ssOrigin);
+
+        _mvMatrix.multiplyMatrices(camera.matrixWorldInverse, matrixWorld);
+
+        for (var i = 0, l = instanceStart.count; i < l; i++) {
+          _start4.fromBufferAttribute(instanceStart, i);
+
+          _end4.fromBufferAttribute(instanceEnd, i);
+
+          _start4.w = 1;
+          _end4.w = 1; // camera space
+
+          _start4.applyMatrix4(_mvMatrix);
+
+          _end4.applyMatrix4(_mvMatrix); // skip the segment if it's entirely behind the camera
+
+
+          var isBehindCameraNear = _start4.z > near && _end4.z > near;
+
+          if (isBehindCameraNear) {
+            continue;
+          } // trim the segment if it extends behind camera near
+
+
+          if (_start4.z > near) {
+            var deltaDist = _start4.z - _end4.z;
+            var t = (_start4.z - near) / deltaDist;
+
+            _start4.lerp(_end4, t);
+          } else if (_end4.z > near) {
+            var _deltaDist = _end4.z - _start4.z;
+
+            var _t = (_end4.z - near) / _deltaDist;
+
+            _end4.lerp(_start4, _t);
+          } // clip space
+
+
+          _start4.applyMatrix4(projectionMatrix);
+
+          _end4.applyMatrix4(projectionMatrix); // ndc space [ - 1.0, 1.0 ]
+
+
+          _start4.multiplyScalar(1 / _start4.w);
+
+          _end4.multiplyScalar(1 / _end4.w); // screen space
+
+
+          _start4.x *= resolution.x / 2;
+          _start4.y *= resolution.y / 2;
+          _end4.x *= resolution.x / 2;
+          _end4.y *= resolution.y / 2; // create 2d segment
+
+          _line.start.copy(_start4);
+
+          _line.start.z = 0;
+
+          _line.end.copy(_end4);
+
+          _line.end.z = 0; // get closest point on ray to segment
+
+          var param = _line.closestPointToPointParameter(_ssOrigin3, true);
+
+          _line.at(param, _closestPoint); // check if the intersection point is within clip space
+
+
+          var zPos = _three.MathUtils.lerp(_start4.z, _end4.z, param);
+
+          var isInClipSpace = zPos >= -1 && zPos <= 1;
+          var isInside = _ssOrigin3.distanceTo(_closestPoint) < lineWidth * 0.5;
+
+          if (isInClipSpace && isInside) {
+            _line.start.fromBufferAttribute(instanceStart, i);
+
+            _line.end.fromBufferAttribute(instanceEnd, i);
+
+            _line.start.applyMatrix4(matrixWorld);
+
+            _line.end.applyMatrix4(matrixWorld);
+
+            var pointOnLine = new _three.Vector3();
+            var point = new _three.Vector3();
+            ray.distanceSqToSegment(_line.start, _line.end, point, pointOnLine);
+            intersects.push({
+              point: point,
+              pointOnLine: pointOnLine,
+              distance: ray.origin.distanceTo(point),
+              object: this,
+              face: null,
+              faceIndex: i,
+              uv: null,
+              uv2: null
+            });
+          }
+        }
+      }
+    }]);
+
+    return LineSegments2;
+  }(_three.Mesh);
+
+  _exports.LineSegments2 = LineSegments2;
+  LineSegments2.prototype.isLineSegments2 = true;
+});

data/lib-opal/js_wrap/three/lines/LineSegmentsGeometry.js

@@ -0,0 +1,238 @@
+(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.LineSegmentsGeometry = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.LineSegmentsGeometry = void 0;
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  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 _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  var _box = new _three.Box3();
+
+  var _vector = new _three.Vector3();
+
+  var LineSegmentsGeometry = /*#__PURE__*/function (_InstancedBufferGeome) {
+    _inherits(LineSegmentsGeometry, _InstancedBufferGeome);
+
+    var _super = _createSuper(LineSegmentsGeometry);
+
+    function LineSegmentsGeometry() {
+      var _this;
+
+      _classCallCheck(this, LineSegmentsGeometry);
+
+      _this = _super.call(this);
+      _this.type = 'LineSegmentsGeometry';
+      var positions = [-1, 2, 0, 1, 2, 0, -1, 1, 0, 1, 1, 0, -1, 0, 0, 1, 0, 0, -1, -1, 0, 1, -1, 0];
+      var uvs = [-1, 2, 1, 2, -1, 1, 1, 1, -1, -1, 1, -1, -1, -2, 1, -2];
+      var index = [0, 2, 1, 2, 3, 1, 2, 4, 3, 4, 5, 3, 4, 6, 5, 6, 7, 5];
+
+      _this.setIndex(index);
+
+      _this.setAttribute('position', new _three.Float32BufferAttribute(positions, 3));
+
+      _this.setAttribute('uv', new _three.Float32BufferAttribute(uvs, 2));
+
+      return _this;
+    }
+
+    _createClass(LineSegmentsGeometry, [{
+      key: "applyMatrix4",
+      value: function applyMatrix4(matrix) {
+        var start = this.attributes.instanceStart;
+        var end = this.attributes.instanceEnd;
+
+        if (start !== undefined) {
+          start.applyMatrix4(matrix);
+          end.applyMatrix4(matrix);
+          start.needsUpdate = true;
+        }
+
+        if (this.boundingBox !== null) {
+          this.computeBoundingBox();
+        }
+
+        if (this.boundingSphere !== null) {
+          this.computeBoundingSphere();
+        }
+
+        return this;
+      }
+    }, {
+      key: "setPositions",
+      value: function setPositions(array) {
+        var lineSegments;
+
+        if (array instanceof Float32Array) {
+          lineSegments = array;
+        } else if (Array.isArray(array)) {
+          lineSegments = new Float32Array(array);
+        }
+
+        var instanceBuffer = new _three.InstancedInterleavedBuffer(lineSegments, 6, 1); // xyz, xyz
+
+        this.setAttribute('instanceStart', new _three.InterleavedBufferAttribute(instanceBuffer, 3, 0)); // xyz
+
+        this.setAttribute('instanceEnd', new _three.InterleavedBufferAttribute(instanceBuffer, 3, 3)); // xyz
+        //
+
+        this.computeBoundingBox();
+        this.computeBoundingSphere();
+        return this;
+      }
+    }, {
+      key: "setColors",
+      value: function setColors(array) {
+        var colors;
+
+        if (array instanceof Float32Array) {
+          colors = array;
+        } else if (Array.isArray(array)) {
+          colors = new Float32Array(array);
+        }
+
+        var instanceColorBuffer = new _three.InstancedInterleavedBuffer(colors, 6, 1); // rgb, rgb
+
+        this.setAttribute('instanceColorStart', new _three.InterleavedBufferAttribute(instanceColorBuffer, 3, 0)); // rgb
+
+        this.setAttribute('instanceColorEnd', new _three.InterleavedBufferAttribute(instanceColorBuffer, 3, 3)); // rgb
+
+        return this;
+      }
+    }, {
+      key: "fromWireframeGeometry",
+      value: function fromWireframeGeometry(geometry) {
+        this.setPositions(geometry.attributes.position.array);
+        return this;
+      }
+    }, {
+      key: "fromEdgesGeometry",
+      value: function fromEdgesGeometry(geometry) {
+        this.setPositions(geometry.attributes.position.array);
+        return this;
+      }
+    }, {
+      key: "fromMesh",
+      value: function fromMesh(mesh) {
+        this.fromWireframeGeometry(new _three.WireframeGeometry(mesh.geometry)); // set colors, maybe
+
+        return this;
+      }
+    }, {
+      key: "fromLineSegments",
+      value: function fromLineSegments(lineSegments) {
+        var geometry = lineSegments.geometry;
+
+        if (geometry.isGeometry) {
+          console.error('THREE.LineSegmentsGeometry no longer supports Geometry. Use THREE.BufferGeometry instead.');
+          return;
+        } else if (geometry.isBufferGeometry) {
+          this.setPositions(geometry.attributes.position.array); // assumes non-indexed
+        } // set colors, maybe
+
+
+        return this;
+      }
+    }, {
+      key: "computeBoundingBox",
+      value: function computeBoundingBox() {
+        if (this.boundingBox === null) {
+          this.boundingBox = new _three.Box3();
+        }
+
+        var start = this.attributes.instanceStart;
+        var end = this.attributes.instanceEnd;
+
+        if (start !== undefined && end !== undefined) {
+          this.boundingBox.setFromBufferAttribute(start);
+
+          _box.setFromBufferAttribute(end);
+
+          this.boundingBox.union(_box);
+        }
+      }
+    }, {
+      key: "computeBoundingSphere",
+      value: function computeBoundingSphere() {
+        if (this.boundingSphere === null) {
+          this.boundingSphere = new _three.Sphere();
+        }
+
+        if (this.boundingBox === null) {
+          this.computeBoundingBox();
+        }
+
+        var start = this.attributes.instanceStart;
+        var end = this.attributes.instanceEnd;
+
+        if (start !== undefined && end !== undefined) {
+          var center = this.boundingSphere.center;
+          this.boundingBox.getCenter(center);
+          var maxRadiusSq = 0;
+
+          for (var i = 0, il = start.count; i < il; i++) {
+            _vector.fromBufferAttribute(start, i);
+
+            maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(_vector));
+
+            _vector.fromBufferAttribute(end, i);
+
+            maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(_vector));
+          }
+
+          this.boundingSphere.radius = Math.sqrt(maxRadiusSq);
+
+          if (isNaN(this.boundingSphere.radius)) {
+            console.error('THREE.LineSegmentsGeometry.computeBoundingSphere(): Computed radius is NaN. The instanced position data is likely to have NaN values.', this);
+          }
+        }
+      }
+    }, {
+      key: "toJSON",
+      value: function toJSON() {// todo
+      }
+    }, {
+      key: "applyMatrix",
+      value: function applyMatrix(matrix) {
+        console.warn('THREE.LineSegmentsGeometry: applyMatrix() has been renamed to applyMatrix4().');
+        return this.applyMatrix4(matrix);
+      }
+    }]);
+
+    return LineSegmentsGeometry;
+  }(_three.InstancedBufferGeometry);
+
+  _exports.LineSegmentsGeometry = LineSegmentsGeometry;
+  LineSegmentsGeometry.prototype.isLineSegmentsGeometry = true;
+});

data/lib-opal/js_wrap/three/lines/Wireframe.js

@@ -0,0 +1,98 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "../lines/LineSegmentsGeometry.js", "../lines/LineMaterial.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("../lines/LineSegmentsGeometry.js"), require("../lines/LineMaterial.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.LineSegmentsGeometry, global.LineMaterial);
+    global.Wireframe = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, _LineSegmentsGeometry, _LineMaterial) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.Wireframe = void 0;
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  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 _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  var _start = new _three.Vector3();
+
+  var _end = new _three.Vector3();
+
+  var Wireframe = /*#__PURE__*/function (_Mesh) {
+    _inherits(Wireframe, _Mesh);
+
+    var _super = _createSuper(Wireframe);
+
+    function Wireframe() {
+      var _this;
+
+      var geometry = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new _LineSegmentsGeometry.LineSegmentsGeometry();
+      var material = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new _LineMaterial.LineMaterial({
+        color: Math.random() * 0xffffff
+      });
+
+      _classCallCheck(this, Wireframe);
+
+      _this = _super.call(this, geometry, material);
+      _this.type = 'Wireframe';
+      return _this;
+    } // for backwards-compatability, but could be a method of LineSegmentsGeometry...
+
+
+    _createClass(Wireframe, [{
+      key: "computeLineDistances",
+      value: function computeLineDistances() {
+        var geometry = this.geometry;
+        var instanceStart = geometry.attributes.instanceStart;
+        var instanceEnd = geometry.attributes.instanceEnd;
+        var lineDistances = new Float32Array(2 * instanceStart.count);
+
+        for (var i = 0, j = 0, l = instanceStart.count; i < l; i++, j += 2) {
+          _start.fromBufferAttribute(instanceStart, i);
+
+          _end.fromBufferAttribute(instanceEnd, i);
+
+          lineDistances[j] = j === 0 ? 0 : lineDistances[j - 1];
+          lineDistances[j + 1] = lineDistances[j] + _start.distanceTo(_end);
+        }
+
+        var instanceDistanceBuffer = new _three.InstancedInterleavedBuffer(lineDistances, 2, 1); // d0, d1
+
+        geometry.setAttribute('instanceDistanceStart', new _three.InterleavedBufferAttribute(instanceDistanceBuffer, 1, 0)); // d0
+
+        geometry.setAttribute('instanceDistanceEnd', new _three.InterleavedBufferAttribute(instanceDistanceBuffer, 1, 1)); // d1
+
+        return this;
+      }
+    }]);
+
+    return Wireframe;
+  }(_three.Mesh);
+
+  _exports.Wireframe = Wireframe;
+  Wireframe.prototype.isWireframe = true;
+});