opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/modifiers/CurveModifier.js

@@ -0,0 +1,291 @@
+(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.CurveModifier = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.InstancedFlow = _exports.Flow = void 0;
+  _exports.getUniforms = getUniforms;
+  _exports.initSplineTexture = initSplineTexture;
+  _exports.modifyShader = modifyShader;
+  _exports.updateSplineTexture = updateSplineTexture;
+
+  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); }
+
+  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; }
+
+  // Original src: https://github.com/zz85/threejs-path-flow
+  var BITS = 3;
+  var TEXTURE_WIDTH = 1024;
+  var TEXTURE_HEIGHT = 4;
+
+  /**
+   * Make a new DataTexture to store the descriptions of the curves.
+   *
+   * @param { number } numberOfCurves the number of curves needed to be described by this texture.
+   */
+  function initSplineTexture() {
+    var numberOfCurves = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+    var dataArray = new Float32Array(TEXTURE_WIDTH * TEXTURE_HEIGHT * numberOfCurves * BITS);
+    var dataTexture = new _three.DataTexture(dataArray, TEXTURE_WIDTH, TEXTURE_HEIGHT * numberOfCurves, _three.RGBFormat, _three.FloatType);
+    dataTexture.wrapS = _three.RepeatWrapping;
+    dataTexture.wrapY = _three.RepeatWrapping;
+    dataTexture.magFilter = _three.NearestFilter;
+    dataTexture.needsUpdate = true;
+    return dataTexture;
+  }
+  /**
+   * Write the curve description to the data texture
+   *
+   * @param { DataTexture } texture The DataTexture to write to
+   * @param { Curve } splineCurve The curve to describe
+   * @param { number } offset Which curve slot to write to
+   */
+
+
+  function updateSplineTexture(texture, splineCurve) {
+    var offset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    var numberOfPoints = Math.floor(TEXTURE_WIDTH * (TEXTURE_HEIGHT / 4));
+    splineCurve.arcLengthDivisions = numberOfPoints / 2;
+    splineCurve.updateArcLengths();
+    var points = splineCurve.getSpacedPoints(numberOfPoints);
+    var frenetFrames = splineCurve.computeFrenetFrames(numberOfPoints, true);
+
+    for (var i = 0; i < numberOfPoints; i++) {
+      var rowOffset = Math.floor(i / TEXTURE_WIDTH);
+      var rowIndex = i % TEXTURE_WIDTH;
+      var pt = points[i];
+      setTextureValue(texture, rowIndex, pt.x, pt.y, pt.z, 0 + rowOffset + TEXTURE_HEIGHT * offset);
+      pt = frenetFrames.tangents[i];
+      setTextureValue(texture, rowIndex, pt.x, pt.y, pt.z, 1 + rowOffset + TEXTURE_HEIGHT * offset);
+      pt = frenetFrames.normals[i];
+      setTextureValue(texture, rowIndex, pt.x, pt.y, pt.z, 2 + rowOffset + TEXTURE_HEIGHT * offset);
+      pt = frenetFrames.binormals[i];
+      setTextureValue(texture, rowIndex, pt.x, pt.y, pt.z, 3 + rowOffset + TEXTURE_HEIGHT * offset);
+    }
+
+    texture.needsUpdate = true;
+  }
+
+  function setTextureValue(texture, index, x, y, z, o) {
+    var image = texture.image;
+    var data = image.data;
+    var i = BITS * TEXTURE_WIDTH * o; // Row Offset
+
+    data[index * BITS + i + 0] = x;
+    data[index * BITS + i + 1] = y;
+    data[index * BITS + i + 2] = z;
+  }
+  /**
+   * Create a new set of uniforms for describing the curve modifier
+   *
+   * @param { DataTexture } Texture which holds the curve description
+   */
+
+
+  function getUniforms(splineTexture) {
+    var uniforms = {
+      spineTexture: {
+        value: splineTexture
+      },
+      pathOffset: {
+        type: 'f',
+        value: 0
+      },
+      // time of path curve
+      pathSegment: {
+        type: 'f',
+        value: 1
+      },
+      // fractional length of path
+      spineOffset: {
+        type: 'f',
+        value: 161
+      },
+      spineLength: {
+        type: 'f',
+        value: 400
+      },
+      flow: {
+        type: 'i',
+        value: 1
+      }
+    };
+    return uniforms;
+  }
+
+  function modifyShader(material, uniforms) {
+    var numberOfCurves = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+    if (material.__ok) return;
+    material.__ok = true;
+
+    material.onBeforeCompile = function (shader) {
+      if (shader.__modified) return;
+      shader.__modified = true;
+      Object.assign(shader.uniforms, uniforms);
+      var vertexShader = "\n\t\tuniform sampler2D spineTexture;\n\t\tuniform float pathOffset;\n\t\tuniform float pathSegment;\n\t\tuniform float spineOffset;\n\t\tuniform float spineLength;\n\t\tuniform int flow;\n\n\t\tfloat textureLayers = ".concat(TEXTURE_HEIGHT * numberOfCurves, ".;\n\t\tfloat textureStacks = ").concat(TEXTURE_HEIGHT / 4, ".;\n\n\t\t").concat(shader.vertexShader, "\n\t\t") // chunk import moved in front of modified shader below
+      .replace('#include <beginnormal_vertex>', '') // vec3 transformedNormal declaration overriden below
+      .replace('#include <defaultnormal_vertex>', '') // vec3 transformed declaration overriden below
+      .replace('#include <begin_vertex>', '') // shader override
+      .replace(/void\s*main\s*\(\)\s*\{/, "\nvoid main() {\n#include <beginnormal_vertex>\n\nvec4 worldPos = modelMatrix * vec4(position, 1.);\n\nbool bend = flow > 0;\nfloat xWeight = bend ? 0. : 1.;\n\n#ifdef USE_INSTANCING\nfloat pathOffsetFromInstanceMatrix = instanceMatrix[3][2];\nfloat spineLengthFromInstanceMatrix = instanceMatrix[3][0];\nfloat spinePortion = bend ? (worldPos.x + spineOffset) / spineLengthFromInstanceMatrix : 0.;\nfloat mt = (spinePortion * pathSegment + pathOffset + pathOffsetFromInstanceMatrix)*textureStacks;\n#else\nfloat spinePortion = bend ? (worldPos.x + spineOffset) / spineLength : 0.;\nfloat mt = (spinePortion * pathSegment + pathOffset)*textureStacks;\n#endif\n\nmt = mod(mt, textureStacks);\nfloat rowOffset = floor(mt);\n\n#ifdef USE_INSTANCING\nrowOffset += instanceMatrix[3][1] * ".concat(TEXTURE_HEIGHT, ".;\n#endif\n\nvec3 spinePos = texture2D(spineTexture, vec2(mt, (0. + rowOffset + 0.5) / textureLayers)).xyz;\nvec3 a =        texture2D(spineTexture, vec2(mt, (1. + rowOffset + 0.5) / textureLayers)).xyz;\nvec3 b =        texture2D(spineTexture, vec2(mt, (2. + rowOffset + 0.5) / textureLayers)).xyz;\nvec3 c =        texture2D(spineTexture, vec2(mt, (3. + rowOffset + 0.5) / textureLayers)).xyz;\nmat3 basis = mat3(a, b, c);\n\nvec3 transformed = basis\n\t* vec3(worldPos.x * xWeight, worldPos.y * 1., worldPos.z * 1.)\n\t+ spinePos;\n\nvec3 transformedNormal = normalMatrix * (basis * objectNormal);\n\t\t\t")).replace('#include <project_vertex>', "vec4 mvPosition = modelViewMatrix * vec4( transformed, 1.0 );\n\t\t\t\tgl_Position = projectionMatrix * mvPosition;");
+      shader.vertexShader = vertexShader;
+    };
+  }
+  /**
+   * A helper class for making meshes bend aroudn curves
+   */
+
+
+  var Flow = /*#__PURE__*/function () {
+    /**
+     * @param {Mesh} mesh The mesh to clone and modify to bend around the curve
+     * @param {number} numberOfCurves The amount of space that should preallocated for additional curves
+     */
+    function Flow(mesh) {
+      var numberOfCurves = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+
+      _classCallCheck(this, Flow);
+
+      var obj3D = mesh.clone();
+      var splineTexure = initSplineTexture(numberOfCurves);
+      var uniforms = getUniforms(splineTexure);
+      obj3D.traverse(function (child) {
+        if (child instanceof _three.Mesh || child instanceof _three.InstancedMesh) {
+          child.material = child.material.clone();
+          modifyShader(child.material, uniforms, numberOfCurves);
+        }
+      });
+      this.curveArray = new Array(numberOfCurves);
+      this.curveLengthArray = new Array(numberOfCurves);
+      this.object3D = obj3D;
+      this.splineTexure = splineTexure;
+      this.uniforms = uniforms;
+    }
+
+    _createClass(Flow, [{
+      key: "updateCurve",
+      value: function updateCurve(index, curve) {
+        if (index >= this.curveArray.length) throw Error('Index out of range for Flow');
+        var curveLength = curve.getLength();
+        this.uniforms.spineLength.value = curveLength;
+        this.curveLengthArray[index] = curveLength;
+        this.curveArray[index] = curve;
+        updateSplineTexture(this.splineTexure, curve, index);
+      }
+    }, {
+      key: "moveAlongCurve",
+      value: function moveAlongCurve(amount) {
+        this.uniforms.pathOffset.value += amount;
+      }
+    }]);
+
+    return Flow;
+  }();
+
+  _exports.Flow = Flow;
+  var matrix = new _three.Matrix4();
+  /**
+   * A helper class for creating instanced versions of flow, where the instances are placed on the curve.
+   */
+
+  var InstancedFlow = /*#__PURE__*/function (_Flow) {
+    _inherits(InstancedFlow, _Flow);
+
+    var _super = _createSuper(InstancedFlow);
+
+    /**
+     *
+     * @param {number} count The number of instanced elements
+     * @param {number} curveCount The number of curves to preallocate for
+     * @param {Geometry} geometry The geometry to use for the instanced mesh
+     * @param {Material} material The material to use for the instanced mesh
+     */
+    function InstancedFlow(count, curveCount, geometry, material) {
+      var _this;
+
+      _classCallCheck(this, InstancedFlow);
+
+      var mesh = new _three.InstancedMesh(geometry, material, count);
+      mesh.instanceMatrix.setUsage(_three.DynamicDrawUsage);
+      _this = _super.call(this, mesh, curveCount);
+      _this.offsets = new Array(count).fill(0);
+      _this.whichCurve = new Array(count).fill(0);
+      return _this;
+    }
+    /**
+     * The extra information about which curve and curve position is stored in the translation components of the matrix for the instanced objects
+     * This writes that information to the matrix and marks it as needing update.
+     *
+     * @param {number} index of the instanced element to update
+     */
+
+
+    _createClass(InstancedFlow, [{
+      key: "writeChanges",
+      value: function writeChanges(index) {
+        matrix.makeTranslation(this.curveLengthArray[this.whichCurve[index]], this.whichCurve[index], this.offsets[index]);
+        this.object3D.setMatrixAt(index, matrix);
+        this.object3D.instanceMatrix.needsUpdate = true;
+      }
+      /**
+       * Move an individual element along the curve by a specific amount
+       *
+       * @param {number} index Which element to update
+       * @param {number} offset Move by how much
+       */
+
+    }, {
+      key: "moveIndividualAlongCurve",
+      value: function moveIndividualAlongCurve(index, offset) {
+        this.offsets[index] += offset;
+        this.writeChanges(index);
+      }
+      /**
+       * Select which curve to use for an element
+       *
+       * @param {number} index the index of the instanced element to update
+       * @param {number} curveNo the index of the curve it should use
+       */
+
+    }, {
+      key: "setCurve",
+      value: function setCurve(index, curveNo) {
+        if (isNaN(curveNo)) throw Error('curve index being set is Not a Number (NaN)');
+        this.whichCurve[index] = curveNo;
+        this.writeChanges(index);
+      }
+    }]);
+
+    return InstancedFlow;
+  }(Flow);
+
+  _exports.InstancedFlow = InstancedFlow;
+});

data/lib-opal/js_wrap/three/modifiers/EdgeSplitModifier.js

@@ -0,0 +1,308 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "../utils/BufferGeometryUtils.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("../utils/BufferGeometryUtils.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.BufferGeometryUtils);
+    global.EdgeSplitModifier = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, BufferGeometryUtils) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.EdgeSplitModifier = void 0;
+  BufferGeometryUtils = _interopRequireWildcard(BufferGeometryUtils);
+
+  function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+  function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+  function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+  function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+  function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+  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; }
+
+  var _A = new _three.Vector3();
+
+  var _B = new _three.Vector3();
+
+  var _C = new _three.Vector3();
+
+  var EdgeSplitModifier = /*#__PURE__*/function () {
+    function EdgeSplitModifier() {
+      _classCallCheck(this, EdgeSplitModifier);
+    }
+
+    _createClass(EdgeSplitModifier, [{
+      key: "modify",
+      value: function modify(geometry, cutOffAngle) {
+        var tryKeepNormals = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+
+        function computeNormals() {
+          normals = new Float32Array(indexes.length * 3);
+
+          for (var i = 0; i < indexes.length; i += 3) {
+            var index = indexes[i];
+
+            _A.set(positions[3 * index], positions[3 * index + 1], positions[3 * index + 2]);
+
+            index = indexes[i + 1];
+
+            _B.set(positions[3 * index], positions[3 * index + 1], positions[3 * index + 2]);
+
+            index = indexes[i + 2];
+
+            _C.set(positions[3 * index], positions[3 * index + 1], positions[3 * index + 2]);
+
+            _C.sub(_B);
+
+            _A.sub(_B);
+
+            var normal = _C.cross(_A).normalize();
+
+            for (var j = 0; j < 3; j++) {
+              normals[3 * (i + j)] = normal.x;
+              normals[3 * (i + j) + 1] = normal.y;
+              normals[3 * (i + j) + 2] = normal.z;
+            }
+          }
+        }
+
+        function mapPositionsToIndexes() {
+          pointToIndexMap = Array(positions.length / 3);
+
+          for (var i = 0; i < indexes.length; i++) {
+            var index = indexes[i];
+
+            if (pointToIndexMap[index] == null) {
+              pointToIndexMap[index] = [];
+            }
+
+            pointToIndexMap[index].push(i);
+          }
+        }
+
+        function edgeSplitToGroups(indexes, cutOff, firstIndex) {
+          _A.set(normals[3 * firstIndex], normals[3 * firstIndex + 1], normals[3 * firstIndex + 2]).normalize();
+
+          var result = {
+            splitGroup: [],
+            currentGroup: [firstIndex]
+          };
+
+          var _iterator = _createForOfIteratorHelper(indexes),
+              _step;
+
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              var j = _step.value;
+
+              if (j !== firstIndex) {
+                _B.set(normals[3 * j], normals[3 * j + 1], normals[3 * j + 2]).normalize();
+
+                if (_B.dot(_A) < cutOff) {
+                  result.splitGroup.push(j);
+                } else {
+                  result.currentGroup.push(j);
+                }
+              }
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+
+          return result;
+        }
+
+        function edgeSplit(indexes, cutOff) {
+          var original = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+          if (indexes.length === 0) return;
+          var groupResults = [];
+
+          var _iterator2 = _createForOfIteratorHelper(indexes),
+              _step2;
+
+          try {
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              var index = _step2.value;
+              groupResults.push(edgeSplitToGroups(indexes, cutOff, index));
+            }
+          } catch (err) {
+            _iterator2.e(err);
+          } finally {
+            _iterator2.f();
+          }
+
+          var result = groupResults[0];
+
+          for (var _i = 0, _groupResults = groupResults; _i < _groupResults.length; _i++) {
+            var groupResult = _groupResults[_i];
+
+            if (groupResult.currentGroup.length > result.currentGroup.length) {
+              result = groupResult;
+            }
+          }
+
+          if (original != null) {
+            splitIndexes.push({
+              original: original,
+              indexes: result.currentGroup
+            });
+          }
+
+          if (result.splitGroup.length) {
+            edgeSplit(result.splitGroup, cutOff, original || result.currentGroup[0]);
+          }
+        }
+
+        if (geometry.isGeometry === true) {
+          console.error('THREE.EdgeSplitModifier no longer supports THREE.Geometry. Use BufferGeometry instead.');
+          return;
+        }
+
+        var hadNormals = false;
+        var oldNormals = null;
+
+        if (geometry.attributes.normal) {
+          hadNormals = true;
+          geometry = geometry.clone();
+
+          if (tryKeepNormals === true && geometry.index !== null) {
+            oldNormals = geometry.attributes.normal.array;
+          }
+
+          geometry.deleteAttribute('normal');
+        }
+
+        if (geometry.index == null) {
+          if (BufferGeometryUtils === undefined) {
+            throw 'THREE.EdgeSplitModifier relies on BufferGeometryUtils';
+          }
+
+          geometry = BufferGeometryUtils.mergeVertices(geometry);
+        }
+
+        var indexes = geometry.index.array;
+        var positions = geometry.getAttribute('position').array;
+        var normals;
+        var pointToIndexMap;
+        computeNormals();
+        mapPositionsToIndexes();
+        var splitIndexes = [];
+
+        var _iterator3 = _createForOfIteratorHelper(pointToIndexMap),
+            _step3;
+
+        try {
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var vertexIndexes = _step3.value;
+            edgeSplit(vertexIndexes, Math.cos(cutOffAngle) - 0.001);
+          }
+        } catch (err) {
+          _iterator3.e(err);
+        } finally {
+          _iterator3.f();
+        }
+
+        var newAttributes = {};
+
+        for (var _i2 = 0, _Object$keys = Object.keys(geometry.attributes); _i2 < _Object$keys.length; _i2++) {
+          var name = _Object$keys[_i2];
+          var oldAttribute = geometry.attributes[name];
+          var newArray = new oldAttribute.array.constructor((indexes.length + splitIndexes.length) * oldAttribute.itemSize);
+          newArray.set(oldAttribute.array);
+          newAttributes[name] = new _three.BufferAttribute(newArray, oldAttribute.itemSize, oldAttribute.normalized);
+        }
+
+        var newIndexes = new Uint32Array(indexes.length);
+        newIndexes.set(indexes);
+
+        for (var i = 0; i < splitIndexes.length; i++) {
+          var split = splitIndexes[i];
+          var index = indexes[split.original];
+
+          for (var _i3 = 0, _Object$values = Object.values(newAttributes); _i3 < _Object$values.length; _i3++) {
+            var attribute = _Object$values[_i3];
+
+            for (var j = 0; j < attribute.itemSize; j++) {
+              attribute.array[(indexes.length + i) * attribute.itemSize + j] = attribute.array[index * attribute.itemSize + j];
+            }
+          }
+
+          var _iterator4 = _createForOfIteratorHelper(split.indexes),
+              _step4;
+
+          try {
+            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+              var _j = _step4.value;
+              newIndexes[_j] = indexes.length + i;
+            }
+          } catch (err) {
+            _iterator4.e(err);
+          } finally {
+            _iterator4.f();
+          }
+        }
+
+        geometry = new _three.BufferGeometry();
+        geometry.setIndex(new _three.BufferAttribute(newIndexes, 1));
+
+        for (var _i4 = 0, _Object$keys2 = Object.keys(newAttributes); _i4 < _Object$keys2.length; _i4++) {
+          var _name = _Object$keys2[_i4];
+          geometry.setAttribute(_name, newAttributes[_name]);
+        }
+
+        if (hadNormals) {
+          geometry.computeVertexNormals();
+
+          if (oldNormals !== null) {
+            var changedNormals = new Array(oldNormals.length / 3).fill(false);
+
+            var _iterator5 = _createForOfIteratorHelper(splitIndexes),
+                _step5;
+
+            try {
+              for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+                var splitData = _step5.value;
+                changedNormals[splitData.original] = true;
+              }
+            } catch (err) {
+              _iterator5.e(err);
+            } finally {
+              _iterator5.f();
+            }
+
+            for (var _i5 = 0; _i5 < changedNormals.length; _i5++) {
+              if (changedNormals[_i5] === false) {
+                for (var _j2 = 0; _j2 < 3; _j2++) {
+                  geometry.attributes.normal.array[3 * _i5 + _j2] = oldNormals[3 * _i5 + _j2];
+                }
+              }
+            }
+          }
+        }
+
+        return geometry;
+      }
+    }]);
+
+    return EdgeSplitModifier;
+  }();
+
+  _exports.EdgeSplitModifier = EdgeSplitModifier;
+});