opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/geometries/LightningStrike.js

@@ -0,0 +1,817 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "../math/SimplexNoise.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("../math/SimplexNoise.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.SimplexNoise);
+    global.LightningStrike = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, _SimplexNoise) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.LightningStrike = 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 _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
+
+  function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+  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); }
+
+  /**
+   * @fileoverview LightningStrike object for creating lightning strikes and voltaic arcs.
+   *
+   *
+   * Usage
+   *
+   * var myRay = new LightningStrike( paramsObject );
+   * var myRayMesh = new THREE.Mesh( myRay, myMaterial );
+   * scene.add( myRayMesh );
+   * ...
+   * myRay.update( currentTime );
+   *
+   * The "currentTime" can vary its rate, go forwards, backwards or even jump, but it cannot be negative.
+   *
+   * You should normally leave the ray position to (0, 0, 0). You should control it by changing the sourceOffset and destOffset parameters.
+   *
+   *
+   * LightningStrike parameters
+   *
+   * The paramsObject can contain any of the following parameters.
+   *
+   * Legend:
+   * 'LightningStrike' (also called 'ray'): An independent voltaic arc with its ramifications and defined with a set of parameters.
+   * 'Subray': A ramification of the ray. It is not a LightningStrike object.
+   * 'Segment': A linear segment piece of a subray.
+   * 'Leaf segment': A ray segment which cannot be smaller.
+   *
+   *
+   * The following parameters can be changed any time and if they vary smoothly, the ray form will also change smoothly:
+   *
+   * @param {Vector3} sourceOffset The point where the ray starts.
+   *
+   * @param {Vector3} destOffset The point where the ray ends.
+   *
+   * @param {double} timeScale The rate at wich the ray form changes in time. Default: 1
+   *
+   * @param {double} roughness From 0 to 1. The higher the value, the more wrinkled is the ray. Default: 0.9
+   *
+   * @param {double} straightness From 0 to 1. The higher the value, the more straight will be a subray path. Default: 0.7
+   *
+   * @param {Vector3} up0 Ray 'up' direction at the ray starting point. Must be normalized. It should be perpendicular to the ray forward direction but it doesn't matter much.
+   *
+   * @param {Vector3} up1 Like the up0 parameter but at the end of the ray. Must be normalized.
+   *
+   * @param {double} radius0 Radius of the main ray trunk at the start point. Default: 1
+   *
+   * @param {double} radius1 Radius of the main ray trunk at the end point. Default: 1
+   *
+   * @param {double} radius0Factor The radius0 of a subray is this factor times the radius0 of its parent subray. Default: 0.5
+   *
+   * @param {double} radius1Factor The radius1 of a subray is this factor times the radius1 of its parent subray. Default: 0.2
+   *
+   * @param {minRadius} Minimum value a subray radius0 or radius1 can get. Default: 0.1
+   *
+   *
+   * The following parameters should not be changed after lightning creation. They can be changed but the ray will change its form abruptly:
+   *
+   * @param {boolean} isEternal If true the ray never extinguishes. Otherwise its life is controlled by the 'birthTime' and 'deathTime' parameters. Default: true if any of those two parameters is undefined.
+   *
+   * @param {double} birthTime The time at which the ray starts its life and begins propagating. Only if isEternal is false. Default: None.
+   *
+   * @param {double} deathTime The time at which the ray ends vanishing and its life. Only if isEternal is false. Default: None.
+   *
+   * @param {double} propagationTimeFactor From 0 to 1. Lifetime factor at which the ray ends propagating and enters the steady phase. For example, 0.1 means it is propagating 1/10 of its lifetime. Default: 0.1
+   *
+   * @param {double} vanishingTimeFactor From 0 to 1. Lifetime factor at which the ray ends the steady phase and begins vanishing. For example, 0.9 means it is vanishing 1/10 of its lifetime. Default: 0.9
+   *
+   * @param {double} subrayPeriod Subrays cycle periodically. This is their time period. Default: 4
+   *
+   * @param {double} subrayDutyCycle From 0 to 1. This is the fraction of time a subray is active. Default: 0.6
+   *
+   *
+   * These parameters cannot change after lightning creation:
+   *
+   * @param {integer} maxIterations: Greater than 0. The number of ray's leaf segments is 2**maxIterations. Default: 9
+   *
+   * @param {boolean} isStatic Set to true only for rays which won't change over time and are not attached to moving objects (Rare case). It is used to set the vertex buffers non-dynamic. You can omit calling update() for these rays.
+   *
+   * @param {integer} ramification Greater than 0. Maximum number of child subrays a subray can have. Default: 5
+   *
+   * @param {integer} maxSubrayRecursion Greater than 0. Maximum level of recursion (subray descendant generations). Default: 3
+   *
+   * @param {double} recursionProbability From 0 to 1. The lower the value, the less chance each new generation of subrays has to generate new subrays. Default: 0.6
+   *
+   * @param {boolean} generateUVs If true, the ray geometry will have uv coordinates generated. u runs along the ray, and v across its perimeter. Default: false.
+   *
+   * @param {Object} randomGenerator Set here your random number generator which will seed the SimplexNoise and other decisions during ray tree creation.
+   * It can be used to generate repeatable rays. For that, set also the noiseSeed parameter, and each ray created with that generator and seed pair will be identical in time.
+   * The randomGenerator parameter should be an object with a random() function similar to Math.random, but seedable.
+   * It must have also a getSeed() method, which returns the current seed, and a setSeed( seed ) method, which accepts as seed a fractional number from 0 to 1, as well as any other number.
+   * The default value is an internal generator for some uses and Math.random for others (It is non-repeatable even if noiseSeed is supplied)
+   *
+   * @param {double} noiseSeed Seed used to make repeatable rays (see the randomGenerator)
+   *
+   * @param {function} onDecideSubrayCreation Set this to change the callback which decides subray creation. You can look at the default callback in the code (createDefaultSubrayCreationCallbacks)for more info.
+   *
+   * @param {function} onSubrayCreation This is another callback, more simple than the previous one. It can be used to adapt the form of subrays or other parameters once a subray has been created and initialized. It is used in the examples to adapt subrays to a sphere or to a plane.
+   *
+   *
+  */
+  var LightningStrike = /*#__PURE__*/function (_BufferGeometry) {
+    _inherits(LightningStrike, _BufferGeometry);
+
+    var _super = _createSuper(LightningStrike);
+
+    function LightningStrike() {
+      var _this;
+
+      var rayParameters = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+      _classCallCheck(this, LightningStrike);
+
+      _this = _super.call(this);
+      _this.type = 'LightningStrike'; // Set parameters, and set undefined parameters to default values
+
+      _this.init(LightningStrike.copyParameters(rayParameters, rayParameters)); // Creates and populates the mesh
+
+
+      _this.createMesh();
+
+      return _this;
+    }
+
+    _createClass(LightningStrike, [{
+      key: "update",
+      value: function update(time) {
+        if (this.isStatic) return;
+
+        if (this.rayParameters.isEternal || this.rayParameters.birthTime <= time && time <= this.rayParameters.deathTime) {
+          this.updateMesh(time);
+
+          if (time < this.subrays[0].endPropagationTime) {
+            this.state = LightningStrike.RAY_PROPAGATING;
+          } else if (time > this.subrays[0].beginVanishingTime) {
+            this.state = LightningStrike.RAY_VANISHING;
+          } else {
+            this.state = LightningStrike.RAY_STEADY;
+          }
+
+          this.visible = true;
+        } else {
+          this.visible = false;
+
+          if (time < this.rayParameters.birthTime) {
+            this.state = LightningStrike.RAY_UNBORN;
+          } else {
+            this.state = LightningStrike.RAY_EXTINGUISHED;
+          }
+        }
+      }
+    }, {
+      key: "init",
+      value: function init(rayParameters) {
+        // Init all the state from the parameters
+        this.rayParameters = rayParameters; // These parameters cannot change after lightning creation:
+
+        this.maxIterations = rayParameters.maxIterations !== undefined ? Math.floor(rayParameters.maxIterations) : 9;
+        rayParameters.maxIterations = this.maxIterations;
+        this.isStatic = rayParameters.isStatic !== undefined ? rayParameters.isStatic : false;
+        rayParameters.isStatic = this.isStatic;
+        this.ramification = rayParameters.ramification !== undefined ? Math.floor(rayParameters.ramification) : 5;
+        rayParameters.ramification = this.ramification;
+        this.maxSubrayRecursion = rayParameters.maxSubrayRecursion !== undefined ? Math.floor(rayParameters.maxSubrayRecursion) : 3;
+        rayParameters.maxSubrayRecursion = this.maxSubrayRecursion;
+        this.recursionProbability = rayParameters.recursionProbability !== undefined ? rayParameters.recursionProbability : 0.6;
+        rayParameters.recursionProbability = this.recursionProbability;
+        this.generateUVs = rayParameters.generateUVs !== undefined ? rayParameters.generateUVs : false;
+        rayParameters.generateUVs = this.generateUVs; // Random generator
+
+        if (rayParameters.randomGenerator !== undefined) {
+          this.randomGenerator = rayParameters.randomGenerator;
+          this.seedGenerator = rayParameters.randomGenerator;
+
+          if (rayParameters.noiseSeed !== undefined) {
+            this.seedGenerator.setSeed(rayParameters.noiseSeed);
+          }
+        } else {
+          this.randomGenerator = LightningStrike.createRandomGenerator();
+          this.seedGenerator = Math;
+        } // Ray creation callbacks
+
+
+        if (rayParameters.onDecideSubrayCreation !== undefined) {
+          this.onDecideSubrayCreation = rayParameters.onDecideSubrayCreation;
+        } else {
+          this.createDefaultSubrayCreationCallbacks();
+
+          if (rayParameters.onSubrayCreation !== undefined) {
+            this.onSubrayCreation = rayParameters.onSubrayCreation;
+          }
+        } // Internal state
+
+
+        this.state = LightningStrike.RAY_INITIALIZED;
+        this.maxSubrays = Math.ceil(1 + Math.pow(this.ramification, Math.max(0, this.maxSubrayRecursion - 1)));
+        rayParameters.maxSubrays = this.maxSubrays;
+        this.maxRaySegments = 2 * (1 << this.maxIterations);
+        this.subrays = [];
+
+        for (var i = 0; i < this.maxSubrays; i++) {
+          this.subrays.push(this.createSubray());
+        }
+
+        this.raySegments = [];
+
+        for (var _i = 0; _i < this.maxRaySegments; _i++) {
+          this.raySegments.push(this.createSegment());
+        }
+
+        this.time = 0;
+        this.timeFraction = 0;
+        this.currentSegmentCallback = null;
+        this.currentCreateTriangleVertices = this.generateUVs ? this.createTriangleVerticesWithUVs : this.createTriangleVerticesWithoutUVs;
+        this.numSubrays = 0;
+        this.currentSubray = null;
+        this.currentSegmentIndex = 0;
+        this.isInitialSegment = false;
+        this.subrayProbability = 0;
+        this.currentVertex = 0;
+        this.currentIndex = 0;
+        this.currentCoordinate = 0;
+        this.currentUVCoordinate = 0;
+        this.vertices = null;
+        this.uvs = null;
+        this.indices = null;
+        this.positionAttribute = null;
+        this.uvsAttribute = null;
+        this.simplexX = new _SimplexNoise.SimplexNoise(this.seedGenerator);
+        this.simplexY = new _SimplexNoise.SimplexNoise(this.seedGenerator);
+        this.simplexZ = new _SimplexNoise.SimplexNoise(this.seedGenerator); // Temp vectors
+
+        this.forwards = new _three.Vector3();
+        this.forwardsFill = new _three.Vector3();
+        this.side = new _three.Vector3();
+        this.down = new _three.Vector3();
+        this.middlePos = new _three.Vector3();
+        this.middleLinPos = new _three.Vector3();
+        this.newPos = new _three.Vector3();
+        this.vPos = new _three.Vector3();
+        this.cross1 = new _three.Vector3();
+      }
+    }, {
+      key: "createMesh",
+      value: function createMesh() {
+        var maxDrawableSegmentsPerSubRay = 1 << this.maxIterations;
+        var maxVerts = 3 * (maxDrawableSegmentsPerSubRay + 1) * this.maxSubrays;
+        var maxIndices = 18 * maxDrawableSegmentsPerSubRay * this.maxSubrays;
+        this.vertices = new Float32Array(maxVerts * 3);
+        this.indices = new Uint32Array(maxIndices);
+
+        if (this.generateUVs) {
+          this.uvs = new Float32Array(maxVerts * 2);
+        } // Populate the mesh
+
+
+        this.fillMesh(0);
+        this.setIndex(new _three.Uint32BufferAttribute(this.indices, 1));
+        this.positionAttribute = new _three.Float32BufferAttribute(this.vertices, 3);
+        this.setAttribute('position', this.positionAttribute);
+
+        if (this.generateUVs) {
+          this.uvsAttribute = new _three.Float32BufferAttribute(new Float32Array(this.uvs), 2);
+          this.setAttribute('uv', this.uvsAttribute);
+        }
+
+        if (!this.isStatic) {
+          this.index.usage = _three.DynamicDrawUsage;
+          this.positionAttribute.usage = _three.DynamicDrawUsage;
+
+          if (this.generateUVs) {
+            this.uvsAttribute.usage = _three.DynamicDrawUsage;
+          }
+        } // Store buffers for later modification
+
+
+        this.vertices = this.positionAttribute.array;
+        this.indices = this.index.array;
+
+        if (this.generateUVs) {
+          this.uvs = this.uvsAttribute.array;
+        }
+      }
+    }, {
+      key: "updateMesh",
+      value: function updateMesh(time) {
+        this.fillMesh(time);
+        this.drawRange.count = this.currentIndex;
+        this.index.needsUpdate = true;
+        this.positionAttribute.needsUpdate = true;
+
+        if (this.generateUVs) {
+          this.uvsAttribute.needsUpdate = true;
+        }
+      }
+    }, {
+      key: "fillMesh",
+      value: function fillMesh(time) {
+        var scope = this;
+        this.currentVertex = 0;
+        this.currentIndex = 0;
+        this.currentCoordinate = 0;
+        this.currentUVCoordinate = 0;
+        this.fractalRay(time, function fillVertices(segment) {
+          var subray = scope.currentSubray;
+
+          if (time < subray.birthTime) {
+            //&& ( ! this.rayParameters.isEternal || scope.currentSubray.recursion > 0 ) ) {
+            return;
+          } else if (this.rayParameters.isEternal && scope.currentSubray.recursion == 0) {
+            // Eternal rays don't propagate nor vanish, but its subrays do
+            scope.createPrism(segment);
+            scope.onDecideSubrayCreation(segment, scope);
+          } else if (time < subray.endPropagationTime) {
+            if (scope.timeFraction >= segment.fraction0 * subray.propagationTimeFactor) {
+              // Ray propagation has arrived to this segment
+              scope.createPrism(segment);
+              scope.onDecideSubrayCreation(segment, scope);
+            }
+          } else if (time < subray.beginVanishingTime) {
+            // Ray is steady (nor propagating nor vanishing)
+            scope.createPrism(segment);
+            scope.onDecideSubrayCreation(segment, scope);
+          } else {
+            if (scope.timeFraction <= subray.vanishingTimeFactor + segment.fraction1 * (1 - subray.vanishingTimeFactor)) {
+              // Segment has not yet vanished
+              scope.createPrism(segment);
+            }
+
+            scope.onDecideSubrayCreation(segment, scope);
+          }
+        });
+      }
+    }, {
+      key: "addNewSubray",
+      value: function
+        /*rayParameters*/
+      addNewSubray() {
+        return this.subrays[this.numSubrays++];
+      }
+    }, {
+      key: "initSubray",
+      value: function initSubray(subray, rayParameters) {
+        subray.pos0.copy(rayParameters.sourceOffset);
+        subray.pos1.copy(rayParameters.destOffset);
+        subray.up0.copy(rayParameters.up0);
+        subray.up1.copy(rayParameters.up1);
+        subray.radius0 = rayParameters.radius0;
+        subray.radius1 = rayParameters.radius1;
+        subray.birthTime = rayParameters.birthTime;
+        subray.deathTime = rayParameters.deathTime;
+        subray.timeScale = rayParameters.timeScale;
+        subray.roughness = rayParameters.roughness;
+        subray.straightness = rayParameters.straightness;
+        subray.propagationTimeFactor = rayParameters.propagationTimeFactor;
+        subray.vanishingTimeFactor = rayParameters.vanishingTimeFactor;
+        subray.maxIterations = this.maxIterations;
+        subray.seed = rayParameters.noiseSeed !== undefined ? rayParameters.noiseSeed : 0;
+        subray.recursion = 0;
+      }
+    }, {
+      key: "fractalRay",
+      value: function fractalRay(time, segmentCallback) {
+        this.time = time;
+        this.currentSegmentCallback = segmentCallback;
+        this.numSubrays = 0; // Add the top level subray
+
+        this.initSubray(this.addNewSubray(), this.rayParameters); // Process all subrays that are being generated until consuming all of them
+
+        for (var subrayIndex = 0; subrayIndex < this.numSubrays; subrayIndex++) {
+          var subray = this.subrays[subrayIndex];
+          this.currentSubray = subray;
+          this.randomGenerator.setSeed(subray.seed);
+          subray.endPropagationTime = _three.MathUtils.lerp(subray.birthTime, subray.deathTime, subray.propagationTimeFactor);
+          subray.beginVanishingTime = _three.MathUtils.lerp(subray.deathTime, subray.birthTime, 1 - subray.vanishingTimeFactor);
+          var random1 = this.randomGenerator.random;
+          subray.linPos0.set(random1(), random1(), random1()).multiplyScalar(1000);
+          subray.linPos1.set(random1(), random1(), random1()).multiplyScalar(1000);
+          this.timeFraction = (time - subray.birthTime) / (subray.deathTime - subray.birthTime);
+          this.currentSegmentIndex = 0;
+          this.isInitialSegment = true;
+          var segment = this.getNewSegment();
+          segment.iteration = 0;
+          segment.pos0.copy(subray.pos0);
+          segment.pos1.copy(subray.pos1);
+          segment.linPos0.copy(subray.linPos0);
+          segment.linPos1.copy(subray.linPos1);
+          segment.up0.copy(subray.up0);
+          segment.up1.copy(subray.up1);
+          segment.radius0 = subray.radius0;
+          segment.radius1 = subray.radius1;
+          segment.fraction0 = 0;
+          segment.fraction1 = 1;
+          segment.positionVariationFactor = 1 - subray.straightness;
+          this.subrayProbability = this.ramification * Math.pow(this.recursionProbability, subray.recursion) / (1 << subray.maxIterations);
+          this.fractalRayRecursive(segment);
+        }
+
+        this.currentSegmentCallback = null;
+        this.currentSubray = null;
+      }
+    }, {
+      key: "fractalRayRecursive",
+      value: function fractalRayRecursive(segment) {
+        // Leave recursion condition
+        if (segment.iteration >= this.currentSubray.maxIterations) {
+          this.currentSegmentCallback(segment);
+          return;
+        } // Interpolation
+
+
+        this.forwards.subVectors(segment.pos1, segment.pos0);
+        var lForwards = this.forwards.length();
+
+        if (lForwards < 0.000001) {
+          this.forwards.set(0, 0, 0.01);
+          lForwards = this.forwards.length();
+        }
+
+        var middleRadius = (segment.radius0 + segment.radius1) * 0.5;
+        var middleFraction = (segment.fraction0 + segment.fraction1) * 0.5;
+        var timeDimension = this.time * this.currentSubray.timeScale * Math.pow(2, segment.iteration);
+        this.middlePos.lerpVectors(segment.pos0, segment.pos1, 0.5);
+        this.middleLinPos.lerpVectors(segment.linPos0, segment.linPos1, 0.5);
+        var p = this.middleLinPos; // Noise
+
+        this.newPos.set(this.simplexX.noise4d(p.x, p.y, p.z, timeDimension), this.simplexY.noise4d(p.x, p.y, p.z, timeDimension), this.simplexZ.noise4d(p.x, p.y, p.z, timeDimension));
+        this.newPos.multiplyScalar(segment.positionVariationFactor * lForwards);
+        this.newPos.add(this.middlePos); // Recursion
+
+        var newSegment1 = this.getNewSegment();
+        newSegment1.pos0.copy(segment.pos0);
+        newSegment1.pos1.copy(this.newPos);
+        newSegment1.linPos0.copy(segment.linPos0);
+        newSegment1.linPos1.copy(this.middleLinPos);
+        newSegment1.up0.copy(segment.up0);
+        newSegment1.up1.copy(segment.up1);
+        newSegment1.radius0 = segment.radius0;
+        newSegment1.radius1 = middleRadius;
+        newSegment1.fraction0 = segment.fraction0;
+        newSegment1.fraction1 = middleFraction;
+        newSegment1.positionVariationFactor = segment.positionVariationFactor * this.currentSubray.roughness;
+        newSegment1.iteration = segment.iteration + 1;
+        var newSegment2 = this.getNewSegment();
+        newSegment2.pos0.copy(this.newPos);
+        newSegment2.pos1.copy(segment.pos1);
+        newSegment2.linPos0.copy(this.middleLinPos);
+        newSegment2.linPos1.copy(segment.linPos1);
+        this.cross1.crossVectors(segment.up0, this.forwards.normalize());
+        newSegment2.up0.crossVectors(this.forwards, this.cross1).normalize();
+        newSegment2.up1.copy(segment.up1);
+        newSegment2.radius0 = middleRadius;
+        newSegment2.radius1 = segment.radius1;
+        newSegment2.fraction0 = middleFraction;
+        newSegment2.fraction1 = segment.fraction1;
+        newSegment2.positionVariationFactor = segment.positionVariationFactor * this.currentSubray.roughness;
+        newSegment2.iteration = segment.iteration + 1;
+        this.fractalRayRecursive(newSegment1);
+        this.fractalRayRecursive(newSegment2);
+      }
+    }, {
+      key: "createPrism",
+      value: function createPrism(segment) {
+        // Creates one triangular prism and its vertices at the segment
+        this.forwardsFill.subVectors(segment.pos1, segment.pos0).normalize();
+
+        if (this.isInitialSegment) {
+          this.currentCreateTriangleVertices(segment.pos0, segment.up0, this.forwardsFill, segment.radius0, 0);
+          this.isInitialSegment = false;
+        }
+
+        this.currentCreateTriangleVertices(segment.pos1, segment.up0, this.forwardsFill, segment.radius1, segment.fraction1);
+        this.createPrismFaces();
+      }
+    }, {
+      key: "createTriangleVerticesWithoutUVs",
+      value: function createTriangleVerticesWithoutUVs(pos, up, forwards, radius) {
+        // Create an equilateral triangle (only vertices)
+        this.side.crossVectors(up, forwards).multiplyScalar(radius * LightningStrike.COS30DEG);
+        this.down.copy(up).multiplyScalar(-radius * LightningStrike.SIN30DEG);
+        var p = this.vPos;
+        var v = this.vertices;
+        p.copy(pos).sub(this.side).add(this.down);
+        v[this.currentCoordinate++] = p.x;
+        v[this.currentCoordinate++] = p.y;
+        v[this.currentCoordinate++] = p.z;
+        p.copy(pos).add(this.side).add(this.down);
+        v[this.currentCoordinate++] = p.x;
+        v[this.currentCoordinate++] = p.y;
+        v[this.currentCoordinate++] = p.z;
+        p.copy(up).multiplyScalar(radius).add(pos);
+        v[this.currentCoordinate++] = p.x;
+        v[this.currentCoordinate++] = p.y;
+        v[this.currentCoordinate++] = p.z;
+        this.currentVertex += 3;
+      }
+    }, {
+      key: "createTriangleVerticesWithUVs",
+      value: function createTriangleVerticesWithUVs(pos, up, forwards, radius, u) {
+        // Create an equilateral triangle (only vertices)
+        this.side.crossVectors(up, forwards).multiplyScalar(radius * LightningStrike.COS30DEG);
+        this.down.copy(up).multiplyScalar(-radius * LightningStrike.SIN30DEG);
+        var p = this.vPos;
+        var v = this.vertices;
+        var uv = this.uvs;
+        p.copy(pos).sub(this.side).add(this.down);
+        v[this.currentCoordinate++] = p.x;
+        v[this.currentCoordinate++] = p.y;
+        v[this.currentCoordinate++] = p.z;
+        uv[this.currentUVCoordinate++] = u;
+        uv[this.currentUVCoordinate++] = 0;
+        p.copy(pos).add(this.side).add(this.down);
+        v[this.currentCoordinate++] = p.x;
+        v[this.currentCoordinate++] = p.y;
+        v[this.currentCoordinate++] = p.z;
+        uv[this.currentUVCoordinate++] = u;
+        uv[this.currentUVCoordinate++] = 0.5;
+        p.copy(up).multiplyScalar(radius).add(pos);
+        v[this.currentCoordinate++] = p.x;
+        v[this.currentCoordinate++] = p.y;
+        v[this.currentCoordinate++] = p.z;
+        uv[this.currentUVCoordinate++] = u;
+        uv[this.currentUVCoordinate++] = 1;
+        this.currentVertex += 3;
+      }
+    }, {
+      key: "createPrismFaces",
+      value: function createPrismFaces(vertex
+      /*, index*/
+      ) {
+        var indices = this.indices;
+        vertex = this.currentVertex - 6;
+        indices[this.currentIndex++] = vertex + 1;
+        indices[this.currentIndex++] = vertex + 2;
+        indices[this.currentIndex++] = vertex + 5;
+        indices[this.currentIndex++] = vertex + 1;
+        indices[this.currentIndex++] = vertex + 5;
+        indices[this.currentIndex++] = vertex + 4;
+        indices[this.currentIndex++] = vertex + 0;
+        indices[this.currentIndex++] = vertex + 1;
+        indices[this.currentIndex++] = vertex + 4;
+        indices[this.currentIndex++] = vertex + 0;
+        indices[this.currentIndex++] = vertex + 4;
+        indices[this.currentIndex++] = vertex + 3;
+        indices[this.currentIndex++] = vertex + 2;
+        indices[this.currentIndex++] = vertex + 0;
+        indices[this.currentIndex++] = vertex + 3;
+        indices[this.currentIndex++] = vertex + 2;
+        indices[this.currentIndex++] = vertex + 3;
+        indices[this.currentIndex++] = vertex + 5;
+      }
+    }, {
+      key: "createDefaultSubrayCreationCallbacks",
+      value: function createDefaultSubrayCreationCallbacks() {
+        var random1 = this.randomGenerator.random;
+
+        this.onDecideSubrayCreation = function (segment, lightningStrike) {
+          // Decide subrays creation at parent (sub)ray segment
+          var subray = lightningStrike.currentSubray;
+          var period = lightningStrike.rayParameters.subrayPeriod;
+          var dutyCycle = lightningStrike.rayParameters.subrayDutyCycle;
+          var phase0 = lightningStrike.rayParameters.isEternal && subray.recursion == 0 ? -random1() * period : _three.MathUtils.lerp(subray.birthTime, subray.endPropagationTime, segment.fraction0) - random1() * period;
+          var phase = lightningStrike.time - phase0;
+          var currentCycle = Math.floor(phase / period);
+          var childSubraySeed = random1() * (currentCycle + 1);
+          var isActive = phase % period <= dutyCycle * period;
+          var probability = 0;
+
+          if (isActive) {
+            probability = lightningStrike.subrayProbability; // Distribution test: probability *= segment.fraction0 > 0.5 && segment.fraction0 < 0.9 ? 1 / 0.4 : 0;
+          }
+
+          if (subray.recursion < lightningStrike.maxSubrayRecursion && lightningStrike.numSubrays < lightningStrike.maxSubrays && random1() < probability) {
+            var childSubray = lightningStrike.addNewSubray();
+            var parentSeed = lightningStrike.randomGenerator.getSeed();
+            childSubray.seed = childSubraySeed;
+            lightningStrike.randomGenerator.setSeed(childSubraySeed);
+            childSubray.recursion = subray.recursion + 1;
+            childSubray.maxIterations = Math.max(1, subray.maxIterations - 1);
+            childSubray.linPos0.set(random1(), random1(), random1()).multiplyScalar(1000);
+            childSubray.linPos1.set(random1(), random1(), random1()).multiplyScalar(1000);
+            childSubray.up0.copy(subray.up0);
+            childSubray.up1.copy(subray.up1);
+            childSubray.radius0 = segment.radius0 * lightningStrike.rayParameters.radius0Factor;
+            childSubray.radius1 = Math.min(lightningStrike.rayParameters.minRadius, segment.radius1 * lightningStrike.rayParameters.radius1Factor);
+            childSubray.birthTime = phase0 + currentCycle * period;
+            childSubray.deathTime = childSubray.birthTime + period * dutyCycle;
+
+            if (!lightningStrike.rayParameters.isEternal && subray.recursion == 0) {
+              childSubray.birthTime = Math.max(childSubray.birthTime, subray.birthTime);
+              childSubray.deathTime = Math.min(childSubray.deathTime, subray.deathTime);
+            }
+
+            childSubray.timeScale = subray.timeScale * 2;
+            childSubray.roughness = subray.roughness;
+            childSubray.straightness = subray.straightness;
+            childSubray.propagationTimeFactor = subray.propagationTimeFactor;
+            childSubray.vanishingTimeFactor = subray.vanishingTimeFactor;
+            lightningStrike.onSubrayCreation(segment, subray, childSubray, lightningStrike);
+            lightningStrike.randomGenerator.setSeed(parentSeed);
+          }
+        };
+
+        var vec1Pos = new _three.Vector3();
+        var vec2Forward = new _three.Vector3();
+        var vec3Side = new _three.Vector3();
+        var vec4Up = new _three.Vector3();
+
+        this.onSubrayCreation = function (segment, parentSubray, childSubray, lightningStrike) {
+          // Decide childSubray origin and destination positions (pos0 and pos1) and possibly other properties of childSubray
+          // Just use the default cone position generator
+          lightningStrike.subrayCylinderPosition(segment, parentSubray, childSubray, 0.5, 0.6, 0.2);
+        };
+
+        this.subrayConePosition = function (segment, parentSubray, childSubray, heightFactor, sideWidthFactor, minSideWidthFactor) {
+          // Sets childSubray pos0 and pos1 in a cone
+          childSubray.pos0.copy(segment.pos0);
+          vec1Pos.subVectors(parentSubray.pos1, parentSubray.pos0);
+          vec2Forward.copy(vec1Pos).normalize();
+          vec1Pos.multiplyScalar(segment.fraction0 + (1 - segment.fraction0) * (random1() * heightFactor));
+          var length = vec1Pos.length();
+          vec3Side.crossVectors(parentSubray.up0, vec2Forward);
+          var angle = 2 * Math.PI * random1();
+          vec3Side.multiplyScalar(Math.cos(angle));
+          vec4Up.copy(parentSubray.up0).multiplyScalar(Math.sin(angle));
+          childSubray.pos1.copy(vec3Side).add(vec4Up).multiplyScalar(length * sideWidthFactor * (minSideWidthFactor + random1() * (1 - minSideWidthFactor))).add(vec1Pos).add(parentSubray.pos0);
+        };
+
+        this.subrayCylinderPosition = function (segment, parentSubray, childSubray, heightFactor, sideWidthFactor, minSideWidthFactor) {
+          // Sets childSubray pos0 and pos1 in a cylinder
+          childSubray.pos0.copy(segment.pos0);
+          vec1Pos.subVectors(parentSubray.pos1, parentSubray.pos0);
+          vec2Forward.copy(vec1Pos).normalize();
+          vec1Pos.multiplyScalar(segment.fraction0 + (1 - segment.fraction0) * ((2 * random1() - 1) * heightFactor));
+          var length = vec1Pos.length();
+          vec3Side.crossVectors(parentSubray.up0, vec2Forward);
+          var angle = 2 * Math.PI * random1();
+          vec3Side.multiplyScalar(Math.cos(angle));
+          vec4Up.copy(parentSubray.up0).multiplyScalar(Math.sin(angle));
+          childSubray.pos1.copy(vec3Side).add(vec4Up).multiplyScalar(length * sideWidthFactor * (minSideWidthFactor + random1() * (1 - minSideWidthFactor))).add(vec1Pos).add(parentSubray.pos0);
+        };
+      }
+    }, {
+      key: "createSubray",
+      value: function createSubray() {
+        return {
+          seed: 0,
+          maxIterations: 0,
+          recursion: 0,
+          pos0: new _three.Vector3(),
+          pos1: new _three.Vector3(),
+          linPos0: new _three.Vector3(),
+          linPos1: new _three.Vector3(),
+          up0: new _three.Vector3(),
+          up1: new _three.Vector3(),
+          radius0: 0,
+          radius1: 0,
+          birthTime: 0,
+          deathTime: 0,
+          timeScale: 0,
+          roughness: 0,
+          straightness: 0,
+          propagationTimeFactor: 0,
+          vanishingTimeFactor: 0,
+          endPropagationTime: 0,
+          beginVanishingTime: 0
+        };
+      }
+    }, {
+      key: "createSegment",
+      value: function createSegment() {
+        return {
+          iteration: 0,
+          pos0: new _three.Vector3(),
+          pos1: new _three.Vector3(),
+          linPos0: new _three.Vector3(),
+          linPos1: new _three.Vector3(),
+          up0: new _three.Vector3(),
+          up1: new _three.Vector3(),
+          radius0: 0,
+          radius1: 0,
+          fraction0: 0,
+          fraction1: 0,
+          positionVariationFactor: 0
+        };
+      }
+    }, {
+      key: "getNewSegment",
+      value: function getNewSegment() {
+        return this.raySegments[this.currentSegmentIndex++];
+      }
+    }, {
+      key: "copy",
+      value: function copy(source) {
+        _get(_getPrototypeOf(LightningStrike.prototype), "copy", this).call(this, source);
+
+        this.init(LightningStrike.copyParameters({}, source.rayParameters));
+        return this;
+      }
+    }, {
+      key: "clone",
+      value: function clone() {
+        return new this.constructor(LightningStrike.copyParameters({}, this.rayParameters));
+      }
+    }], [{
+      key: "createRandomGenerator",
+      value: function createRandomGenerator() {
+        var numSeeds = 2053;
+        var seeds = [];
+
+        for (var i = 0; i < numSeeds; i++) {
+          seeds.push(Math.random());
+        }
+
+        var generator = {
+          currentSeed: 0,
+          random: function random() {
+            var value = seeds[generator.currentSeed];
+            generator.currentSeed = (generator.currentSeed + 1) % numSeeds;
+            return value;
+          },
+          getSeed: function getSeed() {
+            return generator.currentSeed / numSeeds;
+          },
+          setSeed: function setSeed(seed) {
+            generator.currentSeed = Math.floor(seed * numSeeds) % numSeeds;
+          }
+        };
+        return generator;
+      }
+    }, {
+      key: "copyParameters",
+      value: function copyParameters() {
+        var dest = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+        var source = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+        var vecCopy = function vecCopy(v) {
+          if (source === dest) {
+            return v;
+          } else {
+            return v.clone();
+          }
+        };
+
+        dest.sourceOffset = source.sourceOffset !== undefined ? vecCopy(source.sourceOffset) : new _three.Vector3(0, 100, 0), dest.destOffset = source.destOffset !== undefined ? vecCopy(source.destOffset) : new _three.Vector3(0, 0, 0), dest.timeScale = source.timeScale !== undefined ? source.timeScale : 1, dest.roughness = source.roughness !== undefined ? source.roughness : 0.9, dest.straightness = source.straightness !== undefined ? source.straightness : 0.7, dest.up0 = source.up0 !== undefined ? vecCopy(source.up0) : new _three.Vector3(0, 0, 1);
+        dest.up1 = source.up1 !== undefined ? vecCopy(source.up1) : new _three.Vector3(0, 0, 1), dest.radius0 = source.radius0 !== undefined ? source.radius0 : 1, dest.radius1 = source.radius1 !== undefined ? source.radius1 : 1, dest.radius0Factor = source.radius0Factor !== undefined ? source.radius0Factor : 0.5, dest.radius1Factor = source.radius1Factor !== undefined ? source.radius1Factor : 0.2, dest.minRadius = source.minRadius !== undefined ? source.minRadius : 0.2, // These parameters should not be changed after lightning creation. They can be changed but the ray will change its form abruptly:
+        dest.isEternal = source.isEternal !== undefined ? source.isEternal : source.birthTime === undefined || source.deathTime === undefined, dest.birthTime = source.birthTime, dest.deathTime = source.deathTime, dest.propagationTimeFactor = source.propagationTimeFactor !== undefined ? source.propagationTimeFactor : 0.1, dest.vanishingTimeFactor = source.vanishingTimeFactor !== undefined ? source.vanishingTimeFactor : 0.9, dest.subrayPeriod = source.subrayPeriod !== undefined ? source.subrayPeriod : 4, dest.subrayDutyCycle = source.subrayDutyCycle !== undefined ? source.subrayDutyCycle : 0.6; // These parameters cannot change after lightning creation:
+
+        dest.maxIterations = source.maxIterations !== undefined ? source.maxIterations : 9;
+        dest.isStatic = source.isStatic !== undefined ? source.isStatic : false;
+        dest.ramification = source.ramification !== undefined ? source.ramification : 5;
+        dest.maxSubrayRecursion = source.maxSubrayRecursion !== undefined ? source.maxSubrayRecursion : 3;
+        dest.recursionProbability = source.recursionProbability !== undefined ? source.recursionProbability : 0.6;
+        dest.generateUVs = source.generateUVs !== undefined ? source.generateUVs : false;
+        dest.randomGenerator = source.randomGenerator, dest.noiseSeed = source.noiseSeed, dest.onDecideSubrayCreation = source.onDecideSubrayCreation, dest.onSubrayCreation = source.onSubrayCreation;
+        return dest;
+      }
+    }]);
+
+    return LightningStrike;
+  }(_three.BufferGeometry);
+
+  _exports.LightningStrike = LightningStrike;
+  LightningStrike.prototype.isLightningStrike = true; // Ray states
+
+  LightningStrike.RAY_INITIALIZED = 0;
+  LightningStrike.RAY_UNBORN = 1;
+  LightningStrike.RAY_PROPAGATING = 2;
+  LightningStrike.RAY_STEADY = 3;
+  LightningStrike.RAY_VANISHING = 4;
+  LightningStrike.RAY_EXTINGUISHED = 5;
+  LightningStrike.COS30DEG = Math.cos(30 * Math.PI / 180);
+  LightningStrike.SIN30DEG = Math.sin(30 * Math.PI / 180);
+});