@newkrok/three-particles 2.6.3 → 2.6.4

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

@@ -1,62 +0,0 @@
-const cache = [];
-const nCr = (n, k) => {
-    let z = 1;
-    for (let i = 1; i <= k; i++)
-        z *= (n + 1 - i) / i;
-    return z;
-};
-export const 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 !== undefined)
-                    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;
-};
-export const 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);
-    }
-};
-export const getBezierCacheSize = () => cache.length;

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

@@ -1,108 +0,0 @@
-import { CurveFunction } from './types.js';
-/**
- * Predefined easing function identifiers for animating particle properties
- * over their lifetime.
- *
- * These functions control the rate of change and create different animation
- * feels. Each type has three variants:
- * - **IN**: Starts slow, accelerates toward the end
- * - **OUT**: Starts fast, decelerates toward the end
- * - **IN_OUT**: Combines both, slow at start and end, fast in middle
- *
- * @enum {string}
- *
- * @see {@link https://easings.net/} - Visual reference for easing functions
- */
-export declare const enum CurveFunctionId {
-    /** Use custom Bezier curve (not an easing function) */
-    BEZIER = "BEZIER",
-    /** Linear interpolation with constant rate of change */
-    LINEAR = "LINEAR",
-    /** Quadratic (t²) easing - gentle acceleration */
-    QUADRATIC_IN = "QUADRATIC_IN",
-    /** Quadratic (t²) easing - gentle deceleration */
-    QUADRATIC_OUT = "QUADRATIC_OUT",
-    /** Quadratic (t²) easing - gentle acceleration then deceleration */
-    QUADRATIC_IN_OUT = "QUADRATIC_IN_OUT",
-    /** Cubic (t³) easing - moderate acceleration */
-    CUBIC_IN = "CUBIC_IN",
-    /** Cubic (t³) easing - moderate deceleration */
-    CUBIC_OUT = "CUBIC_OUT",
-    /** Cubic (t³) easing - moderate acceleration then deceleration */
-    CUBIC_IN_OUT = "CUBIC_IN_OUT",
-    /** Quartic (t⁴) easing - strong acceleration */
-    QUARTIC_IN = "QUARTIC_IN",
-    /** Quartic (t⁴) easing - strong deceleration */
-    QUARTIC_OUT = "QUARTIC_OUT",
-    /** Quartic (t⁴) easing - strong acceleration then deceleration */
-    QUARTIC_IN_OUT = "QUARTIC_IN_OUT",
-    /** Quintic (t⁵) easing - very strong acceleration */
-    QUINTIC_IN = "QUINTIC_IN",
-    /** Quintic (t⁵) easing - very strong deceleration */
-    QUINTIC_OUT = "QUINTIC_OUT",
-    /** Quintic (t⁵) easing - very strong acceleration then deceleration */
-    QUINTIC_IN_OUT = "QUINTIC_IN_OUT",
-    /** Sinusoidal easing - smooth, natural acceleration */
-    SINUSOIDAL_IN = "SINUSOIDAL_IN",
-    /** Sinusoidal easing - smooth, natural deceleration */
-    SINUSOIDAL_OUT = "SINUSOIDAL_OUT",
-    /** Sinusoidal easing - smooth acceleration then deceleration */
-    SINUSOIDAL_IN_OUT = "SINUSOIDAL_IN_OUT",
-    /** Exponential easing - dramatic, explosive acceleration */
-    EXPONENTIAL_IN = "EXPONENTIAL_IN",
-    /** Exponential easing - dramatic, explosive deceleration */
-    EXPONENTIAL_OUT = "EXPONENTIAL_OUT",
-    /** Exponential easing - dramatic acceleration then deceleration */
-    EXPONENTIAL_IN_OUT = "EXPONENTIAL_IN_OUT",
-    /** Circular easing - sharp acceleration with curved trajectory */
-    CIRCULAR_IN = "CIRCULAR_IN",
-    /** Circular easing - sharp deceleration with curved trajectory */
-    CIRCULAR_OUT = "CIRCULAR_OUT",
-    /** Circular easing - sharp acceleration then deceleration */
-    CIRCULAR_IN_OUT = "CIRCULAR_IN_OUT",
-    /** Elastic easing - oscillates back before accelerating (spring-like) */
-    ELASTIC_IN = "ELASTIC_IN",
-    /** Elastic easing - overshoots then oscillates back (spring-like) */
-    ELASTIC_OUT = "ELASTIC_OUT",
-    /** Elastic easing - oscillates at both ends (spring-like) */
-    ELASTIC_IN_OUT = "ELASTIC_IN_OUT",
-    /** Back easing - pulls back before accelerating forward */
-    BACK_IN = "BACK_IN",
-    /** Back easing - overshoots forward then pulls back */
-    BACK_OUT = "BACK_OUT",
-    /** Back easing - pulls back, overshoots, then settles */
-    BACK_IN_OUT = "BACK_IN_OUT",
-    /** Bounce easing - bounces at the start */
-    BOUNCE_IN = "BOUNCE_IN",
-    /** Bounce easing - bounces at the end (like a ball landing) */
-    BOUNCE_OUT = "BOUNCE_OUT",
-    /** Bounce easing - bounces at both start and end */
-    BOUNCE_IN_OUT = "BOUNCE_IN_OUT"
-}
-/**
- * Resolves a curve function from an identifier or returns the function itself.
- *
- * This utility function allows you to use either a {@link CurveFunctionId} string
- * identifier or a custom function directly.
- *
- * @param curveFunctionId - Either a {@link CurveFunctionId} enum value or a
- *                          custom {@link CurveFunction} implementation
- * @returns The actual easing function that takes a normalized time value (0-1)
- *          and returns the eased value
- *
- * @example
- * ```typescript
- * import { getCurveFunction, CurveFunctionId } from '@newkrok/three-particles';
- *
- * // Using a predefined easing function
- * const easingFunc = getCurveFunction(CurveFunctionId.CUBIC_OUT);
- * console.log(easingFunc(0.5)); // Returns eased value at 50% progress
- *
- * // Using a custom function
- * const customEasing = (t: number) => t * t; // Quadratic
- * const customFunc = getCurveFunction(customEasing);
- * console.log(customFunc(0.5)); // Returns 0.25
- * ```
- */
-export declare const getCurveFunction: (curveFunctionId: CurveFunctionId | CurveFunction) => CurveFunction;
-//# sourceMappingURL=three-particles-curves.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"three-particles-curves.d.ts","sourceRoot":"","sources":["../../../../src/js/effects/three-particles/three-particles-curves.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAE3C;;;;;;;;;;;;;GAaG;AACH,0BAAkB,eAAe;IAC/B,uDAAuD;IACvD,MAAM,WAAW;IAEjB,wDAAwD;IACxD,MAAM,WAAW;IAEjB,kDAAkD;IAClD,YAAY,iBAAiB;IAC7B,kDAAkD;IAClD,aAAa,kBAAkB;IAC/B,oEAAoE;IACpE,gBAAgB,qBAAqB;IAErC,gDAAgD;IAChD,QAAQ,aAAa;IACrB,gDAAgD;IAChD,SAAS,cAAc;IACvB,kEAAkE;IAClE,YAAY,iBAAiB;IAE7B,gDAAgD;IAChD,UAAU,eAAe;IACzB,gDAAgD;IAChD,WAAW,gBAAgB;IAC3B,kEAAkE;IAClE,cAAc,mBAAmB;IAEjC,qDAAqD;IACrD,UAAU,eAAe;IACzB,qDAAqD;IACrD,WAAW,gBAAgB;IAC3B,uEAAuE;IACvE,cAAc,mBAAmB;IAEjC,uDAAuD;IACvD,aAAa,kBAAkB;IAC/B,uDAAuD;IACvD,cAAc,mBAAmB;IACjC,gEAAgE;IAChE,iBAAiB,sBAAsB;IAEvC,4DAA4D;IAC5D,cAAc,mBAAmB;IACjC,4DAA4D;IAC5D,eAAe,oBAAoB;IACnC,mEAAmE;IACnE,kBAAkB,uBAAuB;IAEzC,kEAAkE;IAClE,WAAW,gBAAgB;IAC3B,kEAAkE;IAClE,YAAY,iBAAiB;IAC7B,6DAA6D;IAC7D,eAAe,oBAAoB;IAEnC,yEAAyE;IACzE,UAAU,eAAe;IACzB,qEAAqE;IACrE,WAAW,gBAAgB;IAC3B,6DAA6D;IAC7D,cAAc,mBAAmB;IAEjC,2DAA2D;IAC3D,OAAO,YAAY;IACnB,uDAAuD;IACvD,QAAQ,aAAa;IACrB,yDAAyD;IACzD,WAAW,gBAAgB;IAE3B,2CAA2C;IAC3C,SAAS,cAAc;IACvB,+DAA+D;IAC/D,UAAU,eAAe;IACzB,oDAAoD;IACpD,aAAa,kBAAkB;CAChC;AAoCD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,gBAAgB,GAC3B,iBAAiB,eAAe,GAAG,aAAa,KAC/C,aAGuC,CAAC"}

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

@@ -1,62 +0,0 @@
-import Easing from 'easing-functions';
-const CurveFunctionIdMap = {
-    ["LINEAR" /* CurveFunctionId.LINEAR */]: Easing.Linear.None,
-    ["QUADRATIC_IN" /* CurveFunctionId.QUADRATIC_IN */]: Easing.Quadratic.In,
-    ["QUADRATIC_OUT" /* CurveFunctionId.QUADRATIC_OUT */]: Easing.Quadratic.Out,
-    ["QUADRATIC_IN_OUT" /* CurveFunctionId.QUADRATIC_IN_OUT */]: Easing.Quadratic.InOut,
-    ["CUBIC_IN" /* CurveFunctionId.CUBIC_IN */]: Easing.Cubic.In,
-    ["CUBIC_OUT" /* CurveFunctionId.CUBIC_OUT */]: Easing.Cubic.Out,
-    ["CUBIC_IN_OUT" /* CurveFunctionId.CUBIC_IN_OUT */]: Easing.Cubic.InOut,
-    ["QUARTIC_IN" /* CurveFunctionId.QUARTIC_IN */]: Easing.Quartic.In,
-    ["QUARTIC_OUT" /* CurveFunctionId.QUARTIC_OUT */]: Easing.Quartic.Out,
-    ["QUARTIC_IN_OUT" /* CurveFunctionId.QUARTIC_IN_OUT */]: Easing.Quartic.InOut,
-    ["QUINTIC_IN" /* CurveFunctionId.QUINTIC_IN */]: Easing.Quintic.In,
-    ["QUINTIC_OUT" /* CurveFunctionId.QUINTIC_OUT */]: Easing.Quintic.Out,
-    ["QUINTIC_IN_OUT" /* CurveFunctionId.QUINTIC_IN_OUT */]: Easing.Quintic.InOut,
-    ["SINUSOIDAL_IN" /* CurveFunctionId.SINUSOIDAL_IN */]: Easing.Sinusoidal.In,
-    ["SINUSOIDAL_OUT" /* CurveFunctionId.SINUSOIDAL_OUT */]: Easing.Sinusoidal.Out,
-    ["SINUSOIDAL_IN_OUT" /* CurveFunctionId.SINUSOIDAL_IN_OUT */]: Easing.Sinusoidal.InOut,
-    ["EXPONENTIAL_IN" /* CurveFunctionId.EXPONENTIAL_IN */]: Easing.Exponential.In,
-    ["EXPONENTIAL_OUT" /* CurveFunctionId.EXPONENTIAL_OUT */]: Easing.Exponential.Out,
-    ["EXPONENTIAL_IN_OUT" /* CurveFunctionId.EXPONENTIAL_IN_OUT */]: Easing.Exponential.InOut,
-    ["CIRCULAR_IN" /* CurveFunctionId.CIRCULAR_IN */]: Easing.Circular.In,
-    ["CIRCULAR_OUT" /* CurveFunctionId.CIRCULAR_OUT */]: Easing.Circular.Out,
-    ["CIRCULAR_IN_OUT" /* CurveFunctionId.CIRCULAR_IN_OUT */]: Easing.Circular.InOut,
-    ["ELASTIC_IN" /* CurveFunctionId.ELASTIC_IN */]: Easing.Elastic.In,
-    ["ELASTIC_OUT" /* CurveFunctionId.ELASTIC_OUT */]: Easing.Elastic.Out,
-    ["ELASTIC_IN_OUT" /* CurveFunctionId.ELASTIC_IN_OUT */]: Easing.Elastic.InOut,
-    ["BACK_IN" /* CurveFunctionId.BACK_IN */]: Easing.Back.In,
-    ["BACK_OUT" /* CurveFunctionId.BACK_OUT */]: Easing.Back.Out,
-    ["BACK_IN_OUT" /* CurveFunctionId.BACK_IN_OUT */]: Easing.Back.InOut,
-    ["BOUNCE_IN" /* CurveFunctionId.BOUNCE_IN */]: Easing.Bounce.In,
-    ["BOUNCE_OUT" /* CurveFunctionId.BOUNCE_OUT */]: Easing.Bounce.Out,
-    ["BOUNCE_IN_OUT" /* CurveFunctionId.BOUNCE_IN_OUT */]: Easing.Bounce.InOut,
-};
-/**
- * Resolves a curve function from an identifier or returns the function itself.
- *
- * This utility function allows you to use either a {@link CurveFunctionId} string
- * identifier or a custom function directly.
- *
- * @param curveFunctionId - Either a {@link CurveFunctionId} enum value or a
- *                          custom {@link CurveFunction} implementation
- * @returns The actual easing function that takes a normalized time value (0-1)
- *          and returns the eased value
- *
- * @example
- * ```typescript
- * import { getCurveFunction, CurveFunctionId } from '@newkrok/three-particles';
- *
- * // Using a predefined easing function
- * const easingFunc = getCurveFunction(CurveFunctionId.CUBIC_OUT);
- * console.log(easingFunc(0.5)); // Returns eased value at 50% progress
- *
- * // Using a custom function
- * const customEasing = (t: number) => t * t; // Quadratic
- * const customFunc = getCurveFunction(customEasing);
- * console.log(customFunc(0.5)); // Returns 0.25
- * ```
- */
-export const getCurveFunction = (curveFunctionId) => typeof curveFunctionId === 'function'
-    ? curveFunctionId
-    : CurveFunctionIdMap[curveFunctionId];

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

@@ -1,115 +0,0 @@
-/**
- * Defines the coordinate space in which particles are simulated.
- *
- * @enum {string}
- */
-export declare const enum SimulationSpace {
-    /**
-     * Particles move relative to the emitter's local coordinate system.
-     * When the emitter moves or rotates, particles move with it.
-     * Ideal for effects attached to moving objects (e.g., engine trails, character auras).
-     */
-    LOCAL = "LOCAL",
-    /**
-     * Particles move in world space and are independent of the emitter's transform.
-     * Once emitted, particles remain stationary or move according to their velocity in world coordinates.
-     * Ideal for environmental effects (e.g., smoke, explosions, ambient particles).
-     */
-    WORLD = "WORLD"
-}
-/**
- * Defines the geometric shape from which particles are emitted.
- *
- * @enum {string}
- */
-export declare const enum Shape {
-    /**
-     * Emit particles from a spherical volume or shell.
-     * Configure with {@link Sphere} properties (radius, arc, radiusThickness).
-     */
-    SPHERE = "SPHERE",
-    /**
-     * Emit particles from a conical volume or shell.
-     * Configure with {@link Cone} properties (angle, radius, arc, radiusThickness).
-     * Useful for directional effects like fire, smoke plumes, or spray effects.
-     */
-    CONE = "CONE",
-    /**
-     * Emit particles from a box volume, shell, or edges.
-     * Configure with {@link Box} properties (scale, emitFrom).
-     * Useful for area-based effects like dust clouds or rain.
-     */
-    BOX = "BOX",
-    /**
-     * Emit particles from a circular area or edge.
-     * Configure with {@link Circle} properties (radius, arc, radiusThickness).
-     * Useful for ground impacts, rings, or radial effects.
-     */
-    CIRCLE = "CIRCLE",
-    /**
-     * Emit particles from a rectangular area.
-     * Configure with {@link Rectangle} properties (scale, rotation).
-     * Useful for planar effects like rain on a surface or screen effects.
-     */
-    RECTANGLE = "RECTANGLE"
-}
-/**
- * Defines where on a shape particles are emitted from.
- * Not all shapes support all emit modes.
- *
- * @enum {string}
- */
-export declare const enum EmitFrom {
-    /**
-     * Emit particles from random positions within the entire volume of the shape.
-     * Supported by: SPHERE, CONE, BOX.
-     */
-    VOLUME = "VOLUME",
-    /**
-     * Emit particles from the surface/shell of the shape.
-     * Supported by: SPHERE, CONE, BOX.
-     */
-    SHELL = "SHELL",
-    /**
-     * Emit particles from the edges of the shape.
-     * Supported by: BOX.
-     */
-    EDGE = "EDGE"
-}
-/**
- * Defines how texture sheet animation is timed.
- *
- * @enum {string}
- */
-export declare const enum TimeMode {
-    /**
-     * Animation frames are based on the particle's lifetime percentage.
-     * The animation completes once over the particle's lifetime.
-     */
-    LIFETIME = "LIFETIME",
-    /**
-     * Animation frames are based on frames per second (FPS).
-     * The animation runs at a fixed speed regardless of particle lifetime.
-     */
-    FPS = "FPS"
-}
-/**
- * Defines the type of curve function used for animating values over a particle's lifetime.
- *
- * @enum {string}
- */
-export declare const enum LifeTimeCurve {
-    /**
-     * Use custom Bezier curves with control points.
-     * Provides maximum control over the animation curve shape.
-     * See {@link BezierCurve} for configuration.
-     */
-    BEZIER = "BEZIER",
-    /**
-     * Use predefined easing functions (e.g., easeInQuad, easeOutCubic).
-     * Convenient for common animation patterns.
-     * See {@link EasingCurve} and {@link CurveFunctionId} for available functions.
-     */
-    EASING = "EASING"
-}
-//# sourceMappingURL=three-particles-enums.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"three-particles-enums.d.ts","sourceRoot":"","sources":["../../../../src/js/effects/three-particles/three-particles-enums.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,0BAAkB,eAAe;IAC/B;;;;OAIG;IACH,KAAK,UAAU;IAEf;;;;OAIG;IACH,KAAK,UAAU;CAChB;AAED;;;;GAIG;AACH,0BAAkB,KAAK;IACrB;;;OAGG;IACH,MAAM,WAAW;IAEjB;;;;OAIG;IACH,IAAI,SAAS;IAEb;;;;OAIG;IACH,GAAG,QAAQ;IAEX;;;;OAIG;IACH,MAAM,WAAW;IAEjB;;;;OAIG;IACH,SAAS,cAAc;CACxB;AAED;;;;;GAKG;AACH,0BAAkB,QAAQ;IACxB;;;OAGG;IACH,MAAM,WAAW;IAEjB;;;OAGG;IACH,KAAK,UAAU;IAEf;;;OAGG;IACH,IAAI,SAAS;CACd;AAED;;;;GAIG;AACH,0BAAkB,QAAQ;IACxB;;;OAGG;IACH,QAAQ,aAAa;IAErB;;;OAGG;IACH,GAAG,QAAQ;CACZ;AAED;;;;GAIG;AACH,0BAAkB,aAAa;IAC7B;;;;OAIG;IACH,MAAM,WAAW;IAEjB;;;;OAIG;IACH,MAAM,WAAW;CAClB"}

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

@@ -1 +0,0 @@
-export {};

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

@@ -1,73 +0,0 @@
-import * as THREE from 'three';
-import { GeneralData, NormalizedParticleSystemConfig } from './types.js';
-/**
- * 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 declare const applyModifiers: ({ delta, generalData, normalizedConfig, attributes, particleLifetimePercentage, particleIndex, }: {
-    delta: number;
-    generalData: GeneralData;
-    normalizedConfig: NormalizedParticleSystemConfig;
-    attributes: THREE.NormalBufferAttributes;
-    particleLifetimePercentage: number;
-    particleIndex: number;
-}) => void;
-//# sourceMappingURL=three-particles-modifiers.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"three-particles-modifiers.d.ts","sourceRoot":"","sources":["../../../../src/js/effects/three-particles/three-particles-modifiers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,OAAO,EAAE,WAAW,EAAE,8BAA8B,EAAE,MAAM,YAAY,CAAC;AAKzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,eAAO,MAAM,cAAc,GAAI,kGAO5B;IACD,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,WAAW,CAAC;IACzB,gBAAgB,EAAE,8BAA8B,CAAC;IACjD,UAAU,EAAE,KAAK,CAAC,sBAAsB,CAAC;IACzC,0BAA0B,EAAE,MAAM,CAAC;IACnC,aAAa,EAAE,MAAM,CAAC;CACvB,SA2KA,CAAC"}

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;
-    }
-};