three-stdlib 2.22.7 → 2.22.9

package/dist/objects/Lensflare.js

@@ -0,0 +1,280 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+class Lensflare extends THREE.Mesh {
+  constructor() {
+    super(Lensflare.Geometry, new THREE.MeshBasicMaterial({ opacity: 0, transparent: true }));
+    this.type = "Lensflare";
+    this.frustumCulled = false;
+    this.renderOrder = Infinity;
+    const positionScreen = new THREE.Vector3();
+    const positionView = new THREE.Vector3();
+    const tempMap = new THREE.DataTexture(new Uint8Array(16 * 16 * 3), 16, 16, THREE.RGBAFormat);
+    tempMap.minFilter = THREE.NearestFilter;
+    tempMap.magFilter = THREE.NearestFilter;
+    tempMap.wrapS = THREE.ClampToEdgeWrapping;
+    tempMap.wrapT = THREE.ClampToEdgeWrapping;
+    const occlusionMap = new THREE.DataTexture(new Uint8Array(16 * 16 * 3), 16, 16, THREE.RGBAFormat);
+    occlusionMap.minFilter = THREE.NearestFilter;
+    occlusionMap.magFilter = THREE.NearestFilter;
+    occlusionMap.wrapS = THREE.ClampToEdgeWrapping;
+    occlusionMap.wrapT = THREE.ClampToEdgeWrapping;
+    const geometry = Lensflare.Geometry;
+    const material1a = new THREE.RawShaderMaterial({
+      uniforms: {
+        scale: { value: null },
+        screenPosition: { value: null }
+      },
+      vertexShader: (
+        /* glsl */
+        `
+
+				precision highp float;
+
+				uniform vec3 screenPosition;
+				uniform vec2 scale;
+
+				attribute vec3 position;
+
+				void main() {
+
+					gl_Position = vec4( position.xy * scale + screenPosition.xy, screenPosition.z, 1.0 );
+
+				}`
+      ),
+      fragmentShader: (
+        /* glsl */
+        `
+
+				precision highp float;
+
+				void main() {
+
+					gl_FragColor = vec4( 1.0, 0.0, 1.0, 1.0 );
+
+				}`
+      ),
+      depthTest: true,
+      depthWrite: false,
+      transparent: false
+    });
+    const material1b = new THREE.RawShaderMaterial({
+      uniforms: {
+        map: { value: tempMap },
+        scale: { value: null },
+        screenPosition: { value: null }
+      },
+      vertexShader: (
+        /* glsl */
+        `
+
+				precision highp float;
+
+				uniform vec3 screenPosition;
+				uniform vec2 scale;
+
+				attribute vec3 position;
+				attribute vec2 uv;
+
+				varying vec2 vUV;
+
+				void main() {
+
+					vUV = uv;
+
+					gl_Position = vec4( position.xy * scale + screenPosition.xy, screenPosition.z, 1.0 );
+
+				}`
+      ),
+      fragmentShader: (
+        /* glsl */
+        `
+
+				precision highp float;
+
+				uniform sampler2D map;
+
+				varying vec2 vUV;
+
+				void main() {
+
+					gl_FragColor = texture2D( map, vUV );
+
+				}`
+      ),
+      depthTest: false,
+      depthWrite: false,
+      transparent: false
+    });
+    const mesh1 = new THREE.Mesh(geometry, material1a);
+    const elements = [];
+    const shader = LensflareElement.Shader;
+    const material2 = new THREE.RawShaderMaterial({
+      uniforms: {
+        map: { value: null },
+        occlusionMap: { value: occlusionMap },
+        color: { value: new THREE.Color(16777215) },
+        scale: { value: new THREE.Vector2() },
+        screenPosition: { value: new THREE.Vector3() }
+      },
+      vertexShader: shader.vertexShader,
+      fragmentShader: shader.fragmentShader,
+      blending: THREE.AdditiveBlending,
+      transparent: true,
+      depthWrite: false
+    });
+    const mesh2 = new THREE.Mesh(geometry, material2);
+    this.addElement = function(element) {
+      elements.push(element);
+    };
+    const scale = new THREE.Vector2();
+    const screenPositionPixels = new THREE.Vector2();
+    const validArea = new THREE.Box2();
+    const viewport = new THREE.Vector4();
+    this.onBeforeRender = function(renderer, scene, camera) {
+      renderer.getCurrentViewport(viewport);
+      const invAspect = viewport.w / viewport.z;
+      const halfViewportWidth = viewport.z / 2;
+      const halfViewportHeight = viewport.w / 2;
+      let size = 16 / viewport.w;
+      scale.set(size * invAspect, size);
+      validArea.min.set(viewport.x, viewport.y);
+      validArea.max.set(viewport.x + (viewport.z - 16), viewport.y + (viewport.w - 16));
+      positionView.setFromMatrixPosition(this.matrixWorld);
+      positionView.applyMatrix4(camera.matrixWorldInverse);
+      if (positionView.z > 0)
+        return;
+      positionScreen.copy(positionView).applyMatrix4(camera.projectionMatrix);
+      screenPositionPixels.x = viewport.x + positionScreen.x * halfViewportWidth + halfViewportWidth - 8;
+      screenPositionPixels.y = viewport.y + positionScreen.y * halfViewportHeight + halfViewportHeight - 8;
+      if (validArea.containsPoint(screenPositionPixels)) {
+        renderer.copyFramebufferToTexture(screenPositionPixels, tempMap);
+        let uniforms = material1a.uniforms;
+        uniforms["scale"].value = scale;
+        uniforms["screenPosition"].value = positionScreen;
+        renderer.renderBufferDirect(camera, null, geometry, material1a, mesh1, null);
+        renderer.copyFramebufferToTexture(screenPositionPixels, occlusionMap);
+        uniforms = material1b.uniforms;
+        uniforms["scale"].value = scale;
+        uniforms["screenPosition"].value = positionScreen;
+        renderer.renderBufferDirect(camera, null, geometry, material1b, mesh1, null);
+        const vecX = -positionScreen.x * 2;
+        const vecY = -positionScreen.y * 2;
+        for (let i = 0, l = elements.length; i < l; i++) {
+          const element = elements[i];
+          const uniforms2 = material2.uniforms;
+          uniforms2["color"].value.copy(element.color);
+          uniforms2["map"].value = element.texture;
+          uniforms2["screenPosition"].value.x = positionScreen.x + vecX * element.distance;
+          uniforms2["screenPosition"].value.y = positionScreen.y + vecY * element.distance;
+          size = element.size / viewport.w;
+          const invAspect2 = viewport.w / viewport.z;
+          uniforms2["scale"].value.set(size * invAspect2, size);
+          material2.uniformsNeedUpdate = true;
+          renderer.renderBufferDirect(camera, null, geometry, material2, mesh2, null);
+        }
+      }
+    };
+    this.dispose = function() {
+      material1a.dispose();
+      material1b.dispose();
+      material2.dispose();
+      tempMap.dispose();
+      occlusionMap.dispose();
+      for (let i = 0, l = elements.length; i < l; i++) {
+        elements[i].texture.dispose();
+      }
+    };
+  }
+}
+Lensflare.prototype.isLensflare = true;
+class LensflareElement {
+  constructor(texture, size = 1, distance = 0, color = new THREE.Color(16777215)) {
+    this.texture = texture;
+    this.size = size;
+    this.distance = distance;
+    this.color = color;
+  }
+}
+LensflareElement.Shader = {
+  uniforms: {
+    map: { value: null },
+    occlusionMap: { value: null },
+    color: { value: null },
+    scale: { value: null },
+    screenPosition: { value: null }
+  },
+  vertexShader: (
+    /* glsl */
+    `
+
+		precision highp float;
+
+		uniform vec3 screenPosition;
+		uniform vec2 scale;
+
+		uniform sampler2D occlusionMap;
+
+		attribute vec3 position;
+		attribute vec2 uv;
+
+		varying vec2 vUV;
+		varying float vVisibility;
+
+		void main() {
+
+			vUV = uv;
+
+			vec2 pos = position.xy;
+
+			vec4 visibility = texture2D( occlusionMap, vec2( 0.1, 0.1 ) );
+			visibility += texture2D( occlusionMap, vec2( 0.5, 0.1 ) );
+			visibility += texture2D( occlusionMap, vec2( 0.9, 0.1 ) );
+			visibility += texture2D( occlusionMap, vec2( 0.9, 0.5 ) );
+			visibility += texture2D( occlusionMap, vec2( 0.9, 0.9 ) );
+			visibility += texture2D( occlusionMap, vec2( 0.5, 0.9 ) );
+			visibility += texture2D( occlusionMap, vec2( 0.1, 0.9 ) );
+			visibility += texture2D( occlusionMap, vec2( 0.1, 0.5 ) );
+			visibility += texture2D( occlusionMap, vec2( 0.5, 0.5 ) );
+
+			vVisibility =        visibility.r / 9.0;
+			vVisibility *= 1.0 - visibility.g / 9.0;
+			vVisibility *=       visibility.b / 9.0;
+
+			gl_Position = vec4( ( pos * scale + screenPosition.xy ).xy, screenPosition.z, 1.0 );
+
+		}`
+  ),
+  fragmentShader: (
+    /* glsl */
+    `
+
+		precision highp float;
+
+		uniform sampler2D map;
+		uniform vec3 color;
+
+		varying vec2 vUV;
+		varying float vVisibility;
+
+		void main() {
+
+			vec4 texture = texture2D( map, vUV );
+			texture.a *= vVisibility;
+			gl_FragColor = texture;
+			gl_FragColor.rgb *= color;
+
+		}`
+  )
+};
+Lensflare.Geometry = function() {
+  const geometry = new THREE.BufferGeometry();
+  const float32Array = new Float32Array([-1, -1, 0, 0, 0, 1, -1, 0, 1, 0, 1, 1, 0, 1, 1, -1, 1, 0, 0, 1]);
+  const interleavedBuffer = new THREE.InterleavedBuffer(float32Array, 5);
+  geometry.setIndex([0, 1, 2, 0, 2, 3]);
+  geometry.setAttribute("position", new THREE.InterleavedBufferAttribute(interleavedBuffer, 3, 0, false));
+  geometry.setAttribute("uv", new THREE.InterleavedBufferAttribute(interleavedBuffer, 2, 3, false));
+  return geometry;
+}();
+exports.Lensflare = Lensflare;
+exports.LensflareElement = LensflareElement;

package/dist/objects/Lensflare.mjs

@@ -0,0 +1,280 @@
+import { Mesh, MeshBasicMaterial, Vector3, DataTexture, RGBAFormat, NearestFilter, ClampToEdgeWrapping, RawShaderMaterial, Color, Vector2, AdditiveBlending, Box2, Vector4, BufferGeometry, InterleavedBuffer, InterleavedBufferAttribute } from "three";
+class Lensflare extends Mesh {
+  constructor() {
+    super(Lensflare.Geometry, new MeshBasicMaterial({ opacity: 0, transparent: true }));
+    this.type = "Lensflare";
+    this.frustumCulled = false;
+    this.renderOrder = Infinity;
+    const positionScreen = new Vector3();
+    const positionView = new Vector3();
+    const tempMap = new DataTexture(new Uint8Array(16 * 16 * 3), 16, 16, RGBAFormat);
+    tempMap.minFilter = NearestFilter;
+    tempMap.magFilter = NearestFilter;
+    tempMap.wrapS = ClampToEdgeWrapping;
+    tempMap.wrapT = ClampToEdgeWrapping;
+    const occlusionMap = new DataTexture(new Uint8Array(16 * 16 * 3), 16, 16, RGBAFormat);
+    occlusionMap.minFilter = NearestFilter;
+    occlusionMap.magFilter = NearestFilter;
+    occlusionMap.wrapS = ClampToEdgeWrapping;
+    occlusionMap.wrapT = ClampToEdgeWrapping;
+    const geometry = Lensflare.Geometry;
+    const material1a = new RawShaderMaterial({
+      uniforms: {
+        scale: { value: null },
+        screenPosition: { value: null }
+      },
+      vertexShader: (
+        /* glsl */
+        `
+
+				precision highp float;
+
+				uniform vec3 screenPosition;
+				uniform vec2 scale;
+
+				attribute vec3 position;
+
+				void main() {
+
+					gl_Position = vec4( position.xy * scale + screenPosition.xy, screenPosition.z, 1.0 );
+
+				}`
+      ),
+      fragmentShader: (
+        /* glsl */
+        `
+
+				precision highp float;
+
+				void main() {
+
+					gl_FragColor = vec4( 1.0, 0.0, 1.0, 1.0 );
+
+				}`
+      ),
+      depthTest: true,
+      depthWrite: false,
+      transparent: false
+    });
+    const material1b = new RawShaderMaterial({
+      uniforms: {
+        map: { value: tempMap },
+        scale: { value: null },
+        screenPosition: { value: null }
+      },
+      vertexShader: (
+        /* glsl */
+        `
+
+				precision highp float;
+
+				uniform vec3 screenPosition;
+				uniform vec2 scale;
+
+				attribute vec3 position;
+				attribute vec2 uv;
+
+				varying vec2 vUV;
+
+				void main() {
+
+					vUV = uv;
+
+					gl_Position = vec4( position.xy * scale + screenPosition.xy, screenPosition.z, 1.0 );
+
+				}`
+      ),
+      fragmentShader: (
+        /* glsl */
+        `
+
+				precision highp float;
+
+				uniform sampler2D map;
+
+				varying vec2 vUV;
+
+				void main() {
+
+					gl_FragColor = texture2D( map, vUV );
+
+				}`
+      ),
+      depthTest: false,
+      depthWrite: false,
+      transparent: false
+    });
+    const mesh1 = new Mesh(geometry, material1a);
+    const elements = [];
+    const shader = LensflareElement.Shader;
+    const material2 = new RawShaderMaterial({
+      uniforms: {
+        map: { value: null },
+        occlusionMap: { value: occlusionMap },
+        color: { value: new Color(16777215) },
+        scale: { value: new Vector2() },
+        screenPosition: { value: new Vector3() }
+      },
+      vertexShader: shader.vertexShader,
+      fragmentShader: shader.fragmentShader,
+      blending: AdditiveBlending,
+      transparent: true,
+      depthWrite: false
+    });
+    const mesh2 = new Mesh(geometry, material2);
+    this.addElement = function(element) {
+      elements.push(element);
+    };
+    const scale = new Vector2();
+    const screenPositionPixels = new Vector2();
+    const validArea = new Box2();
+    const viewport = new Vector4();
+    this.onBeforeRender = function(renderer, scene, camera) {
+      renderer.getCurrentViewport(viewport);
+      const invAspect = viewport.w / viewport.z;
+      const halfViewportWidth = viewport.z / 2;
+      const halfViewportHeight = viewport.w / 2;
+      let size = 16 / viewport.w;
+      scale.set(size * invAspect, size);
+      validArea.min.set(viewport.x, viewport.y);
+      validArea.max.set(viewport.x + (viewport.z - 16), viewport.y + (viewport.w - 16));
+      positionView.setFromMatrixPosition(this.matrixWorld);
+      positionView.applyMatrix4(camera.matrixWorldInverse);
+      if (positionView.z > 0)
+        return;
+      positionScreen.copy(positionView).applyMatrix4(camera.projectionMatrix);
+      screenPositionPixels.x = viewport.x + positionScreen.x * halfViewportWidth + halfViewportWidth - 8;
+      screenPositionPixels.y = viewport.y + positionScreen.y * halfViewportHeight + halfViewportHeight - 8;
+      if (validArea.containsPoint(screenPositionPixels)) {
+        renderer.copyFramebufferToTexture(screenPositionPixels, tempMap);
+        let uniforms = material1a.uniforms;
+        uniforms["scale"].value = scale;
+        uniforms["screenPosition"].value = positionScreen;
+        renderer.renderBufferDirect(camera, null, geometry, material1a, mesh1, null);
+        renderer.copyFramebufferToTexture(screenPositionPixels, occlusionMap);
+        uniforms = material1b.uniforms;
+        uniforms["scale"].value = scale;
+        uniforms["screenPosition"].value = positionScreen;
+        renderer.renderBufferDirect(camera, null, geometry, material1b, mesh1, null);
+        const vecX = -positionScreen.x * 2;
+        const vecY = -positionScreen.y * 2;
+        for (let i = 0, l = elements.length; i < l; i++) {
+          const element = elements[i];
+          const uniforms2 = material2.uniforms;
+          uniforms2["color"].value.copy(element.color);
+          uniforms2["map"].value = element.texture;
+          uniforms2["screenPosition"].value.x = positionScreen.x + vecX * element.distance;
+          uniforms2["screenPosition"].value.y = positionScreen.y + vecY * element.distance;
+          size = element.size / viewport.w;
+          const invAspect2 = viewport.w / viewport.z;
+          uniforms2["scale"].value.set(size * invAspect2, size);
+          material2.uniformsNeedUpdate = true;
+          renderer.renderBufferDirect(camera, null, geometry, material2, mesh2, null);
+        }
+      }
+    };
+    this.dispose = function() {
+      material1a.dispose();
+      material1b.dispose();
+      material2.dispose();
+      tempMap.dispose();
+      occlusionMap.dispose();
+      for (let i = 0, l = elements.length; i < l; i++) {
+        elements[i].texture.dispose();
+      }
+    };
+  }
+}
+Lensflare.prototype.isLensflare = true;
+class LensflareElement {
+  constructor(texture, size = 1, distance = 0, color = new Color(16777215)) {
+    this.texture = texture;
+    this.size = size;
+    this.distance = distance;
+    this.color = color;
+  }
+}
+LensflareElement.Shader = {
+  uniforms: {
+    map: { value: null },
+    occlusionMap: { value: null },
+    color: { value: null },
+    scale: { value: null },
+    screenPosition: { value: null }
+  },
+  vertexShader: (
+    /* glsl */
+    `
+
+		precision highp float;
+
+		uniform vec3 screenPosition;
+		uniform vec2 scale;
+
+		uniform sampler2D occlusionMap;
+
+		attribute vec3 position;
+		attribute vec2 uv;
+
+		varying vec2 vUV;
+		varying float vVisibility;
+
+		void main() {
+
+			vUV = uv;
+
+			vec2 pos = position.xy;
+
+			vec4 visibility = texture2D( occlusionMap, vec2( 0.1, 0.1 ) );
+			visibility += texture2D( occlusionMap, vec2( 0.5, 0.1 ) );
+			visibility += texture2D( occlusionMap, vec2( 0.9, 0.1 ) );
+			visibility += texture2D( occlusionMap, vec2( 0.9, 0.5 ) );
+			visibility += texture2D( occlusionMap, vec2( 0.9, 0.9 ) );
+			visibility += texture2D( occlusionMap, vec2( 0.5, 0.9 ) );
+			visibility += texture2D( occlusionMap, vec2( 0.1, 0.9 ) );
+			visibility += texture2D( occlusionMap, vec2( 0.1, 0.5 ) );
+			visibility += texture2D( occlusionMap, vec2( 0.5, 0.5 ) );
+
+			vVisibility =        visibility.r / 9.0;
+			vVisibility *= 1.0 - visibility.g / 9.0;
+			vVisibility *=       visibility.b / 9.0;
+
+			gl_Position = vec4( ( pos * scale + screenPosition.xy ).xy, screenPosition.z, 1.0 );
+
+		}`
+  ),
+  fragmentShader: (
+    /* glsl */
+    `
+
+		precision highp float;
+
+		uniform sampler2D map;
+		uniform vec3 color;
+
+		varying vec2 vUV;
+		varying float vVisibility;
+
+		void main() {
+
+			vec4 texture = texture2D( map, vUV );
+			texture.a *= vVisibility;
+			gl_FragColor = texture;
+			gl_FragColor.rgb *= color;
+
+		}`
+  )
+};
+Lensflare.Geometry = function() {
+  const geometry = new BufferGeometry();
+  const float32Array = new Float32Array([-1, -1, 0, 0, 0, 1, -1, 0, 1, 0, 1, 1, 0, 1, 1, -1, 1, 0, 0, 1]);
+  const interleavedBuffer = new InterleavedBuffer(float32Array, 5);
+  geometry.setIndex([0, 1, 2, 0, 2, 3]);
+  geometry.setAttribute("position", new InterleavedBufferAttribute(interleavedBuffer, 3, 0, false));
+  geometry.setAttribute("uv", new InterleavedBufferAttribute(interleavedBuffer, 2, 3, false));
+  return geometry;
+}();
+export {
+  Lensflare,
+  LensflareElement
+};

package/dist/objects/LightningStorm.d.ts

@@ -0,0 +1,32 @@
+import { Material, Vector3 } from 'three'
+
+import { LightningStrike, RayParameters } from '../geometries/LightningStrike'
+
+export interface StormParams {
+  size?: number
+  minHeight?: number
+  maxHeight?: number
+  maxSlope?: number
+
+  maxLightnings?: number
+
+  lightningMinPeriod?: number
+  lightningMaxPeriod?: number
+  lightningMinDuration?: number
+  lightningMaxDuration?: number
+
+  lightningParameters?: RayParameters
+  lightningMaterial?: Material
+
+  isEternal?: boolean
+
+  onRayPosition?: (source: Vector3, dest: Vector3) => void
+  onLightningDown?: (lightning: LightningStrike) => void
+}
+
+export class LightningStorm {
+  constructor(stormParams?: StormParams)
+  update(time: number): void
+  copy(source: LightningStorm): LightningStorm
+  clone(): this
+}

package/dist/objects/LightningStorm.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const LightningStrike = require("../geometries/LightningStrike.js");
+class LightningStorm extends THREE.Object3D {
+  constructor(stormParams = {}) {
+    super();
+    this.stormParams = stormParams;
+    stormParams.size = stormParams.size !== void 0 ? stormParams.size : 1e3;
+    stormParams.minHeight = stormParams.minHeight !== void 0 ? stormParams.minHeight : 80;
+    stormParams.maxHeight = stormParams.maxHeight !== void 0 ? stormParams.maxHeight : 100;
+    stormParams.maxSlope = stormParams.maxSlope !== void 0 ? stormParams.maxSlope : 1.1;
+    stormParams.maxLightnings = stormParams.maxLightnings !== void 0 ? stormParams.maxLightnings : 3;
+    stormParams.lightningMinPeriod = stormParams.lightningMinPeriod !== void 0 ? stormParams.lightningMinPeriod : 3;
+    stormParams.lightningMaxPeriod = stormParams.lightningMaxPeriod !== void 0 ? stormParams.lightningMaxPeriod : 7;
+    stormParams.lightningMinDuration = stormParams.lightningMinDuration !== void 0 ? stormParams.lightningMinDuration : 1;
+    stormParams.lightningMaxDuration = stormParams.lightningMaxDuration !== void 0 ? stormParams.lightningMaxDuration : 2.5;
+    this.lightningParameters = LightningStrike.LightningStrike.copyParameters(
+      stormParams.lightningParameters,
+      stormParams.lightningParameters
+    );
+    this.lightningParameters.isEternal = false;
+    this.lightningMaterial = stormParams.lightningMaterial !== void 0 ? stormParams.lightningMaterial : new THREE.MeshBasicMaterial({ color: 11599871 });
+    if (stormParams.onRayPosition !== void 0) {
+      this.onRayPosition = stormParams.onRayPosition;
+    } else {
+      this.onRayPosition = function(source, dest) {
+        dest.set((Math.random() - 0.5) * stormParams.size, 0, (Math.random() - 0.5) * stormParams.size);
+        const height = THREE.MathUtils.lerp(stormParams.minHeight, stormParams.maxHeight, Math.random());
+        source.set(stormParams.maxSlope * (2 * Math.random() - 1), 1, stormParams.maxSlope * (2 * Math.random() - 1)).multiplyScalar(height).add(dest);
+      };
+    }
+    this.onLightningDown = stormParams.onLightningDown;
+    this.inited = false;
+    this.nextLightningTime = 0;
+    this.lightningsMeshes = [];
+    this.deadLightningsMeshes = [];
+    for (let i = 0; i < this.stormParams.maxLightnings; i++) {
+      const lightning = new LightningStrike.LightningStrike(LightningStrike.LightningStrike.copyParameters({}, this.lightningParameters));
+      const mesh = new THREE.Mesh(lightning, this.lightningMaterial);
+      this.deadLightningsMeshes.push(mesh);
+    }
+  }
+  update(time) {
+    if (!this.inited) {
+      this.nextLightningTime = this.getNextLightningTime(time) * Math.random();
+      this.inited = true;
+    }
+    if (time >= this.nextLightningTime) {
+      const lightningMesh = this.deadLightningsMeshes.pop();
+      if (lightningMesh) {
+        const lightningParams1 = LightningStrike.LightningStrike.copyParameters(
+          lightningMesh.geometry.rayParameters,
+          this.lightningParameters
+        );
+        lightningParams1.birthTime = time;
+        lightningParams1.deathTime = time + THREE.MathUtils.lerp(this.stormParams.lightningMinDuration, this.stormParams.lightningMaxDuration, Math.random());
+        this.onRayPosition(lightningParams1.sourceOffset, lightningParams1.destOffset);
+        lightningParams1.noiseSeed = Math.random();
+        this.add(lightningMesh);
+        this.lightningsMeshes.push(lightningMesh);
+      }
+      this.nextLightningTime = this.getNextLightningTime(time);
+    }
+    let i = 0, il = this.lightningsMeshes.length;
+    while (i < il) {
+      const mesh = this.lightningsMeshes[i];
+      const lightning = mesh.geometry;
+      const prevState = lightning.state;
+      lightning.update(time);
+      if (prevState === LightningStrike.LightningStrike.RAY_PROPAGATING && lightning.state > prevState) {
+        if (this.onLightningDown) {
+          this.onLightningDown(lightning);
+        }
+      }
+      if (lightning.state === LightningStrike.LightningStrike.RAY_EXTINGUISHED) {
+        this.lightningsMeshes.splice(this.lightningsMeshes.indexOf(mesh), 1);
+        this.deadLightningsMeshes.push(mesh);
+        this.remove(mesh);
+        il--;
+      } else {
+        i++;
+      }
+    }
+  }
+  getNextLightningTime(currentTime) {
+    return currentTime + THREE.MathUtils.lerp(this.stormParams.lightningMinPeriod, this.stormParams.lightningMaxPeriod, Math.random()) / (this.stormParams.maxLightnings + 1);
+  }
+  copy(source) {
+    super.copy(source);
+    this.stormParams.size = source.stormParams.size;
+    this.stormParams.minHeight = source.stormParams.minHeight;
+    this.stormParams.maxHeight = source.stormParams.maxHeight;
+    this.stormParams.maxSlope = source.stormParams.maxSlope;
+    this.stormParams.maxLightnings = source.stormParams.maxLightnings;
+    this.stormParams.lightningMinPeriod = source.stormParams.lightningMinPeriod;
+    this.stormParams.lightningMaxPeriod = source.stormParams.lightningMaxPeriod;
+    this.stormParams.lightningMinDuration = source.stormParams.lightningMinDuration;
+    this.stormParams.lightningMaxDuration = source.stormParams.lightningMaxDuration;
+    this.lightningParameters = LightningStrike.LightningStrike.copyParameters({}, source.lightningParameters);
+    this.lightningMaterial = source.stormParams.lightningMaterial;
+    this.onLightningDown = source.onLightningDown;
+    return this;
+  }
+  clone() {
+    return new this.constructor(this.stormParams).copy(this);
+  }
+}
+LightningStorm.prototype.isLightningStorm = true;
+exports.LightningStorm = LightningStorm;