Creating Particle Systems with Processing

We used Processing in combination with Perplexity AI to create a complex particle system with emergent behavior, color transitions, and multiple physics forces:

java code:

import java.util.ArrayList;

ArrayList<Particle> particles;
float GRAVITY = 0.1;
float TURBULENCE = 0.2;
int MAX_PARTICLES = 1000;
int EMISSION_RATE = 50;

class Particle {
  PVector position;
  PVector velocity;
  PVector acceleration;
  color particleColor;
  float lifespan;
  float mass;
  float hue;
  
  Particle() {
    position = new PVector(random(width), random(height));
    velocity = PVector.random2D().mult(random(1, 5));
    acceleration = new PVector(0, 0);
    mass = random(0.5, 2.0);
    hue = random(360);
    lifespan = 255;
    
    // Create color with initial random hue
    particleColor = color(
      hue,
      random(70, 100), 
      random(70, 100),
      lifespan
    );
  }

  void applyForce(PVector force) {
    PVector f = PVector.div(force, mass);
    acceleration.add(f);
  }

  void update() {
    // Dynamic force application
    applyCentralGravity();
    applyWind();
    applyTurbulence();
    
    velocity.add(acceleration);
    position.add(velocity);
    acceleration.mult(0);
    
    // Color transition through hue spectrum
    hue = (hue + 0.5) % 360;
    particleColor = color(
      hue,
      constrain(80 + velocity.mag() * 5, 70, 100),
      constrain(90 - lifespan * 0.2, 70, 100),
      lifespan
    );
    
    lifespan -= 0.5 + mass;
  }

  void display() {
    noStroke();
    fill(particleColor);
    ellipse(position.x, position.y, mass * 4, mass * 4);
  }

  boolean isDead() {
    return lifespan <= 0 || 
           position.x < -100 || position.x > width + 100 ||
           position.y < -100 || position.y > height + 100;
  }

  void applyCentralGravity() {
    PVector center = new PVector(width/2, height/2);
    PVector gravity = PVector.sub(center, position);
    gravity.normalize();
    gravity.mult(GRAVITY * mass);
    applyForce(gravity);
  }

  void applyWind() {
    PVector wind = new PVector(
      noise(position.x * 0.01, frameCount * 0.01) - 0.5,
      noise(position.y * 0.01, frameCount * 0.02) - 0.5
    );
    wind.mult(TURBULENCE);
    applyForce(wind);
  }

  void applyTurbulence() {
    float angle = noise(position.x * 0.01, position.y * 0.01, frameCount * 0.01) * TWO_PI;
    PVector turbulence = PVector.fromAngle(angle);
    turbulence.mult(0.1 * mass);
    applyForce(turbulence);
  }
}

void setup() {
  size(1200, 800);
  colorMode(HSB, 360, 100, 100, 255);
  background(0);
  particles = new ArrayList<Particle>();
}

void draw() {
  background(0, 25); // Semi-transparent background for motion trails
  
  // Add new particles
  for (int i = 0; i < EMISSION_RATE; i++) {
    if (particles.size() < MAX_PARTICLES) {
      particles.add(new Particle());
    }
  }
  
  // Update and display particles
  for (int i = particles.size() - 1; i >= 0; i--) {
    Particle p = particles.get(i);
    p.update();
    p.display();
    
    if (p.isDead()) {
      particles.remove(i);
    }
  }
  
  // Dynamic system parameters
  GRAVITY = 0.1 + sin(frameCount * 0.01) * 0.05;
  TURBULENCE = 0.2 + cos(frameCount * 0.005) * 0.1;
}

This complex system features:

1. Advanced Physics Simulation:
   • Central gravitational pull
   • Perlin noise-based wind patterns
   • Angular turbulence forces
   • Mass-dependent behavior
2. Dynamic Color System:
   • Continuous hue shifting
   • Brightness based on velocity
   • Saturation affected by particle lifespan
   • Alpha transparency decay
3. Emergent Behavior:
   • Self-organizing particle flows
   • Organic swirling patterns
   • Mass-dependent trajectories
   • System-wide parameter oscillations
4. Efficient Particle Management:
   • Particle recycling system
   • Boundary culling
   • Mass-based size variation
   • Motion trail effects
5. Dynamic System Parameters:
   • Gravity that oscillates over time
   • Turbulence that evolves with noise
   • Auto-adjusting emission rates
   • Smooth parameter transitions