@newkrok/three-particles 2.6.3 → 2.6.5

package/dist/js/effects/three-particles/three-particles-modifiers.js

@@ -1,168 +0,0 @@
-import * as THREE from 'three';
-import { calculateValue } from './three-particles-utils.js';
-const noiseInput = new THREE.Vector3(0, 0, 0);
-const orbitalEuler = new THREE.Euler();
-/**
- * Applies all active modifiers to a single particle during the update cycle.
- *
- * This function handles the animation and modification of particle properties over its lifetime,
- * including velocity (linear and orbital), size, opacity, color, rotation, and noise-based effects.
- * It is called once per particle per frame by the {@link updateParticleSystems} function.
- *
- * @param params - Configuration object containing:
- * @param params.delta - Time elapsed since the last frame in seconds. Used for velocity and rotation calculations.
- * @param params.generalData - Internal particle system state and cached values.
- * @param params.normalizedConfig - The normalized particle system configuration with all modifiers.
- * @param params.attributes - Three.js buffer attributes for position, size, rotation, and color.
- * @param params.particleLifetimePercentage - Normalized lifetime of the particle (0.0 to 1.0).
- *   - 0.0 = particle just born
- *   - 1.0 = particle at end of life
- * @param params.particleIndex - Index of the particle in the buffer arrays.
- *
- * @remarks
- * The function modifies the following particle properties based on configuration:
- *
- * - **Linear Velocity**: Moves particles in a straight line (velocityOverLifetime.linear)
- * - **Orbital Velocity**: Rotates particles around their emission point (velocityOverLifetime.orbital)
- * - **Size Over Lifetime**: Scales particle size based on lifetime curve (sizeOverLifetime)
- * - **Opacity Over Lifetime**: Fades particles in/out based on lifetime curve (opacityOverLifetime)
- * - **Color Over Lifetime**: Animates RGB channels independently based on lifetime curves (colorOverLifetime)
- * - **Rotation Over Lifetime**: Rotates particles around their center (rotationOverLifetime)
- * - **Noise**: Adds organic, turbulent motion to position, rotation, and size (noise)
- *
- * Each modifier only runs if it's active in the configuration, optimizing performance for simple effects.
- *
- * @example
- * ```typescript
- * // This function is called internally by updateParticleSystems
- * // You typically don't need to call it directly
- *
- * // However, understanding its behavior helps configure particle systems:
- * const config = {
- *   sizeOverLifetime: {
- *     isActive: true,
- *     lifetimeCurve: {
- *       type: 'BEZIER',
- *       bezierPoints: [
- *         { x: 0, y: 0, percentage: 0 },    // Start at 0% size
- *         { x: 0.5, y: 1, percentage: 0.5 }, // Grow to 100% at midlife
- *         { x: 1, y: 0, percentage: 1 }      // Shrink to 0% at end
- *       ]
- *     }
- *   },
- *   opacityOverLifetime: {
- *     isActive: true,
- *     lifetimeCurve: {
- *       type: 'EASING',
- *       curveFunction: 'easeOutQuad'
- *     }
- *   }
- * };
- * ```
- *
- * @see {@link updateParticleSystems} - Calls this function for each active particle
- * @see {@link VelocityOverLifetime} - Configuration for velocity modifiers
- * @see {@link NoiseConfig} - Configuration for noise-based effects
- */
-export const 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;
-    }
-};

package/dist/js/effects/three-particles/three-particles-utils.d.ts

@@ -1,159 +0,0 @@
-import * as THREE from 'three';
-import { EmitFrom } from './three-particles-enums.js';
-import { Constant, LifetimeCurve, Point3D, RandomBetweenTwoConstants } from './types.js';
-/**
- * Calculates random position and velocity for particles emitted from a sphere.
- *
- * Supports emission from the entire volume or just the shell of the sphere.
- * Uses spherical coordinates for uniform distribution across the surface.
- *
- * @param position - Output vector for the particle's starting position
- * @param quaternion - Rotation to apply to the emission shape
- * @param velocity - Output vector for the particle's initial velocity
- * @param speed - Speed multiplier for the velocity
- * @param params - Sphere configuration
- * @param params.radius - Radius of the sphere
- * @param params.radiusThickness - Controls emission from volume (1.0) vs shell (0.0)
- * @param params.arc - Arc angle in degrees (360 = full sphere, 180 = hemisphere)
- *
- * @remarks
- * - `radiusThickness = 1.0`: Emit from entire volume
- * - `radiusThickness = 0.0`: Emit only from surface shell
- * - Particles are emitted radially outward from the center
- *
- * @see {@link Sphere} - Configuration type for sphere shape
- */
-export declare const calculateRandomPositionAndVelocityOnSphere: (position: THREE.Vector3, quaternion: THREE.Quaternion, velocity: THREE.Vector3, speed: number, { radius, radiusThickness, arc, }: {
-    radius: number;
-    radiusThickness: number;
-    arc: number;
-}) => void;
-/**
- * Calculates random position and velocity for particles emitted from a cone.
- *
- * Useful for directional particle effects like fire, smoke plumes, fountains,
- * or spray effects. The cone emits particles in a spreading pattern.
- *
- * @param position - Output vector for the particle's starting position
- * @param quaternion - Rotation to apply to the emission shape
- * @param velocity - Output vector for the particle's initial velocity
- * @param speed - Speed multiplier for the velocity
- * @param params - Cone configuration
- * @param params.radius - Base radius of the cone
- * @param params.radiusThickness - Controls emission from volume (1.0) vs shell (0.0)
- * @param params.arc - Arc angle in degrees (360 = full cone, 180 = half cone)
- * @param params.angle - Cone opening angle in degrees (default: 90)
- *                       Smaller values create tighter cones
- *
- * @remarks
- * - The cone emits from its base (circular area) outward
- * - Particles travel in a conical spread pattern
- * - `angle = 0`: Straight line (no spread)
- * - `angle = 90`: Wide cone
- * - Common for fire (10-30°), smoke (30-60°), explosions (60-90°)
- *
- * @see {@link Cone} - Configuration type for cone shape
- */
-export declare const calculateRandomPositionAndVelocityOnCone: (position: THREE.Vector3, quaternion: THREE.Quaternion, velocity: THREE.Vector3, speed: number, { radius, radiusThickness, arc, angle, }: {
-    radius: number;
-    radiusThickness: number;
-    arc: number;
-    angle?: number;
-}) => void;
-/**
- * Calculates random position and velocity for particles emitted from a box.
- *
- * Supports three emission modes: volume, shell (surface), and edges.
- * Useful for area-based effects like dust clouds, rain, or geometric patterns.
- *
- * @param position - Output vector for the particle's starting position
- * @param quaternion - Rotation to apply to the emission shape
- * @param velocity - Output vector for the particle's initial velocity
- * @param speed - Speed multiplier for the velocity
- * @param params - Box configuration
- * @param params.scale - Size of the box on each axis (width, height, depth)
- * @param params.emitFrom - Emission mode:
- *   - `VOLUME`: Random positions throughout the entire box volume
- *   - `SHELL`: Random positions on the 6 faces (surface)
- *   - `EDGE`: Random positions along the 12 edges
- *
- * @remarks
- * - All particles emit with velocity along the +Z axis (forward)
- * - Box is centered at the origin before rotation
- * - VOLUME mode: Best for rain, snow, or volumetric clouds
- * - SHELL mode: Best for hollow effects or surface particles
- * - EDGE mode: Best for wireframe effects or particle outlines
- *
- * @see {@link Box} - Configuration type for box shape
- * @see {@link EmitFrom} - Emission mode enum
- */
-export declare const calculateRandomPositionAndVelocityOnBox: (position: THREE.Vector3, quaternion: THREE.Quaternion, velocity: THREE.Vector3, speed: number, { scale, emitFrom }: {
-    scale: Point3D;
-    emitFrom: EmitFrom;
-}) => void;
-/**
- * Calculates random position and velocity for particles emitted from a circle.
- *
- * Emits particles from a circular area or ring. Useful for ground impacts,
- * radial effects, magic circles, or any circular planar emission.
- *
- * @param position - Output vector for the particle's starting position
- * @param quaternion - Rotation to apply to the emission shape
- * @param velocity - Output vector for the particle's initial velocity
- * @param speed - Speed multiplier for the velocity
- * @param params - Circle configuration
- * @param params.radius - Radius of the circle
- * @param params.radiusThickness - Controls emission from area (1.0) vs edge (0.0)
- * @param params.arc - Arc angle in degrees (360 = full circle, 180 = semicircle)
- *
- * @remarks
- * - Circle lies in the XY plane by default (Z = 0)
- * - Particles emit along the +Z axis (perpendicular to circle)
- * - `radiusThickness = 1.0`: Filled circle (disc)
- * - `radiusThickness = 0.0`: Ring (circle edge only)
- * - Good for ground impact effects, teleport circles, or radial bursts
- *
- * @see {@link Circle} - Configuration type for circle shape
- */
-export declare const calculateRandomPositionAndVelocityOnCircle: (position: THREE.Vector3, quaternion: THREE.Quaternion, velocity: THREE.Vector3, speed: number, { radius, radiusThickness, arc, }: {
-    radius: number;
-    radiusThickness: number;
-    arc: number;
-}) => void;
-/**
- * Calculates random position and velocity for particles emitted from a rectangle.
- *
- * Emits particles from a rectangular planar area. Useful for rain on a surface,
- * screen-space effects, or any planar emission pattern.
- *
- * @param position - Output vector for the particle's starting position
- * @param quaternion - Rotation to apply to the emission shape
- * @param velocity - Output vector for the particle's initial velocity
- * @param speed - Speed multiplier for the velocity
- * @param params - Rectangle configuration
- * @param params.rotation - Local rotation of the rectangle (degrees) before
- *                          applying quaternion
- * @param params.scale - Size of the rectangle (width and height)
- *
- * @remarks
- * - Rectangle lies in the XY plane by default
- * - Particles emit along the +Z axis (perpendicular to rectangle)
- * - The rotation parameter allows tilting the rectangle before the main
- *   quaternion rotation is applied
- * - Good for rain effects, screen particles, or planar area emissions
- *
- * @see {@link Rectangle} - Configuration type for rectangle shape
- */
-export declare const calculateRandomPositionAndVelocityOnRectangle: (position: THREE.Vector3, quaternion: THREE.Quaternion, velocity: THREE.Vector3, speed: number, { rotation, scale }: {
-    rotation: Point3D;
-    scale: Point3D;
-}) => void;
-/**
- * Creates a default white circle texture using CanvasTexture.
- * @returns {THREE.CanvasTexture | null} The generated texture or null if context fails.
- */
-export declare const createDefaultParticleTexture: () => THREE.CanvasTexture | null;
-export declare const isLifeTimeCurve: (value: Constant | RandomBetweenTwoConstants | LifetimeCurve) => value is LifetimeCurve;
-export declare const getCurveFunctionFromConfig: (particleSystemId: number, lifetimeCurve: LifetimeCurve) => import("./types.js").CurveFunction;
-export declare const calculateValue: (particleSystemId: number, value: Constant | RandomBetweenTwoConstants | LifetimeCurve, time?: number) => number;
-//# sourceMappingURL=three-particles-utils.d.ts.map

package/dist/js/effects/three-particles/three-particles-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"three-particles-utils.d.ts","sourceRoot":"","sources":["../../../../src/js/effects/three-particles/three-particles-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,OAAO,EAAE,QAAQ,EAAiB,MAAM,4BAA4B,CAAC;AACrE,OAAO,EACL,QAAQ,EACR,aAAa,EACb,OAAO,EACP,yBAAyB,EAC1B,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,0CAA0C,GACrD,UAAU,KAAK,CAAC,OAAO,EACvB,YAAY,KAAK,CAAC,UAAU,EAC5B,UAAU,KAAK,CAAC,OAAO,EACvB,OAAO,MAAM,EACb,mCAIG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,SAiC5D,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,wCAAwC,GACnD,UAAU,KAAK,CAAC,OAAO,EACvB,YAAY,KAAK,CAAC,UAAU,EAC5B,UAAU,KAAK,CAAC,OAAO,EACvB,OAAO,MAAM,EACb,0CAKG;IACD,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,SAgCF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,uCAAuC,GAClD,UAAU,KAAK,CAAC,OAAO,EACvB,YAAY,KAAK,CAAC,UAAU,EAC5B,UAAU,KAAK,CAAC,OAAO,EACvB,OAAO,MAAM,EACb,qBAAqB;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,QAAQ,CAAA;CAAE,SA0C5D,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,0CAA0C,GACrD,UAAU,KAAK,CAAC,OAAO,EACvB,YAAY,KAAK,CAAC,UAAU,EAC5B,UAAU,KAAK,CAAC,OAAO,EACvB,OAAO,MAAM,EACb,mCAIG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,SA2B5D,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,6CAA6C,GACxD,UAAU,KAAK,CAAC,OAAO,EACvB,YAAY,KAAK,CAAC,UAAU,EAC5B,UAAU,KAAK,CAAC,OAAO,EACvB,OAAO,MAAM,EACb,qBAAqB;IAAE,QAAQ,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,SAiB3D,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,4BAA4B,QAAO,KAAK,CAAC,aAAa,GAAG,IA8BrE,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,OAAO,QAAQ,GAAG,yBAAyB,GAAG,aAAa,KAC1D,KAAK,IAAI,aAEX,CAAC;AAEF,eAAO,MAAM,0BAA0B,GACrC,kBAAkB,MAAM,EACxB,eAAe,aAAa,uCAc7B,CAAC;AAEF,eAAO,MAAM,cAAc,GACzB,kBAAkB,MAAM,EACxB,OAAO,QAAQ,GAAG,yBAAyB,GAAG,aAAa,EAC3D,OAAM,MAAU,KACf,MAiBF,CAAC"}

package/dist/js/effects/three-particles/three-particles-utils.js

@@ -1,302 +0,0 @@
-import * as THREE from 'three';
-import { createBezierCurveFunction } from './three-particles-bezier.js';
-/**
- * Calculates random position and velocity for particles emitted from a sphere.
- *
- * Supports emission from the entire volume or just the shell of the sphere.
- * Uses spherical coordinates for uniform distribution across the surface.
- *
- * @param position - Output vector for the particle's starting position
- * @param quaternion - Rotation to apply to the emission shape
- * @param velocity - Output vector for the particle's initial velocity
- * @param speed - Speed multiplier for the velocity
- * @param params - Sphere configuration
- * @param params.radius - Radius of the sphere
- * @param params.radiusThickness - Controls emission from volume (1.0) vs shell (0.0)
- * @param params.arc - Arc angle in degrees (360 = full sphere, 180 = hemisphere)
- *
- * @remarks
- * - `radiusThickness = 1.0`: Emit from entire volume
- * - `radiusThickness = 0.0`: Emit only from surface shell
- * - Particles are emitted radially outward from the center
- *
- * @see {@link Sphere} - Configuration type for sphere shape
- */
-export const 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);
-};
-/**
- * Calculates random position and velocity for particles emitted from a cone.
- *
- * Useful for directional particle effects like fire, smoke plumes, fountains,
- * or spray effects. The cone emits particles in a spreading pattern.
- *
- * @param position - Output vector for the particle's starting position
- * @param quaternion - Rotation to apply to the emission shape
- * @param velocity - Output vector for the particle's initial velocity
- * @param speed - Speed multiplier for the velocity
- * @param params - Cone configuration
- * @param params.radius - Base radius of the cone
- * @param params.radiusThickness - Controls emission from volume (1.0) vs shell (0.0)
- * @param params.arc - Arc angle in degrees (360 = full cone, 180 = half cone)
- * @param params.angle - Cone opening angle in degrees (default: 90)
- *                       Smaller values create tighter cones
- *
- * @remarks
- * - The cone emits from its base (circular area) outward
- * - Particles travel in a conical spread pattern
- * - `angle = 0`: Straight line (no spread)
- * - `angle = 90`: Wide cone
- * - Common for fire (10-30°), smoke (30-60°), explosions (60-90°)
- *
- * @see {@link Cone} - Configuration type for cone shape
- */
-export const 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) * THREE.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);
-};
-/**
- * Calculates random position and velocity for particles emitted from a box.
- *
- * Supports three emission modes: volume, shell (surface), and edges.
- * Useful for area-based effects like dust clouds, rain, or geometric patterns.
- *
- * @param position - Output vector for the particle's starting position
- * @param quaternion - Rotation to apply to the emission shape
- * @param velocity - Output vector for the particle's initial velocity
- * @param speed - Speed multiplier for the velocity
- * @param params - Box configuration
- * @param params.scale - Size of the box on each axis (width, height, depth)
- * @param params.emitFrom - Emission mode:
- *   - `VOLUME`: Random positions throughout the entire box volume
- *   - `SHELL`: Random positions on the 6 faces (surface)
- *   - `EDGE`: Random positions along the 12 edges
- *
- * @remarks
- * - All particles emit with velocity along the +Z axis (forward)
- * - Box is centered at the origin before rotation
- * - VOLUME mode: Best for rain, snow, or volumetric clouds
- * - SHELL mode: Best for hollow effects or surface particles
- * - EDGE mode: Best for wireframe effects or particle outlines
- *
- * @see {@link Box} - Configuration type for box shape
- * @see {@link EmitFrom} - Emission mode enum
- */
-export const calculateRandomPositionAndVelocityOnBox = (position, quaternion, velocity, speed, { scale, emitFrom }) => {
-    const _scale = scale;
-    switch (emitFrom) {
-        case "VOLUME" /* EmitFrom.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" /* EmitFrom.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" /* EmitFrom.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);
-};
-/**
- * Calculates random position and velocity for particles emitted from a circle.
- *
- * Emits particles from a circular area or ring. Useful for ground impacts,
- * radial effects, magic circles, or any circular planar emission.
- *
- * @param position - Output vector for the particle's starting position
- * @param quaternion - Rotation to apply to the emission shape
- * @param velocity - Output vector for the particle's initial velocity
- * @param speed - Speed multiplier for the velocity
- * @param params - Circle configuration
- * @param params.radius - Radius of the circle
- * @param params.radiusThickness - Controls emission from area (1.0) vs edge (0.0)
- * @param params.arc - Arc angle in degrees (360 = full circle, 180 = semicircle)
- *
- * @remarks
- * - Circle lies in the XY plane by default (Z = 0)
- * - Particles emit along the +Z axis (perpendicular to circle)
- * - `radiusThickness = 1.0`: Filled circle (disc)
- * - `radiusThickness = 0.0`: Ring (circle edge only)
- * - Good for ground impact effects, teleport circles, or radial bursts
- *
- * @see {@link Circle} - Configuration type for circle shape
- */
-export const 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);
-};
-/**
- * Calculates random position and velocity for particles emitted from a rectangle.
- *
- * Emits particles from a rectangular planar area. Useful for rain on a surface,
- * screen-space effects, or any planar emission pattern.
- *
- * @param position - Output vector for the particle's starting position
- * @param quaternion - Rotation to apply to the emission shape
- * @param velocity - Output vector for the particle's initial velocity
- * @param speed - Speed multiplier for the velocity
- * @param params - Rectangle configuration
- * @param params.rotation - Local rotation of the rectangle (degrees) before
- *                          applying quaternion
- * @param params.scale - Size of the rectangle (width and height)
- *
- * @remarks
- * - Rectangle lies in the XY plane by default
- * - Particles emit along the +Z axis (perpendicular to rectangle)
- * - The rotation parameter allows tilting the rectangle before the main
- *   quaternion rotation is applied
- * - Good for rain effects, screen particles, or planar area emissions
- *
- * @see {@link Rectangle} - Configuration type for rectangle shape
- */
-export const 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 = THREE.MathUtils.degToRad(_rotation.x);
-    const rotationY = THREE.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);
-};
-/**
- * Creates a default white circle texture using CanvasTexture.
- * @returns {THREE.CanvasTexture | null} The generated texture or null if context fails.
- */
-export const 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; // Small padding
-            context.beginPath();
-            context.arc(centerX, centerY, radius, 0, 2 * Math.PI, false);
-            context.fillStyle = 'white';
-            context.fill();
-            const texture = new THREE.CanvasTexture(canvas);
-            texture.needsUpdate = true;
-            return texture;
-        }
-        else {
-            console.warn('Could not get 2D context to generate default particle texture.');
-            return null;
-        }
-    }
-    catch (error) {
-        // Handle potential errors (e.g., document not available in non-browser env)
-        console.warn('Error creating default particle texture:', error);
-        return null;
-    }
-};
-export const isLifeTimeCurve = (value) => {
-    return typeof value !== 'number' && 'type' in value;
-};
-export const getCurveFunctionFromConfig = (particleSystemId, lifetimeCurve) => {
-    if (lifetimeCurve.type === "BEZIER" /* LifeTimeCurve.BEZIER */) {
-        return createBezierCurveFunction(particleSystemId, lifetimeCurve.bezierPoints); // Bézier curve
-    }
-    if (lifetimeCurve.type === "EASING" /* LifeTimeCurve.EASING */) {
-        return lifetimeCurve.curveFunction; // Easing curve
-    }
-    throw new Error(`Unsupported value type: ${lifetimeCurve}`);
-};
-export const calculateValue = (particleSystemId, value, time = 0) => {
-    if (typeof value === 'number') {
-        return value; // Constant value
-    }
-    if ('min' in value && 'max' in value) {
-        if (value.min === value.max) {
-            return value.min ?? 0; // Constant value
-        }
-        return THREE.MathUtils.randFloat(value.min ?? 0, value.max ?? 1); // Random range
-    }
-    const lifetimeCurve = value;
-    return (getCurveFunctionFromConfig(particleSystemId, lifetimeCurve)(time) *
-        (lifetimeCurve.scale ?? 1));
-};