@newkrok/three-particles 2.6.3 → 2.6.5

package/dist/index.js

@@ -1,6 +1,1578 @@
-export * from './js/effects/three-particles/three-particles-bezier.js';
-export * from './js/effects/three-particles/three-particles-curves.js';
-export * from './js/effects/three-particles/three-particles-enums.js';
-export * from './js/effects/three-particles/three-particles-modifiers.js';
-export * from './js/effects/three-particles/three-particles-utils.js';
-export * from './js/effects/three-particles/three-particles.js';
+import Easing from 'easing-functions';
+import * as THREE3 from 'three';
+import { ObjectUtils } from '@newkrok/three-utils';
+import { Gyroscope } from 'three/examples/jsm/misc/Gyroscope.js';
+import { FBM } from 'three-noise/build/three-noise.module.js';
+
+// src/js/effects/three-particles/three-particles-bezier.ts
+var cache = [];
+var nCr = (n, k) => {
+  let z = 1;
+  for (let i = 1; i <= k; i++) z *= (n + 1 - i) / i;
+  return z;
+};
+var createBezierCurveFunction = (particleSystemId, bezierPoints) => {
+  const cacheEntry = cache.find((item) => item.bezierPoints === bezierPoints);
+  if (cacheEntry) {
+    if (!cacheEntry.referencedBy.includes(particleSystemId))
+      cacheEntry.referencedBy.push(particleSystemId);
+    return cacheEntry.curveFunction;
+  }
+  const entry = {
+    referencedBy: [particleSystemId],
+    bezierPoints,
+    curveFunction: (percentage) => {
+      if (percentage < 0) return bezierPoints[0].y;
+      if (percentage > 1) return bezierPoints[bezierPoints.length - 1].y;
+      let start = 0;
+      let stop = bezierPoints.length - 1;
+      bezierPoints.find((point, index) => {
+        const result = percentage < (point.percentage ?? 0);
+        if (result) stop = index;
+        else if (point.percentage !== void 0) start = index;
+        return result;
+      });
+      const n = stop - start;
+      const calculatedPercentage = (percentage - (bezierPoints[start].percentage ?? 0)) / ((bezierPoints[stop].percentage ?? 1) - (bezierPoints[start].percentage ?? 0));
+      let value = 0;
+      for (let i = 0; i <= n; i++) {
+        const p = bezierPoints[start + i];
+        const c = nCr(n, i) * Math.pow(1 - calculatedPercentage, n - i) * Math.pow(calculatedPercentage, i);
+        value += c * p.y;
+      }
+      return value;
+    }
+  };
+  cache.push(entry);
+  return entry.curveFunction;
+};
+var removeBezierCurveFunction = (particleSystemId) => {
+  while (true) {
+    const index = cache.findIndex(
+      (item) => item.referencedBy.includes(particleSystemId)
+    );
+    if (index === -1) break;
+    const entry = cache[index];
+    entry.referencedBy = entry.referencedBy.filter(
+      (id) => id !== particleSystemId
+    );
+    if (entry.referencedBy.length === 0) cache.splice(index, 1);
+  }
+};
+var getBezierCacheSize = () => cache.length;
+var CurveFunctionId = /* @__PURE__ */ ((CurveFunctionId2) => {
+  CurveFunctionId2["BEZIER"] = "BEZIER";
+  CurveFunctionId2["LINEAR"] = "LINEAR";
+  CurveFunctionId2["QUADRATIC_IN"] = "QUADRATIC_IN";
+  CurveFunctionId2["QUADRATIC_OUT"] = "QUADRATIC_OUT";
+  CurveFunctionId2["QUADRATIC_IN_OUT"] = "QUADRATIC_IN_OUT";
+  CurveFunctionId2["CUBIC_IN"] = "CUBIC_IN";
+  CurveFunctionId2["CUBIC_OUT"] = "CUBIC_OUT";
+  CurveFunctionId2["CUBIC_IN_OUT"] = "CUBIC_IN_OUT";
+  CurveFunctionId2["QUARTIC_IN"] = "QUARTIC_IN";
+  CurveFunctionId2["QUARTIC_OUT"] = "QUARTIC_OUT";
+  CurveFunctionId2["QUARTIC_IN_OUT"] = "QUARTIC_IN_OUT";
+  CurveFunctionId2["QUINTIC_IN"] = "QUINTIC_IN";
+  CurveFunctionId2["QUINTIC_OUT"] = "QUINTIC_OUT";
+  CurveFunctionId2["QUINTIC_IN_OUT"] = "QUINTIC_IN_OUT";
+  CurveFunctionId2["SINUSOIDAL_IN"] = "SINUSOIDAL_IN";
+  CurveFunctionId2["SINUSOIDAL_OUT"] = "SINUSOIDAL_OUT";
+  CurveFunctionId2["SINUSOIDAL_IN_OUT"] = "SINUSOIDAL_IN_OUT";
+  CurveFunctionId2["EXPONENTIAL_IN"] = "EXPONENTIAL_IN";
+  CurveFunctionId2["EXPONENTIAL_OUT"] = "EXPONENTIAL_OUT";
+  CurveFunctionId2["EXPONENTIAL_IN_OUT"] = "EXPONENTIAL_IN_OUT";
+  CurveFunctionId2["CIRCULAR_IN"] = "CIRCULAR_IN";
+  CurveFunctionId2["CIRCULAR_OUT"] = "CIRCULAR_OUT";
+  CurveFunctionId2["CIRCULAR_IN_OUT"] = "CIRCULAR_IN_OUT";
+  CurveFunctionId2["ELASTIC_IN"] = "ELASTIC_IN";
+  CurveFunctionId2["ELASTIC_OUT"] = "ELASTIC_OUT";
+  CurveFunctionId2["ELASTIC_IN_OUT"] = "ELASTIC_IN_OUT";
+  CurveFunctionId2["BACK_IN"] = "BACK_IN";
+  CurveFunctionId2["BACK_OUT"] = "BACK_OUT";
+  CurveFunctionId2["BACK_IN_OUT"] = "BACK_IN_OUT";
+  CurveFunctionId2["BOUNCE_IN"] = "BOUNCE_IN";
+  CurveFunctionId2["BOUNCE_OUT"] = "BOUNCE_OUT";
+  CurveFunctionId2["BOUNCE_IN_OUT"] = "BOUNCE_IN_OUT";
+  return CurveFunctionId2;
+})(CurveFunctionId || {});
+var CurveFunctionIdMap = {
+  ["LINEAR" /* LINEAR */]: Easing.Linear.None,
+  ["QUADRATIC_IN" /* QUADRATIC_IN */]: Easing.Quadratic.In,
+  ["QUADRATIC_OUT" /* QUADRATIC_OUT */]: Easing.Quadratic.Out,
+  ["QUADRATIC_IN_OUT" /* QUADRATIC_IN_OUT */]: Easing.Quadratic.InOut,
+  ["CUBIC_IN" /* CUBIC_IN */]: Easing.Cubic.In,
+  ["CUBIC_OUT" /* CUBIC_OUT */]: Easing.Cubic.Out,
+  ["CUBIC_IN_OUT" /* CUBIC_IN_OUT */]: Easing.Cubic.InOut,
+  ["QUARTIC_IN" /* QUARTIC_IN */]: Easing.Quartic.In,
+  ["QUARTIC_OUT" /* QUARTIC_OUT */]: Easing.Quartic.Out,
+  ["QUARTIC_IN_OUT" /* QUARTIC_IN_OUT */]: Easing.Quartic.InOut,
+  ["QUINTIC_IN" /* QUINTIC_IN */]: Easing.Quintic.In,
+  ["QUINTIC_OUT" /* QUINTIC_OUT */]: Easing.Quintic.Out,
+  ["QUINTIC_IN_OUT" /* QUINTIC_IN_OUT */]: Easing.Quintic.InOut,
+  ["SINUSOIDAL_IN" /* SINUSOIDAL_IN */]: Easing.Sinusoidal.In,
+  ["SINUSOIDAL_OUT" /* SINUSOIDAL_OUT */]: Easing.Sinusoidal.Out,
+  ["SINUSOIDAL_IN_OUT" /* SINUSOIDAL_IN_OUT */]: Easing.Sinusoidal.InOut,
+  ["EXPONENTIAL_IN" /* EXPONENTIAL_IN */]: Easing.Exponential.In,
+  ["EXPONENTIAL_OUT" /* EXPONENTIAL_OUT */]: Easing.Exponential.Out,
+  ["EXPONENTIAL_IN_OUT" /* EXPONENTIAL_IN_OUT */]: Easing.Exponential.InOut,
+  ["CIRCULAR_IN" /* CIRCULAR_IN */]: Easing.Circular.In,
+  ["CIRCULAR_OUT" /* CIRCULAR_OUT */]: Easing.Circular.Out,
+  ["CIRCULAR_IN_OUT" /* CIRCULAR_IN_OUT */]: Easing.Circular.InOut,
+  ["ELASTIC_IN" /* ELASTIC_IN */]: Easing.Elastic.In,
+  ["ELASTIC_OUT" /* ELASTIC_OUT */]: Easing.Elastic.Out,
+  ["ELASTIC_IN_OUT" /* ELASTIC_IN_OUT */]: Easing.Elastic.InOut,
+  ["BACK_IN" /* BACK_IN */]: Easing.Back.In,
+  ["BACK_OUT" /* BACK_OUT */]: Easing.Back.Out,
+  ["BACK_IN_OUT" /* BACK_IN_OUT */]: Easing.Back.InOut,
+  ["BOUNCE_IN" /* BOUNCE_IN */]: Easing.Bounce.In,
+  ["BOUNCE_OUT" /* BOUNCE_OUT */]: Easing.Bounce.Out,
+  ["BOUNCE_IN_OUT" /* BOUNCE_IN_OUT */]: Easing.Bounce.InOut
+};
+var getCurveFunction = (curveFunctionId) => typeof curveFunctionId === "function" ? curveFunctionId : CurveFunctionIdMap[curveFunctionId];
+
+// src/js/effects/three-particles/three-particles-enums.ts
+var SimulationSpace = /* @__PURE__ */ ((SimulationSpace2) => {
+  SimulationSpace2["LOCAL"] = "LOCAL";
+  SimulationSpace2["WORLD"] = "WORLD";
+  return SimulationSpace2;
+})(SimulationSpace || {});
+var Shape = /* @__PURE__ */ ((Shape2) => {
+  Shape2["SPHERE"] = "SPHERE";
+  Shape2["CONE"] = "CONE";
+  Shape2["BOX"] = "BOX";
+  Shape2["CIRCLE"] = "CIRCLE";
+  Shape2["RECTANGLE"] = "RECTANGLE";
+  return Shape2;
+})(Shape || {});
+var EmitFrom = /* @__PURE__ */ ((EmitFrom2) => {
+  EmitFrom2["VOLUME"] = "VOLUME";
+  EmitFrom2["SHELL"] = "SHELL";
+  EmitFrom2["EDGE"] = "EDGE";
+  return EmitFrom2;
+})(EmitFrom || {});
+var TimeMode = /* @__PURE__ */ ((TimeMode2) => {
+  TimeMode2["LIFETIME"] = "LIFETIME";
+  TimeMode2["FPS"] = "FPS";
+  return TimeMode2;
+})(TimeMode || {});
+var LifeTimeCurve = /* @__PURE__ */ ((LifeTimeCurve2) => {
+  LifeTimeCurve2["BEZIER"] = "BEZIER";
+  LifeTimeCurve2["EASING"] = "EASING";
+  return LifeTimeCurve2;
+})(LifeTimeCurve || {});
+var calculateRandomPositionAndVelocityOnSphere = (position, quaternion, velocity, speed, {
+  radius,
+  radiusThickness,
+  arc
+}) => {
+  const u = Math.random() * (arc / 360);
+  const v = Math.random();
+  const randomizedDistanceRatio = Math.random();
+  const theta = 2 * Math.PI * u;
+  const phi = Math.acos(2 * v - 1);
+  const sinPhi = Math.sin(phi);
+  const xDirection = sinPhi * Math.cos(theta);
+  const yDirection = sinPhi * Math.sin(theta);
+  const zDirection = Math.cos(phi);
+  const normalizedThickness = 1 - radiusThickness;
+  position.x = radius * normalizedThickness * xDirection + radius * radiusThickness * randomizedDistanceRatio * xDirection;
+  position.y = radius * normalizedThickness * yDirection + radius * radiusThickness * randomizedDistanceRatio * yDirection;
+  position.z = radius * normalizedThickness * zDirection + radius * radiusThickness * randomizedDistanceRatio * zDirection;
+  position.applyQuaternion(quaternion);
+  const speedMultiplierByPosition = 1 / position.length();
+  velocity.set(
+    position.x * speedMultiplierByPosition * speed,
+    position.y * speedMultiplierByPosition * speed,
+    position.z * speedMultiplierByPosition * speed
+  );
+  velocity.applyQuaternion(quaternion);
+};
+var calculateRandomPositionAndVelocityOnCone = (position, quaternion, velocity, speed, {
+  radius,
+  radiusThickness,
+  arc,
+  angle = 90
+}) => {
+  const theta = 2 * Math.PI * Math.random() * (arc / 360);
+  const randomizedDistanceRatio = Math.random();
+  const xDirection = Math.cos(theta);
+  const yDirection = Math.sin(theta);
+  const normalizedThickness = 1 - radiusThickness;
+  position.x = radius * normalizedThickness * xDirection + radius * radiusThickness * randomizedDistanceRatio * xDirection;
+  position.y = radius * normalizedThickness * yDirection + radius * radiusThickness * randomizedDistanceRatio * yDirection;
+  position.z = 0;
+  position.applyQuaternion(quaternion);
+  const positionLength = position.length();
+  const normalizedAngle = Math.abs(
+    positionLength / radius * THREE3.MathUtils.degToRad(angle)
+  );
+  const sinNormalizedAngle = Math.sin(normalizedAngle);
+  const speedMultiplierByPosition = 1 / positionLength;
+  velocity.set(
+    position.x * sinNormalizedAngle * speedMultiplierByPosition * speed,
+    position.y * sinNormalizedAngle * speedMultiplierByPosition * speed,
+    Math.cos(normalizedAngle) * speed
+  );
+  velocity.applyQuaternion(quaternion);
+};
+var calculateRandomPositionAndVelocityOnBox = (position, quaternion, velocity, speed, { scale, emitFrom }) => {
+  const _scale = scale;
+  switch (emitFrom) {
+    case "VOLUME" /* VOLUME */:
+      position.x = Math.random() * _scale.x - _scale.x / 2;
+      position.y = Math.random() * _scale.y - _scale.y / 2;
+      position.z = Math.random() * _scale.z - _scale.z / 2;
+      break;
+    case "SHELL" /* SHELL */:
+      const side = Math.floor(Math.random() * 6);
+      const perpendicularAxis = side % 3;
+      const shellResult = [];
+      shellResult[perpendicularAxis] = side > 2 ? 1 : 0;
+      shellResult[(perpendicularAxis + 1) % 3] = Math.random();
+      shellResult[(perpendicularAxis + 2) % 3] = Math.random();
+      position.x = shellResult[0] * _scale.x - _scale.x / 2;
+      position.y = shellResult[1] * _scale.y - _scale.y / 2;
+      position.z = shellResult[2] * _scale.z - _scale.z / 2;
+      break;
+    case "EDGE" /* EDGE */:
+      const side2 = Math.floor(Math.random() * 6);
+      const perpendicularAxis2 = side2 % 3;
+      const edge = Math.floor(Math.random() * 4);
+      const edgeResult = [];
+      edgeResult[perpendicularAxis2] = side2 > 2 ? 1 : 0;
+      edgeResult[(perpendicularAxis2 + 1) % 3] = edge < 2 ? Math.random() : edge - 2;
+      edgeResult[(perpendicularAxis2 + 2) % 3] = edge < 2 ? edge : Math.random();
+      position.x = edgeResult[0] * _scale.x - _scale.x / 2;
+      position.y = edgeResult[1] * _scale.y - _scale.y / 2;
+      position.z = edgeResult[2] * _scale.z - _scale.z / 2;
+      break;
+  }
+  position.applyQuaternion(quaternion);
+  velocity.set(0, 0, speed);
+  velocity.applyQuaternion(quaternion);
+};
+var calculateRandomPositionAndVelocityOnCircle = (position, quaternion, velocity, speed, {
+  radius,
+  radiusThickness,
+  arc
+}) => {
+  const theta = 2 * Math.PI * Math.random() * (arc / 360);
+  const randomizedDistanceRatio = Math.random();
+  const xDirection = Math.cos(theta);
+  const yDirection = Math.sin(theta);
+  const normalizedThickness = 1 - radiusThickness;
+  position.x = radius * normalizedThickness * xDirection + radius * radiusThickness * randomizedDistanceRatio * xDirection;
+  position.y = radius * normalizedThickness * yDirection + radius * radiusThickness * randomizedDistanceRatio * yDirection;
+  position.z = 0;
+  position.applyQuaternion(quaternion);
+  const positionLength = position.length();
+  const speedMultiplierByPosition = 1 / positionLength;
+  velocity.set(
+    position.x * speedMultiplierByPosition * speed,
+    position.y * speedMultiplierByPosition * speed,
+    0
+  );
+  velocity.applyQuaternion(quaternion);
+};
+var calculateRandomPositionAndVelocityOnRectangle = (position, quaternion, velocity, speed, { rotation, scale }) => {
+  const _scale = scale;
+  const _rotation = rotation;
+  const xOffset = Math.random() * _scale.x - _scale.x / 2;
+  const yOffset = Math.random() * _scale.y - _scale.y / 2;
+  const rotationX = THREE3.MathUtils.degToRad(_rotation.x);
+  const rotationY = THREE3.MathUtils.degToRad(_rotation.y);
+  position.x = xOffset * Math.cos(rotationY);
+  position.y = yOffset * Math.cos(rotationX);
+  position.z = xOffset * Math.sin(rotationY) - yOffset * Math.sin(rotationX);
+  position.applyQuaternion(quaternion);
+  velocity.set(0, 0, speed);
+  velocity.applyQuaternion(quaternion);
+};
+var createDefaultParticleTexture = () => {
+  try {
+    const canvas = document.createElement("canvas");
+    const size = 64;
+    canvas.width = size;
+    canvas.height = size;
+    const context = canvas.getContext("2d");
+    if (context) {
+      const centerX = size / 2;
+      const centerY = size / 2;
+      const radius = size / 2 - 2;
+      context.beginPath();
+      context.arc(centerX, centerY, radius, 0, 2 * Math.PI, false);
+      context.fillStyle = "white";
+      context.fill();
+      const texture = new THREE3.CanvasTexture(canvas);
+      texture.needsUpdate = true;
+      return texture;
+    } else {
+      console.warn(
+        "Could not get 2D context to generate default particle texture."
+      );
+      return null;
+    }
+  } catch (error) {
+    console.warn("Error creating default particle texture:", error);
+    return null;
+  }
+};
+var isLifeTimeCurve = (value) => {
+  return typeof value !== "number" && "type" in value;
+};
+var getCurveFunctionFromConfig = (particleSystemId, lifetimeCurve) => {
+  if (lifetimeCurve.type === "BEZIER" /* BEZIER */) {
+    return createBezierCurveFunction(
+      particleSystemId,
+      lifetimeCurve.bezierPoints
+    );
+  }
+  if (lifetimeCurve.type === "EASING" /* EASING */) {
+    return lifetimeCurve.curveFunction;
+  }
+  throw new Error(`Unsupported value type: ${lifetimeCurve}`);
+};
+var calculateValue = (particleSystemId, value, time = 0) => {
+  if (typeof value === "number") {
+    return value;
+  }
+  if ("min" in value && "max" in value) {
+    if (value.min === value.max) {
+      return value.min ?? 0;
+    }
+    return THREE3.MathUtils.randFloat(value.min ?? 0, value.max ?? 1);
+  }
+  const lifetimeCurve = value;
+  return getCurveFunctionFromConfig(particleSystemId, lifetimeCurve)(time) * (lifetimeCurve.scale ?? 1);
+};
+
+// src/js/effects/three-particles/three-particles-modifiers.ts
+var noiseInput = new THREE3.Vector3(0, 0, 0);
+var orbitalEuler = new THREE3.Euler();
+var applyModifiers = ({
+  delta,
+  generalData,
+  normalizedConfig,
+  attributes,
+  particleLifetimePercentage,
+  particleIndex
+}) => {
+  const {
+    particleSystemId,
+    startValues,
+    lifetimeValues,
+    linearVelocityData,
+    orbitalVelocityData,
+    noise
+  } = generalData;
+  const positionIndex = particleIndex * 3;
+  const positionArr = attributes.position.array;
+  if (linearVelocityData) {
+    const { speed, valueModifiers } = linearVelocityData[particleIndex];
+    const normalizedXSpeed = valueModifiers.x ? valueModifiers.x(particleLifetimePercentage) : speed.x;
+    const normalizedYSpeed = valueModifiers.y ? valueModifiers.y(particleLifetimePercentage) : speed.y;
+    const normalizedZSpeed = valueModifiers.z ? valueModifiers.z(particleLifetimePercentage) : speed.z;
+    positionArr[positionIndex] += normalizedXSpeed * delta;
+    positionArr[positionIndex + 1] += normalizedYSpeed * delta;
+    positionArr[positionIndex + 2] += normalizedZSpeed * delta;
+    attributes.position.needsUpdate = true;
+  }
+  if (orbitalVelocityData) {
+    const { speed, positionOffset, valueModifiers } = orbitalVelocityData[particleIndex];
+    positionArr[positionIndex] -= positionOffset.x;
+    positionArr[positionIndex + 1] -= positionOffset.y;
+    positionArr[positionIndex + 2] -= positionOffset.z;
+    const normalizedXSpeed = valueModifiers.x ? valueModifiers.x(particleLifetimePercentage) : speed.x;
+    const normalizedYSpeed = valueModifiers.y ? valueModifiers.y(particleLifetimePercentage) : speed.y;
+    const normalizedZSpeed = valueModifiers.z ? valueModifiers.z(particleLifetimePercentage) : speed.z;
+    orbitalEuler.set(
+      normalizedXSpeed * delta,
+      normalizedZSpeed * delta,
+      normalizedYSpeed * delta
+    );
+    positionOffset.applyEuler(orbitalEuler);
+    positionArr[positionIndex] += positionOffset.x;
+    positionArr[positionIndex + 1] += positionOffset.y;
+    positionArr[positionIndex + 2] += positionOffset.z;
+    attributes.position.needsUpdate = true;
+  }
+  if (normalizedConfig.sizeOverLifetime.isActive) {
+    const multiplier = calculateValue(
+      particleSystemId,
+      normalizedConfig.sizeOverLifetime.lifetimeCurve,
+      particleLifetimePercentage
+    );
+    attributes.size.array[particleIndex] = startValues.startSize[particleIndex] * multiplier;
+    attributes.size.needsUpdate = true;
+  }
+  if (normalizedConfig.opacityOverLifetime.isActive) {
+    const multiplier = calculateValue(
+      particleSystemId,
+      normalizedConfig.opacityOverLifetime.lifetimeCurve,
+      particleLifetimePercentage
+    );
+    attributes.colorA.array[particleIndex] = startValues.startOpacity[particleIndex] * multiplier;
+    attributes.colorA.needsUpdate = true;
+  }
+  if (normalizedConfig.colorOverLifetime.isActive) {
+    const rMultiplier = calculateValue(
+      particleSystemId,
+      normalizedConfig.colorOverLifetime.r,
+      particleLifetimePercentage
+    );
+    const gMultiplier = calculateValue(
+      particleSystemId,
+      normalizedConfig.colorOverLifetime.g,
+      particleLifetimePercentage
+    );
+    const bMultiplier = calculateValue(
+      particleSystemId,
+      normalizedConfig.colorOverLifetime.b,
+      particleLifetimePercentage
+    );
+    attributes.colorR.array[particleIndex] = startValues.startColorR[particleIndex] * rMultiplier;
+    attributes.colorG.array[particleIndex] = startValues.startColorG[particleIndex] * gMultiplier;
+    attributes.colorB.array[particleIndex] = startValues.startColorB[particleIndex] * bMultiplier;
+    attributes.colorR.needsUpdate = true;
+    attributes.colorG.needsUpdate = true;
+    attributes.colorB.needsUpdate = true;
+  }
+  if (lifetimeValues.rotationOverLifetime) {
+    attributes.rotation.array[particleIndex] += lifetimeValues.rotationOverLifetime[particleIndex] * delta * 0.02;
+    attributes.rotation.needsUpdate = true;
+  }
+  if (noise.isActive) {
+    const {
+      sampler,
+      strength,
+      noisePower,
+      offsets,
+      positionAmount,
+      rotationAmount,
+      sizeAmount
+    } = noise;
+    let noiseOnPosition;
+    const noisePosition = (particleLifetimePercentage + (offsets ? offsets[particleIndex] : 0)) * 10 * strength;
+    noiseInput.set(noisePosition, 0, 0);
+    noiseOnPosition = sampler.get3(noiseInput);
+    positionArr[positionIndex] += noiseOnPosition * noisePower * positionAmount;
+    if (rotationAmount !== 0) {
+      attributes.rotation.array[particleIndex] += noiseOnPosition * noisePower * rotationAmount;
+      attributes.rotation.needsUpdate = true;
+    }
+    if (sizeAmount !== 0) {
+      attributes.size.array[particleIndex] += noiseOnPosition * noisePower * sizeAmount;
+      attributes.size.needsUpdate = true;
+    }
+    noiseInput.set(noisePosition, noisePosition, 0);
+    noiseOnPosition = sampler.get3(noiseInput);
+    positionArr[positionIndex + 1] += noiseOnPosition * noisePower * positionAmount;
+    noiseInput.set(noisePosition, noisePosition, noisePosition);
+    noiseOnPosition = sampler.get3(noiseInput);
+    positionArr[positionIndex + 2] += noiseOnPosition * noisePower * positionAmount;
+    attributes.position.needsUpdate = true;
+  }
+};
+
+// src/js/effects/three-particles/shaders/particle-system-fragment-shader.glsl.ts
+var ParticleSystemFragmentShader = `
+  uniform sampler2D map;
+  uniform float elapsed;
+  uniform float fps;
+  uniform bool useFPSForFrameIndex;
+  uniform vec2 tiles;
+  uniform bool discardBackgroundColor;
+  uniform vec3 backgroundColor;
+  uniform float backgroundColorTolerance;
+
+  varying vec4 vColor;
+  varying float vLifetime;
+  varying float vStartLifetime;
+  varying float vRotation;
+  varying float vStartFrame;
+
+  #include <common>
+  #include <logdepthbuf_pars_fragment>
+
+  void main()
+  {
+    gl_FragColor = vColor;
+    float mid = 0.5;
+
+    float frameIndex = round(vStartFrame) + (
+      useFPSForFrameIndex == true
+        ? fps == 0.0
+            ? 0.0
+            : max((vLifetime / 1000.0) * fps, 0.0)
+        : max(min(floor(min(vLifetime / vStartLifetime, 1.0) * (tiles.x * tiles.y)), tiles.x * tiles.y - 1.0), 0.0)
+    );
+        
+    float spriteXIndex = floor(mod(frameIndex, tiles.x));
+    float spriteYIndex = floor(mod(frameIndex / tiles.x, tiles.y));
+
+    vec2 frameUV = vec2(
+      gl_PointCoord.x / tiles.x + spriteXIndex / tiles.x,
+      gl_PointCoord.y / tiles.y + spriteYIndex / tiles.y);
+
+    vec2 center = vec2(0.5, 0.5);
+    vec2 centeredPoint = gl_PointCoord - center;
+
+    mat2 rotation = mat2(
+      cos(vRotation), sin(vRotation),
+      -sin(vRotation), cos(vRotation)
+    );
+
+    centeredPoint = rotation * centeredPoint;
+    vec2 centeredMiddlePoint = vec2(
+      centeredPoint.x + center.x,
+      centeredPoint.y + center.y
+    );
+
+    float dist = distance(centeredMiddlePoint, center);
+    if (dist > 0.5) discard;
+
+    vec2 uvPoint = vec2(
+      centeredMiddlePoint.x / tiles.x + spriteXIndex / tiles.x,
+      centeredMiddlePoint.y / tiles.y + spriteYIndex / tiles.y
+    );
+
+    vec4 rotatedTexture = texture2D(map, uvPoint);
+
+    gl_FragColor = gl_FragColor * rotatedTexture;
+
+    if (discardBackgroundColor && abs(length(rotatedTexture.rgb - backgroundColor.rgb)) < backgroundColorTolerance) discard;
+    
+    #include <logdepthbuf_fragment>
+  }
+`;
+var particle_system_fragment_shader_glsl_default = ParticleSystemFragmentShader;
+
+// src/js/effects/three-particles/shaders/particle-system-vertex-shader.glsl.ts
+var ParticleSystemVertexShader = `
+  attribute float size;
+  attribute float colorR;
+  attribute float colorG;
+  attribute float colorB;
+  attribute float colorA;
+  attribute float lifetime;
+  attribute float startLifetime;
+  attribute float rotation;
+  attribute float startFrame;
+
+  varying mat4 vPosition;
+  varying vec4 vColor;
+  varying float vLifetime;
+  varying float vStartLifetime;
+  varying float vRotation;
+  varying float vStartFrame;
+
+  #include <common>
+  #include <logdepthbuf_pars_vertex>
+
+  void main()
+  {
+    vColor = vec4(colorR, colorG, colorB, colorA);
+    vLifetime = lifetime;
+    vStartLifetime = startLifetime;
+    vRotation = rotation;
+    vStartFrame = startFrame;
+
+    vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
+    gl_PointSize = size * (100.0 / length(mvPosition.xyz));
+    gl_Position = projectionMatrix * mvPosition;
+
+    #include <logdepthbuf_vertex>
+  }
+`;
+var particle_system_vertex_shader_glsl_default = ParticleSystemVertexShader;
+
+// src/js/effects/three-particles/three-particles.ts
+var _particleSystemId = 0;
+var createdParticleSystems = [];
+var _lastWorldPositionSnapshot = new THREE3.Vector3();
+var _distanceStep = { x: 0, y: 0, z: 0 };
+var _tempPosition = { x: 0, y: 0, z: 0 };
+var _modifierParams = {
+  delta: 0,
+  generalData: null,
+  normalizedConfig: null,
+  attributes: null,
+  particleLifetimePercentage: 0,
+  particleIndex: 0
+};
+var blendingMap = {
+  "THREE.NoBlending": THREE3.NoBlending,
+  "THREE.NormalBlending": THREE3.NormalBlending,
+  "THREE.AdditiveBlending": THREE3.AdditiveBlending,
+  "THREE.SubtractiveBlending": THREE3.SubtractiveBlending,
+  "THREE.MultiplyBlending": THREE3.MultiplyBlending
+};
+var getDefaultParticleSystemConfig = () => JSON.parse(JSON.stringify(DEFAULT_PARTICLE_SYSTEM_CONFIG));
+var DEFAULT_PARTICLE_SYSTEM_CONFIG = {
+  transform: {
+    position: new THREE3.Vector3(),
+    rotation: new THREE3.Vector3(),
+    scale: new THREE3.Vector3(1, 1, 1)
+  },
+  duration: 5,
+  looping: true,
+  startDelay: 0,
+  startLifetime: 5,
+  startSpeed: 1,
+  startSize: 1,
+  startOpacity: 1,
+  startRotation: 0,
+  startColor: {
+    min: { r: 1, g: 1, b: 1 },
+    max: { r: 1, g: 1, b: 1 }
+  },
+  gravity: 0,
+  simulationSpace: "LOCAL" /* LOCAL */,
+  maxParticles: 100,
+  emission: {
+    rateOverTime: 10,
+    rateOverDistance: 0,
+    bursts: []
+  },
+  shape: {
+    shape: "SPHERE" /* SPHERE */,
+    sphere: {
+      radius: 1,
+      radiusThickness: 1,
+      arc: 360
+    },
+    cone: {
+      angle: 25,
+      radius: 1,
+      radiusThickness: 1,
+      arc: 360
+    },
+    circle: {
+      radius: 1,
+      radiusThickness: 1,
+      arc: 360
+    },
+    rectangle: {
+      rotation: { x: 0, y: 0 },
+      // TODO: add z rotation
+      scale: { x: 1, y: 1 }
+    },
+    box: {
+      scale: { x: 1, y: 1, z: 1 },
+      emitFrom: "VOLUME" /* VOLUME */
+    }
+  },
+  map: void 0,
+  renderer: {
+    blending: THREE3.NormalBlending,
+    discardBackgroundColor: false,
+    backgroundColorTolerance: 1,
+    backgroundColor: { r: 1, g: 1, b: 1 },
+    transparent: true,
+    depthTest: true,
+    depthWrite: false
+  },
+  velocityOverLifetime: {
+    isActive: false,
+    linear: {
+      x: 0,
+      y: 0,
+      z: 0
+    },
+    orbital: {
+      x: 0,
+      y: 0,
+      z: 0
+    }
+  },
+  sizeOverLifetime: {
+    isActive: false,
+    lifetimeCurve: {
+      type: "BEZIER" /* BEZIER */,
+      scale: 1,
+      bezierPoints: [
+        { x: 0, y: 0, percentage: 0 },
+        { x: 1, y: 1, percentage: 1 }
+      ]
+    }
+  },
+  colorOverLifetime: {
+    isActive: false,
+    r: {
+      type: "BEZIER" /* BEZIER */,
+      scale: 1,
+      bezierPoints: [
+        { x: 0, y: 1, percentage: 0 },
+        { x: 1, y: 1, percentage: 1 }
+      ]
+    },
+    g: {
+      type: "BEZIER" /* BEZIER */,
+      scale: 1,
+      bezierPoints: [
+        { x: 0, y: 1, percentage: 0 },
+        { x: 1, y: 1, percentage: 1 }
+      ]
+    },
+    b: {
+      type: "BEZIER" /* BEZIER */,
+      scale: 1,
+      bezierPoints: [
+        { x: 0, y: 1, percentage: 0 },
+        { x: 1, y: 1, percentage: 1 }
+      ]
+    }
+  },
+  opacityOverLifetime: {
+    isActive: false,
+    lifetimeCurve: {
+      type: "BEZIER" /* BEZIER */,
+      scale: 1,
+      bezierPoints: [
+        { x: 0, y: 0, percentage: 0 },
+        { x: 1, y: 1, percentage: 1 }
+      ]
+    }
+  },
+  rotationOverLifetime: {
+    isActive: false,
+    min: 0,
+    max: 0
+  },
+  noise: {
+    isActive: false,
+    useRandomOffset: false,
+    strength: 1,
+    frequency: 0.5,
+    octaves: 1,
+    positionAmount: 1,
+    rotationAmount: 0,
+    sizeAmount: 0
+  },
+  textureSheetAnimation: {
+    tiles: new THREE3.Vector2(1, 1),
+    timeMode: "LIFETIME" /* LIFETIME */,
+    fps: 30,
+    startFrame: 0
+  }
+};
+var createFloat32Attributes = ({
+  geometry,
+  propertyName,
+  maxParticles,
+  factory
+}) => {
+  const array = new Float32Array(maxParticles);
+  if (typeof factory === "function") {
+    for (let i = 0; i < maxParticles; i++) {
+      array[i] = factory(void 0, i);
+    }
+  } else {
+    array.fill(factory);
+  }
+  geometry.setAttribute(propertyName, new THREE3.BufferAttribute(array, 1));
+};
+var calculatePositionAndVelocity = (generalData, { shape, sphere, cone, circle, rectangle, box }, startSpeed, position, velocity) => {
+  const calculatedStartSpeed = calculateValue(
+    generalData.particleSystemId,
+    startSpeed,
+    generalData.normalizedLifetimePercentage
+  );
+  switch (shape) {
+    case "SPHERE" /* SPHERE */:
+      calculateRandomPositionAndVelocityOnSphere(
+        position,
+        generalData.wrapperQuaternion,
+        velocity,
+        calculatedStartSpeed,
+        sphere
+      );
+      break;
+    case "CONE" /* CONE */:
+      calculateRandomPositionAndVelocityOnCone(
+        position,
+        generalData.wrapperQuaternion,
+        velocity,
+        calculatedStartSpeed,
+        cone
+      );
+      break;
+    case "CIRCLE" /* CIRCLE */:
+      calculateRandomPositionAndVelocityOnCircle(
+        position,
+        generalData.wrapperQuaternion,
+        velocity,
+        calculatedStartSpeed,
+        circle
+      );
+      break;
+    case "RECTANGLE" /* RECTANGLE */:
+      calculateRandomPositionAndVelocityOnRectangle(
+        position,
+        generalData.wrapperQuaternion,
+        velocity,
+        calculatedStartSpeed,
+        rectangle
+      );
+      break;
+    case "BOX" /* BOX */:
+      calculateRandomPositionAndVelocityOnBox(
+        position,
+        generalData.wrapperQuaternion,
+        velocity,
+        calculatedStartSpeed,
+        box
+      );
+      break;
+  }
+};
+var destroyParticleSystem = (particleSystem) => {
+  createdParticleSystems = createdParticleSystems.filter(
+    ({
+      particleSystem: savedParticleSystem,
+      wrapper,
+      generalData: { particleSystemId }
+    }) => {
+      if (savedParticleSystem !== particleSystem && wrapper !== particleSystem) {
+        return true;
+      }
+      removeBezierCurveFunction(particleSystemId);
+      savedParticleSystem.geometry.dispose();
+      if (Array.isArray(savedParticleSystem.material))
+        savedParticleSystem.material.forEach((material) => material.dispose());
+      else savedParticleSystem.material.dispose();
+      if (savedParticleSystem.parent)
+        savedParticleSystem.parent.remove(savedParticleSystem);
+      return false;
+    }
+  );
+};
+var createParticleSystem = (config = DEFAULT_PARTICLE_SYSTEM_CONFIG, externalNow) => {
+  const now = externalNow || Date.now();
+  const generalData = {
+    particleSystemId: _particleSystemId++,
+    normalizedLifetimePercentage: 0,
+    distanceFromLastEmitByDistance: 0,
+    lastWorldPosition: new THREE3.Vector3(-99999),
+    currentWorldPosition: new THREE3.Vector3(-99999),
+    worldPositionChange: new THREE3.Vector3(),
+    worldQuaternion: new THREE3.Quaternion(),
+    wrapperQuaternion: new THREE3.Quaternion(),
+    lastWorldQuaternion: new THREE3.Quaternion(-99999),
+    worldEuler: new THREE3.Euler(),
+    gravityVelocity: new THREE3.Vector3(0, 0, 0),
+    startValues: {},
+    linearVelocityData: void 0,
+    orbitalVelocityData: void 0,
+    lifetimeValues: {},
+    creationTimes: [],
+    noise: {
+      isActive: false,
+      strength: 0,
+      noisePower: 0,
+      positionAmount: 0,
+      rotationAmount: 0,
+      sizeAmount: 0
+    },
+    isEnabled: true
+  };
+  const normalizedConfig = ObjectUtils.deepMerge(
+    DEFAULT_PARTICLE_SYSTEM_CONFIG,
+    config,
+    { applyToFirstObject: false, skippedProperties: [] }
+  );
+  let particleMap = normalizedConfig.map || createDefaultParticleTexture();
+  const {
+    transform,
+    duration,
+    looping,
+    startDelay,
+    startLifetime,
+    startSpeed,
+    startSize,
+    startRotation,
+    startColor,
+    startOpacity,
+    gravity,
+    simulationSpace,
+    maxParticles,
+    emission,
+    shape,
+    renderer,
+    noise,
+    velocityOverLifetime,
+    onUpdate,
+    onComplete,
+    textureSheetAnimation
+  } = normalizedConfig;
+  if (typeof renderer?.blending === "string")
+    renderer.blending = blendingMap[renderer.blending];
+  const startPositions = Array.from(
+    { length: maxParticles },
+    () => new THREE3.Vector3()
+  );
+  const velocities = Array.from(
+    { length: maxParticles },
+    () => new THREE3.Vector3()
+  );
+  generalData.creationTimes = Array.from({ length: maxParticles }, () => 0);
+  const freeList = Array.from(
+    { length: maxParticles },
+    (_, i) => maxParticles - 1 - i
+  );
+  if (velocityOverLifetime.isActive) {
+    generalData.linearVelocityData = Array.from(
+      { length: maxParticles },
+      () => ({
+        speed: new THREE3.Vector3(
+          velocityOverLifetime.linear.x ? calculateValue(
+            generalData.particleSystemId,
+            velocityOverLifetime.linear.x,
+            0
+          ) : 0,
+          velocityOverLifetime.linear.y ? calculateValue(
+            generalData.particleSystemId,
+            velocityOverLifetime.linear.y,
+            0
+          ) : 0,
+          velocityOverLifetime.linear.z ? calculateValue(
+            generalData.particleSystemId,
+            velocityOverLifetime.linear.z,
+            0
+          ) : 0
+        ),
+        valueModifiers: {
+          x: isLifeTimeCurve(velocityOverLifetime.linear.x || 0) ? getCurveFunctionFromConfig(
+            generalData.particleSystemId,
+            velocityOverLifetime.linear.x
+          ) : void 0,
+          y: isLifeTimeCurve(velocityOverLifetime.linear.y || 0) ? getCurveFunctionFromConfig(
+            generalData.particleSystemId,
+            velocityOverLifetime.linear.y
+          ) : void 0,
+          z: isLifeTimeCurve(velocityOverLifetime.linear.z || 0) ? getCurveFunctionFromConfig(
+            generalData.particleSystemId,
+            velocityOverLifetime.linear.z
+          ) : void 0
+        }
+      })
+    );
+    generalData.orbitalVelocityData = Array.from(
+      { length: maxParticles },
+      () => ({
+        speed: new THREE3.Vector3(
+          velocityOverLifetime.orbital.x ? calculateValue(
+            generalData.particleSystemId,
+            velocityOverLifetime.orbital.x,
+            0
+          ) : 0,
+          velocityOverLifetime.orbital.y ? calculateValue(
+            generalData.particleSystemId,
+            velocityOverLifetime.orbital.y,
+            0
+          ) : 0,
+          velocityOverLifetime.orbital.z ? calculateValue(
+            generalData.particleSystemId,
+            velocityOverLifetime.orbital.z,
+            0
+          ) : 0
+        ),
+        valueModifiers: {
+          x: isLifeTimeCurve(velocityOverLifetime.orbital.x || 0) ? getCurveFunctionFromConfig(
+            generalData.particleSystemId,
+            velocityOverLifetime.orbital.x
+          ) : void 0,
+          y: isLifeTimeCurve(velocityOverLifetime.orbital.y || 0) ? getCurveFunctionFromConfig(
+            generalData.particleSystemId,
+            velocityOverLifetime.orbital.y
+          ) : void 0,
+          z: isLifeTimeCurve(velocityOverLifetime.orbital.z || 0) ? getCurveFunctionFromConfig(
+            generalData.particleSystemId,
+            velocityOverLifetime.orbital.z
+          ) : void 0
+        },
+        positionOffset: new THREE3.Vector3()
+      })
+    );
+  }
+  const startValueKeys = [
+    "startSize",
+    "startOpacity"
+  ];
+  startValueKeys.forEach((key) => {
+    generalData.startValues[key] = Array.from(
+      { length: maxParticles },
+      () => calculateValue(
+        generalData.particleSystemId,
+        normalizedConfig[key],
+        0
+      )
+    );
+  });
+  generalData.startValues.startColorR = Array.from(
+    { length: maxParticles },
+    () => 0
+  );
+  generalData.startValues.startColorG = Array.from(
+    { length: maxParticles },
+    () => 0
+  );
+  generalData.startValues.startColorB = Array.from(
+    { length: maxParticles },
+    () => 0
+  );
+  const lifetimeValueKeys = [
+    "rotationOverLifetime"
+  ];
+  lifetimeValueKeys.forEach((key) => {
+    const value = normalizedConfig[key];
+    if (value.isActive)
+      generalData.lifetimeValues[key] = Array.from(
+        { length: maxParticles },
+        () => THREE3.MathUtils.randFloat(value.min, value.max)
+      );
+  });
+  generalData.noise = {
+    isActive: noise.isActive,
+    strength: noise.strength,
+    noisePower: 0.15 * noise.strength,
+    positionAmount: noise.positionAmount,
+    rotationAmount: noise.rotationAmount,
+    sizeAmount: noise.sizeAmount,
+    sampler: noise.isActive ? new FBM({
+      seed: Math.random(),
+      scale: noise.frequency,
+      octaves: noise.octaves
+    }) : void 0,
+    offsets: noise.useRandomOffset ? Array.from({ length: maxParticles }, () => Math.random() * 100) : void 0
+  };
+  if (emission.bursts && emission.bursts.length > 0) {
+    generalData.burstStates = emission.bursts.map(() => ({
+      cyclesExecuted: 0,
+      lastCycleTime: 0,
+      probabilityPassed: false
+    }));
+  }
+  const material = new THREE3.ShaderMaterial({
+    uniforms: {
+      elapsed: {
+        value: 0
+      },
+      map: {
+        value: particleMap
+      },
+      tiles: {
+        value: textureSheetAnimation.tiles
+      },
+      fps: {
+        value: textureSheetAnimation.fps
+      },
+      useFPSForFrameIndex: {
+        value: textureSheetAnimation.timeMode === "FPS" /* FPS */
+      },
+      backgroundColor: {
+        value: renderer.backgroundColor
+      },
+      discardBackgroundColor: {
+        value: renderer.discardBackgroundColor
+      },
+      backgroundColorTolerance: {
+        value: renderer.backgroundColorTolerance
+      }
+    },
+    vertexShader: particle_system_vertex_shader_glsl_default,
+    fragmentShader: particle_system_fragment_shader_glsl_default,
+    transparent: renderer.transparent,
+    blending: renderer.blending,
+    depthTest: renderer.depthTest,
+    depthWrite: renderer.depthWrite
+  });
+  const geometry = new THREE3.BufferGeometry();
+  for (let i = 0; i < maxParticles; i++)
+    calculatePositionAndVelocity(
+      generalData,
+      shape,
+      startSpeed,
+      startPositions[i],
+      velocities[i]
+    );
+  const positionArray = new Float32Array(maxParticles * 3);
+  for (let i = 0; i < maxParticles; i++) {
+    positionArray[i * 3] = startPositions[i].x;
+    positionArray[i * 3 + 1] = startPositions[i].y;
+    positionArray[i * 3 + 2] = startPositions[i].z;
+  }
+  geometry.setAttribute(
+    "position",
+    new THREE3.BufferAttribute(positionArray, 3)
+  );
+  createFloat32Attributes({
+    geometry,
+    propertyName: "isActive",
+    maxParticles,
+    factory: 0
+  });
+  createFloat32Attributes({
+    geometry,
+    propertyName: "lifetime",
+    maxParticles,
+    factory: 0
+  });
+  createFloat32Attributes({
+    geometry,
+    propertyName: "startLifetime",
+    maxParticles,
+    factory: () => calculateValue(generalData.particleSystemId, startLifetime, 0) * 1e3
+  });
+  createFloat32Attributes({
+    geometry,
+    propertyName: "startFrame",
+    maxParticles,
+    factory: () => textureSheetAnimation.startFrame ? calculateValue(
+      generalData.particleSystemId,
+      textureSheetAnimation.startFrame,
+      0
+    ) : 0
+  });
+  createFloat32Attributes({
+    geometry,
+    propertyName: "opacity",
+    maxParticles,
+    factory: () => calculateValue(generalData.particleSystemId, startOpacity, 0)
+  });
+  createFloat32Attributes({
+    geometry,
+    propertyName: "rotation",
+    maxParticles,
+    factory: () => calculateValue(generalData.particleSystemId, startRotation, 0)
+  });
+  createFloat32Attributes({
+    geometry,
+    propertyName: "size",
+    maxParticles,
+    factory: (_, index) => generalData.startValues.startSize[index]
+  });
+  createFloat32Attributes({
+    geometry,
+    propertyName: "rotation",
+    maxParticles,
+    factory: 0
+  });
+  const colorRandomRatio = Math.random();
+  createFloat32Attributes({
+    geometry,
+    propertyName: "colorR",
+    maxParticles,
+    factory: () => startColor.min.r + colorRandomRatio * (startColor.max.r - startColor.min.r)
+  });
+  createFloat32Attributes({
+    geometry,
+    propertyName: "colorG",
+    maxParticles,
+    factory: () => startColor.min.g + colorRandomRatio * (startColor.max.g - startColor.min.g)
+  });
+  createFloat32Attributes({
+    geometry,
+    propertyName: "colorB",
+    maxParticles,
+    factory: () => startColor.min.b + colorRandomRatio * (startColor.max.b - startColor.min.b)
+  });
+  createFloat32Attributes({
+    geometry,
+    propertyName: "colorA",
+    maxParticles,
+    factory: 0
+  });
+  const deactivateParticle = (particleIndex) => {
+    geometry.attributes.isActive.array[particleIndex] = 0;
+    geometry.attributes.colorA.array[particleIndex] = 0;
+    geometry.attributes.colorA.needsUpdate = true;
+    freeList.push(particleIndex);
+  };
+  const activateParticle = ({
+    particleIndex,
+    activationTime,
+    position
+  }) => {
+    geometry.attributes.isActive.array[particleIndex] = 1;
+    generalData.creationTimes[particleIndex] = activationTime;
+    if (generalData.noise.offsets)
+      generalData.noise.offsets[particleIndex] = Math.random() * 100;
+    const colorRandomRatio2 = Math.random();
+    geometry.attributes.colorR.array[particleIndex] = startColor.min.r + colorRandomRatio2 * (startColor.max.r - startColor.min.r);
+    geometry.attributes.colorR.needsUpdate = true;
+    geometry.attributes.colorG.array[particleIndex] = startColor.min.g + colorRandomRatio2 * (startColor.max.g - startColor.min.g);
+    geometry.attributes.colorG.needsUpdate = true;
+    geometry.attributes.colorB.array[particleIndex] = startColor.min.b + colorRandomRatio2 * (startColor.max.b - startColor.min.b);
+    geometry.attributes.colorB.needsUpdate = true;
+    generalData.startValues.startColorR[particleIndex] = geometry.attributes.colorR.array[particleIndex];
+    generalData.startValues.startColorG[particleIndex] = geometry.attributes.colorG.array[particleIndex];
+    generalData.startValues.startColorB[particleIndex] = geometry.attributes.colorB.array[particleIndex];
+    geometry.attributes.startFrame.array[particleIndex] = textureSheetAnimation.startFrame ? calculateValue(
+      generalData.particleSystemId,
+      textureSheetAnimation.startFrame,
+      0
+    ) : 0;
+    geometry.attributes.startFrame.needsUpdate = true;
+    geometry.attributes.startLifetime.array[particleIndex] = calculateValue(
+      generalData.particleSystemId,
+      startLifetime,
+      generalData.normalizedLifetimePercentage
+    ) * 1e3;
+    geometry.attributes.startLifetime.needsUpdate = true;
+    generalData.startValues.startSize[particleIndex] = calculateValue(
+      generalData.particleSystemId,
+      startSize,
+      generalData.normalizedLifetimePercentage
+    );
+    geometry.attributes.size.array[particleIndex] = generalData.startValues.startSize[particleIndex];
+    geometry.attributes.size.needsUpdate = true;
+    generalData.startValues.startOpacity[particleIndex] = calculateValue(
+      generalData.particleSystemId,
+      startOpacity,
+      generalData.normalizedLifetimePercentage
+    );
+    geometry.attributes.colorA.array[particleIndex] = generalData.startValues.startOpacity[particleIndex];
+    geometry.attributes.colorA.needsUpdate = true;
+    geometry.attributes.rotation.array[particleIndex] = calculateValue(
+      generalData.particleSystemId,
+      startRotation,
+      generalData.normalizedLifetimePercentage
+    );
+    geometry.attributes.rotation.needsUpdate = true;
+    if (normalizedConfig.rotationOverLifetime.isActive)
+      generalData.lifetimeValues.rotationOverLifetime[particleIndex] = THREE3.MathUtils.randFloat(
+        normalizedConfig.rotationOverLifetime.min,
+        normalizedConfig.rotationOverLifetime.max
+      );
+    calculatePositionAndVelocity(
+      generalData,
+      shape,
+      startSpeed,
+      startPositions[particleIndex],
+      velocities[particleIndex]
+    );
+    const positionIndex = Math.floor(particleIndex * 3);
+    geometry.attributes.position.array[positionIndex] = position.x + startPositions[particleIndex].x;
+    geometry.attributes.position.array[positionIndex + 1] = position.y + startPositions[particleIndex].y;
+    geometry.attributes.position.array[positionIndex + 2] = position.z + startPositions[particleIndex].z;
+    geometry.attributes.position.needsUpdate = true;
+    if (generalData.linearVelocityData) {
+      generalData.linearVelocityData[particleIndex].speed.set(
+        normalizedConfig.velocityOverLifetime.linear.x ? calculateValue(
+          generalData.particleSystemId,
+          normalizedConfig.velocityOverLifetime.linear.x,
+          0
+        ) : 0,
+        normalizedConfig.velocityOverLifetime.linear.y ? calculateValue(
+          generalData.particleSystemId,
+          normalizedConfig.velocityOverLifetime.linear.y,
+          0
+        ) : 0,
+        normalizedConfig.velocityOverLifetime.linear.z ? calculateValue(
+          generalData.particleSystemId,
+          normalizedConfig.velocityOverLifetime.linear.z,
+          0
+        ) : 0
+      );
+    }
+    if (generalData.orbitalVelocityData) {
+      generalData.orbitalVelocityData[particleIndex].speed.set(
+        normalizedConfig.velocityOverLifetime.orbital.x ? calculateValue(
+          generalData.particleSystemId,
+          normalizedConfig.velocityOverLifetime.orbital.x,
+          0
+        ) : 0,
+        normalizedConfig.velocityOverLifetime.orbital.y ? calculateValue(
+          generalData.particleSystemId,
+          normalizedConfig.velocityOverLifetime.orbital.y,
+          0
+        ) : 0,
+        normalizedConfig.velocityOverLifetime.orbital.z ? calculateValue(
+          generalData.particleSystemId,
+          normalizedConfig.velocityOverLifetime.orbital.z,
+          0
+        ) : 0
+      );
+      generalData.orbitalVelocityData[particleIndex].positionOffset.set(
+        startPositions[particleIndex].x,
+        startPositions[particleIndex].y,
+        startPositions[particleIndex].z
+      );
+    }
+    geometry.attributes.lifetime.array[particleIndex] = 0;
+    geometry.attributes.lifetime.needsUpdate = true;
+    applyModifiers({
+      delta: 0,
+      generalData,
+      normalizedConfig,
+      attributes: particleSystem.geometry.attributes,
+      particleLifetimePercentage: 0,
+      particleIndex
+    });
+  };
+  let particleSystem = new THREE3.Points(geometry, material);
+  particleSystem.position.copy(transform.position);
+  particleSystem.rotation.x = THREE3.MathUtils.degToRad(transform.rotation.x);
+  particleSystem.rotation.y = THREE3.MathUtils.degToRad(transform.rotation.y);
+  particleSystem.rotation.z = THREE3.MathUtils.degToRad(transform.rotation.z);
+  particleSystem.scale.copy(transform.scale);
+  const calculatedCreationTime = now + calculateValue(generalData.particleSystemId, startDelay) * 1e3;
+  let wrapper;
+  if (normalizedConfig.simulationSpace === "WORLD" /* WORLD */) {
+    wrapper = new Gyroscope();
+    wrapper.add(particleSystem);
+  }
+  const instanceData = {
+    particleSystem,
+    wrapper,
+    elapsedUniform: material.uniforms.elapsed,
+    generalData,
+    onUpdate,
+    onComplete,
+    creationTime: calculatedCreationTime,
+    lastEmissionTime: calculatedCreationTime,
+    duration,
+    looping,
+    simulationSpace,
+    gravity,
+    emission,
+    normalizedConfig,
+    iterationCount: 0,
+    velocities,
+    freeList,
+    deactivateParticle,
+    activateParticle
+  };
+  createdParticleSystems.push(instanceData);
+  const resumeEmitter = () => generalData.isEnabled = true;
+  const pauseEmitter = () => generalData.isEnabled = false;
+  const dispose = () => destroyParticleSystem(particleSystem);
+  const update = (cycleData) => updateParticleSystemInstance(instanceData, cycleData);
+  return {
+    instance: wrapper || particleSystem,
+    resumeEmitter,
+    pauseEmitter,
+    dispose,
+    update
+  };
+};
+var updateParticleSystemInstance = (props, { now, delta, elapsed }) => {
+  const {
+    onUpdate,
+    generalData,
+    onComplete,
+    particleSystem,
+    wrapper,
+    elapsedUniform,
+    creationTime,
+    lastEmissionTime,
+    duration,
+    looping,
+    emission,
+    normalizedConfig,
+    iterationCount,
+    velocities,
+    freeList,
+    deactivateParticle,
+    activateParticle,
+    simulationSpace,
+    gravity
+  } = props;
+  const lifetime = now - creationTime;
+  const normalizedLifetime = lifetime % (duration * 1e3);
+  generalData.normalizedLifetimePercentage = Math.max(
+    Math.min(normalizedLifetime / (duration * 1e3), 1),
+    0
+  );
+  const {
+    lastWorldPosition,
+    currentWorldPosition,
+    worldPositionChange,
+    lastWorldQuaternion,
+    worldQuaternion,
+    worldEuler,
+    gravityVelocity,
+    isEnabled
+  } = generalData;
+  if (wrapper?.parent)
+    generalData.wrapperQuaternion.copy(wrapper.parent.quaternion);
+  _lastWorldPositionSnapshot.copy(lastWorldPosition);
+  elapsedUniform.value = elapsed;
+  particleSystem.getWorldPosition(currentWorldPosition);
+  if (lastWorldPosition.x !== -99999) {
+    worldPositionChange.set(
+      currentWorldPosition.x - lastWorldPosition.x,
+      currentWorldPosition.y - lastWorldPosition.y,
+      currentWorldPosition.z - lastWorldPosition.z
+    );
+  }
+  if (isEnabled) {
+    generalData.distanceFromLastEmitByDistance += worldPositionChange.length();
+  }
+  particleSystem.getWorldPosition(lastWorldPosition);
+  particleSystem.getWorldQuaternion(worldQuaternion);
+  if (lastWorldQuaternion.x === -99999 || lastWorldQuaternion.x !== worldQuaternion.x || lastWorldQuaternion.y !== worldQuaternion.y || lastWorldQuaternion.z !== worldQuaternion.z) {
+    worldEuler.setFromQuaternion(worldQuaternion);
+    lastWorldQuaternion.copy(worldQuaternion);
+    gravityVelocity.set(
+      lastWorldPosition.x,
+      lastWorldPosition.y + gravity,
+      lastWorldPosition.z
+    );
+    particleSystem.worldToLocal(gravityVelocity);
+  }
+  const creationTimes = generalData.creationTimes;
+  const attributes = particleSystem.geometry.attributes;
+  const isActiveArr = attributes.isActive.array;
+  const startLifetimeArr = attributes.startLifetime.array;
+  const positionArr = attributes.position.array;
+  const lifetimeArr = attributes.lifetime.array;
+  const creationTimesLength = creationTimes.length;
+  let positionNeedsUpdate = false;
+  let lifetimeNeedsUpdate = false;
+  _modifierParams.delta = delta;
+  _modifierParams.generalData = generalData;
+  _modifierParams.normalizedConfig = normalizedConfig;
+  _modifierParams.attributes = attributes;
+  for (let index = 0; index < creationTimesLength; index++) {
+    if (isActiveArr[index]) {
+      const particleLifetime = now - creationTimes[index];
+      if (particleLifetime > startLifetimeArr[index]) {
+        deactivateParticle(index);
+      } else {
+        const velocity = velocities[index];
+        velocity.x -= gravityVelocity.x * delta;
+        velocity.y -= gravityVelocity.y * delta;
+        velocity.z -= gravityVelocity.z * delta;
+        if (gravity !== 0 || velocity.x !== 0 || velocity.y !== 0 || velocity.z !== 0 || worldPositionChange.x !== 0 || worldPositionChange.y !== 0 || worldPositionChange.z !== 0) {
+          const positionIndex = index * 3;
+          if (simulationSpace === "WORLD" /* WORLD */) {
+            positionArr[positionIndex] -= worldPositionChange.x;
+            positionArr[positionIndex + 1] -= worldPositionChange.y;
+            positionArr[positionIndex + 2] -= worldPositionChange.z;
+          }
+          positionArr[positionIndex] += velocity.x * delta;
+          positionArr[positionIndex + 1] += velocity.y * delta;
+          positionArr[positionIndex + 2] += velocity.z * delta;
+          positionNeedsUpdate = true;
+        }
+        lifetimeArr[index] = particleLifetime;
+        lifetimeNeedsUpdate = true;
+        _modifierParams.particleLifetimePercentage = particleLifetime / startLifetimeArr[index];
+        _modifierParams.particleIndex = index;
+        applyModifiers(_modifierParams);
+      }
+    }
+  }
+  if (positionNeedsUpdate) attributes.position.needsUpdate = true;
+  if (lifetimeNeedsUpdate) attributes.lifetime.needsUpdate = true;
+  if (isEnabled && (looping || lifetime < duration * 1e3)) {
+    const emissionDelta = now - lastEmissionTime;
+    const neededParticlesByTime = emission.rateOverTime ? Math.floor(
+      calculateValue(
+        generalData.particleSystemId,
+        emission.rateOverTime,
+        generalData.normalizedLifetimePercentage
+      ) * (emissionDelta / 1e3)
+    ) : 0;
+    const rateOverDistance = emission.rateOverDistance ? calculateValue(
+      generalData.particleSystemId,
+      emission.rateOverDistance,
+      generalData.normalizedLifetimePercentage
+    ) : 0;
+    const neededParticlesByDistance = rateOverDistance > 0 && generalData.distanceFromLastEmitByDistance > 0 ? Math.floor(
+      generalData.distanceFromLastEmitByDistance / (1 / rateOverDistance)
+    ) : 0;
+    const useDistanceStep = neededParticlesByDistance > 0;
+    if (useDistanceStep) {
+      _distanceStep.x = (currentWorldPosition.x - _lastWorldPositionSnapshot.x) / neededParticlesByDistance;
+      _distanceStep.y = (currentWorldPosition.y - _lastWorldPositionSnapshot.y) / neededParticlesByDistance;
+      _distanceStep.z = (currentWorldPosition.z - _lastWorldPositionSnapshot.z) / neededParticlesByDistance;
+    }
+    let neededParticles = neededParticlesByTime + neededParticlesByDistance;
+    if (rateOverDistance > 0 && neededParticlesByDistance >= 1) {
+      generalData.distanceFromLastEmitByDistance = 0;
+    }
+    if (emission.bursts && generalData.burstStates) {
+      const bursts = emission.bursts;
+      const burstStates = generalData.burstStates;
+      const currentIterationTime = normalizedLifetime;
+      for (let i = 0; i < bursts.length; i++) {
+        const burst = bursts[i];
+        const state = burstStates[i];
+        const burstTimeMs = burst.time * 1e3;
+        const cycles = burst.cycles ?? 1;
+        const intervalMs = (burst.interval ?? 0) * 1e3;
+        const probability = burst.probability ?? 1;
+        if (looping && currentIterationTime < burstTimeMs && state.cyclesExecuted > 0) {
+          state.cyclesExecuted = 0;
+          state.lastCycleTime = 0;
+          state.probabilityPassed = false;
+        }
+        if (state.cyclesExecuted >= cycles) continue;
+        const nextCycleTime = burstTimeMs + state.cyclesExecuted * intervalMs;
+        if (currentIterationTime >= nextCycleTime) {
+          if (state.cyclesExecuted === 0) {
+            state.probabilityPassed = Math.random() < probability;
+          }
+          if (state.probabilityPassed) {
+            const burstCount = Math.floor(
+              calculateValue(
+                generalData.particleSystemId,
+                burst.count,
+                generalData.normalizedLifetimePercentage
+              )
+            );
+            neededParticles += burstCount;
+          }
+          state.cyclesExecuted++;
+          state.lastCycleTime = currentIterationTime;
+        }
+      }
+    }
+    if (neededParticles > 0) {
+      let generatedParticlesByDistanceNeeds = 0;
+      for (let i = 0; i < neededParticles; i++) {
+        if (freeList.length === 0) break;
+        const particleIndex = freeList.pop();
+        _tempPosition.x = 0;
+        _tempPosition.y = 0;
+        _tempPosition.z = 0;
+        if (useDistanceStep && generatedParticlesByDistanceNeeds < neededParticlesByDistance) {
+          _tempPosition.x = _distanceStep.x * generatedParticlesByDistanceNeeds;
+          _tempPosition.y = _distanceStep.y * generatedParticlesByDistanceNeeds;
+          _tempPosition.z = _distanceStep.z * generatedParticlesByDistanceNeeds;
+          generatedParticlesByDistanceNeeds++;
+        }
+        activateParticle({
+          particleIndex,
+          activationTime: now,
+          position: _tempPosition
+        });
+        props.lastEmissionTime = now;
+      }
+    }
+    if (onUpdate)
+      onUpdate({
+        particleSystem,
+        delta,
+        elapsed,
+        lifetime,
+        normalizedLifetime,
+        iterationCount: iterationCount + 1
+      });
+  } else if (onComplete)
+    onComplete({
+      particleSystem
+    });
+};
+var updateParticleSystems = (cycleData) => {
+  createdParticleSystems.forEach(
+    (props) => updateParticleSystemInstance(props, cycleData)
+  );
+};
+
+export { CurveFunctionId, EmitFrom, LifeTimeCurve, Shape, SimulationSpace, TimeMode, applyModifiers, blendingMap, calculateRandomPositionAndVelocityOnBox, calculateRandomPositionAndVelocityOnCircle, calculateRandomPositionAndVelocityOnCone, calculateRandomPositionAndVelocityOnRectangle, calculateRandomPositionAndVelocityOnSphere, calculateValue, createBezierCurveFunction, createDefaultParticleTexture, createParticleSystem, getBezierCacheSize, getCurveFunction, getCurveFunctionFromConfig, getDefaultParticleSystemConfig, isLifeTimeCurve, removeBezierCurveFunction, updateParticleSystems };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map