@newkrok/three-particles 1.0.3 → 2.0.1

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

@@ -0,0 +1,36 @@
+import * as THREE from 'three';
+import { EmitFrom } from './three-particles-enums.js';
+import { Constant, LifetimeCurve, Point3D, RandomBetweenTwoConstants } from './types.js';
+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;
+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;
+export declare const calculateRandomPositionAndVelocityOnBox: (position: THREE.Vector3, quaternion: THREE.Quaternion, velocity: THREE.Vector3, speed: number, { scale, emitFrom }: {
+    scale: Point3D;
+    emitFrom: EmitFrom;
+}) => void;
+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;
+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

@@ -0,0 +1 @@
+{"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,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,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,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,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,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

@@ -0,0 +1,179 @@
+import * as THREE from 'three';
+import { createBezierCurveFunction } from './three-particles-bezier.js';
+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);
+};
+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);
+};
+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);
+};
+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);
+};
+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));
+};

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

@@ -0,0 +1,13 @@
+import { CycleData, ParticleSystem, ParticleSystemConfig } from './types.js';
+export * from './types.js';
+export declare const blendingMap: {
+    'THREE.NoBlending': 0;
+    'THREE.NormalBlending': 1;
+    'THREE.AdditiveBlending': 2;
+    'THREE.SubtractiveBlending': 3;
+    'THREE.MultiplyBlending': 4;
+};
+export declare const getDefaultParticleSystemConfig: () => any;
+export declare const createParticleSystem: (config?: ParticleSystemConfig, externalNow?: number) => ParticleSystem;
+export declare const updateParticleSystems: ({ now, delta, elapsed }: CycleData) => void;
+//# sourceMappingURL=three-particles.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"three-particles.d.ts","sourceRoot":"","sources":["../../../../src/js/effects/three-particles/three-particles.ts"],"names":[],"mappings":"AA2BA,OAAO,EAEL,SAAS,EAIT,cAAc,EACd,oBAAoB,EAKrB,MAAM,YAAY,CAAC;AAEpB,cAAc,YAAY,CAAC;AAK3B,eAAO,MAAM,WAAW;;;;;;CAMvB,CAAC;AAEF,eAAO,MAAM,8BAA8B,WACiB,CAAC;AAwP7D,eAAO,MAAM,oBAAoB,GAC/B,SAAQ,oBAAqD,EAC7D,cAAc,MAAM,KACnB,cAojBF,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,yBAAyB,SAAS,SAmPvE,CAAC"}