@newkrok/three-particles 1.0.3 → 2.0.1

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

@@ -1,212 +0,0 @@
-import * as THREE from "three";
-
-import { EmitFrom } from "./three-particles-enums.js";
-
-export const calculateRandomPositionAndVelocityOnSphere = (
-  position,
-  quaternion,
-  velocity,
-  startSpeed,
-  { 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 randomizedSpeed = THREE.MathUtils.randFloat(
-    startSpeed.min,
-    startSpeed.max
-  );
-  const speedMultiplierByPosition = 1 / position.length();
-  velocity.set(
-    position.x * speedMultiplierByPosition * randomizedSpeed,
-    position.y * speedMultiplierByPosition * randomizedSpeed,
-    position.z * speedMultiplierByPosition * randomizedSpeed
-  );
-  velocity.applyQuaternion(quaternion);
-};
-
-export const calculateRandomPositionAndVelocityOnCone = (
-  position,
-  quaternion,
-  velocity,
-  startSpeed,
-  { 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 randomizedSpeed = THREE.MathUtils.randFloat(
-    startSpeed.min,
-    startSpeed.max
-  );
-  const speedMultiplierByPosition = 1 / positionLength;
-  velocity.set(
-    position.x *
-      sinNormalizedAngle *
-      speedMultiplierByPosition *
-      randomizedSpeed,
-    position.y *
-      sinNormalizedAngle *
-      speedMultiplierByPosition *
-      randomizedSpeed,
-    Math.cos(normalizedAngle) * randomizedSpeed
-  );
-  velocity.applyQuaternion(quaternion);
-};
-
-export const calculateRandomPositionAndVelocityOnBox = (
-  position,
-  quaternion,
-  velocity,
-  startSpeed,
-  { scale, emitFrom }
-) => {
-  switch (emitFrom) {
-    case 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 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 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);
-
-  const randomizedSpeed = THREE.MathUtils.randFloat(
-    startSpeed.min,
-    startSpeed.max
-  );
-  velocity.set(0, 0, randomizedSpeed);
-  velocity.applyQuaternion(quaternion);
-};
-
-export const calculateRandomPositionAndVelocityOnCircle = (
-  position,
-  quaternion,
-  velocity,
-  startSpeed,
-  { 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 randomizedSpeed = THREE.MathUtils.randFloat(
-    startSpeed.min,
-    startSpeed.max
-  );
-
-  const positionLength = position.length();
-  const speedMultiplierByPosition = 1 / positionLength;
-  velocity.set(
-    position.x * speedMultiplierByPosition * randomizedSpeed,
-    position.y * speedMultiplierByPosition * randomizedSpeed,
-    0
-  );
-  velocity.applyQuaternion(quaternion);
-};
-
-export const calculateRandomPositionAndVelocityOnRectangle = (
-  position,
-  quaternion,
-  velocity,
-  startSpeed,
-  { rotation, scale }
-) => {
-  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);
-
-  const randomizedSpeed = THREE.MathUtils.randFloat(
-    startSpeed.min,
-    startSpeed.max
-  );
-  velocity.set(0, 0, randomizedSpeed);
-  velocity.applyQuaternion(quaternion);
-};

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

@@ -1,138 +0,0 @@
-export type Point3D = {
-  x?: number;
-  y?: number;
-  z?: number;
-};
-
-export type Transform = {
-  position?: Point3D;
-  rotation?: Point3D;
-  scale?: Point3D;
-};
-
-export type MinMaxNumber = {
-  min?: number;
-  max?: number;
-};
-
-export type Rgb = {
-  r?: number;
-  g?: number;
-  b?: number;
-};
-
-export type MinMaxColor = {
-  min?: Rgb;
-  max?: Rgb;
-};
-
-export type Emission = {
-  rateOverTime?: number;
-  rateOverDistance?: number;
-};
-
-export const enum SimulationSpace {
-  LOCAL = "LOCAL",
-  WORLD = "WORLD",
-}
-
-export const enum Shape {
-  SPHERE = "SPHERE",
-  CONE = "CONE",
-  BOX = "BOX",
-  CIRCLE = "CIRCLE",
-  RECTANGLE = "RECTANGLE",
-}
-
-export const enum EmitFrom {
-  VOLUME = "VOLUME",
-  SHELL = "SHELL",
-  EDGE = "EDGE",
-}
-
-export const enum TimeMode {
-  LIFETIME = "LIFETIME",
-  FPS = "FPS",
-}
-
-export type ShapeConfig = {
-  shape?: Shape;
-  sphere?: {
-    radius?: number;
-    radiusThickness?: number;
-    arc?: number;
-  };
-  cone?: {
-    angle?: number;
-    radius?: number;
-    radiusThickness?: number;
-    arc?: number;
-  };
-  circle?: {
-    radius?: number;
-    radiusThickness?: number;
-    arc?: number;
-  };
-  rectangle?: {
-    rotation?: Point3D;
-    scale?: Point3D;
-  };
-  box?: {
-    scale?: Point3D;
-    emitFrom?: EmitFrom;
-  };
-};
-
-export type TextureSheetAnimation = {
-  tiles?: THREE.Vector2;
-  timeMode?: TimeMode;
-  fps?: number;
-  startFrame?: MinMaxNumber;
-};
-
-export type ParticleSystemConfig = {
-  transform?: Transform;
-  duration?: number;
-  looping?: boolean;
-  startDelay?: MinMaxNumber;
-  startLifetime?: MinMaxNumber;
-  startSpeed?: MinMaxNumber;
-  startSize?: MinMaxNumber;
-  startRotation?: MinMaxNumber;
-  startColor?: MinMaxColor;
-  startOpacity?: MinMaxNumber;
-  gravity?: number;
-  simulationSpace?: SimulationSpace;
-  maxParticles?: number;
-  emission?: Emission;
-  shape?: ShapeConfig;
-  map?: THREE.Texture;
-  renderer?: any;
-  velocityOverLifetime?: any;
-  sizeOverLifetime?: any;
-  opacityOverLifetime?: any;
-  rotationOverLifetime?: any;
-  noise?: any;
-  textureSheetAnimation?: TextureSheetAnimation;
-  _editorData: any;
-};
-
-export type ParticleSystem = {
-  instance: THREE.Object3D;
-  resumeEmitter: () => void;
-  pauseEmitter: () => void;
-  dispose: () => void;
-};
-
-export type CycleData = {
-  now: number,
-  delta: number,
-  elapsed: number,
-};
-
-export function createParticleSystem(
-  config: ParticleSystemConfig,
-  externalNow?: number
-): ParticleSystem;
-
-export function updateParticleSystems(cycleData:CycleData): void;