moving the vector examples and adding comments

java/examples/Topics/Simulate/ForcesWithVectors/ForcesWithVectors.pde

@@ -0,0 +1,77 @@
+/**
+ * Forces (Gravity and Fluid Resistence) with Vectors 
+ * by Daniel Shiffman.  
+ * 
+ * Demonstration of multiple force acting on bodies (Mover class)
+ * Bodies experience gravity continuously
+ * Bodies experience fluid resistance when in "water"
+ *
+ * For the basics of working with PVector, see
+ * http://processing.org/learning/pvector/
+ * as well as examples in Topics/Vectors/
+ * 
+ */
+
+// Five moving bodies
+Mover[] movers = new Mover[10];
+
+// Liquid
+Liquid liquid;
+
+void setup() {
+  size(640, 360);
+  smooth();
+  reset();
+  // Create liquid object
+  liquid = new Liquid(0, height/2, width, height/2, 0.1);
+}
+
+void draw() {
+  background(0);
+  
+  // Draw water
+  liquid.display();
+
+  for (int i = 0; i < movers.length; i++) {
+    
+    // Is the Mover in the liquid?
+    if (liquid.contains(movers[i])) {
+      // Calculate drag force
+      PVector drag = liquid.drag(movers[i]);
+      // Apply drag force to Mover
+      movers[i].applyForce(drag);
+    }
+
+    // Gravity is scaled by mass here!
+    PVector gravity = new PVector(0, 0.1*movers[i].mass);
+    // Apply gravity
+    movers[i].applyForce(gravity);
+   
+    // Update and display
+    movers[i].update();
+    movers[i].display();
+    movers[i].checkEdges();
+  }
+  
+  fill(255);
+  text("click mouse to reset",10,30);
+  
+}
+
+void mousePressed() {
+  reset();
+}
+
+// Restart all the Mover objects randomly
+void reset() {
+  for (int i = 0; i < movers.length; i++) {
+    movers[i] = new Mover(random(0.5, 3), 40+i*70, 0);
+  }
+}
+
+
+
+
+
+
+

java/examples/Topics/Simulate/ForcesWithVectors/Liquid.pde

@@ -0,0 +1,60 @@
+/**
+ * Forces (Gravity and Fluid Resistence) with Vectors 
+ * by Daniel Shiffman.  
+ * 
+ * Demonstration of multiple force acting on bodies (Mover class)
+ * Bodies experience gravity continuously
+ * Bodies experience fluid resistance when in "water"
+ */
+ 
+ // Liquid class 
+ class Liquid {
+
+  
+  // Liquid is a rectangle
+  float x,y,w,h;
+  // Coefficient of drag
+  float c;
+
+  Liquid(float x_, float y_, float w_, float h_, float c_) {
+    x = x_;
+    y = y_;
+    w = w_;
+    h = h_;
+    c = c_;
+  }
+  
+  // Is the Mover in the Liquid?
+  boolean contains(Mover m) {
+    PVector l = m.location;
+    if (l.x > x && l.x < x + w && l.y > y && l.y < y + h) {
+      return true;
+    }  
+    else {
+      return false;
+    }
+  }
+  
+  // Calculate drag force
+  PVector drag(Mover m) {
+    // Magnitude is coefficient * speed squared
+    float speed = m.velocity.mag();
+    float dragMagnitude = c * speed * speed;
+
+    // Direction is inverse of velocity
+    PVector drag = m.velocity.get();
+    drag.mult(-1);
+    
+    // Scale according to magnitude
+    drag.setMag(dragMagnitude);
+    return drag;
+  }
+  
+  void display() {
+    noStroke();
+    fill(127);
+    rect(x,y,w,h);
+  }
+
+}
+

java/examples/Topics/Simulate/ForcesWithVectors/Mover.pde

@@ -0,0 +1,64 @@
+/**
+ * Forces (Gravity and Fluid Resistence) with Vectors 
+ * by Daniel Shiffman.  
+ * 
+ * Demonstration of multiple force acting on bodies (Mover class)
+ * Bodies experience gravity continuously
+ * Bodies experience fluid resistance when in "water"
+ */
+
+
+class Mover {
+
+  // location, velocity, and acceleration 
+  PVector location;
+  PVector velocity;
+  PVector acceleration;
+  
+  // Mass is tied to size
+  float mass;
+
+  Mover(float m, float x, float y) {
+    mass = m;
+    location = new PVector(x, y);
+    velocity = new PVector(0, 0);
+    acceleration = new PVector(0, 0);
+  }
+
+  // Newton's 2nd law: F = M * A
+  // or A = F / M
+  void applyForce(PVector force) {
+    // Divide by mass 
+    PVector f = PVector.div(force, mass);
+    // Accumulate all forces in acceleration
+    acceleration.add(f);
+  }
+
+  void update() {
+    
+    // Velocity changes according to acceleration
+    velocity.add(acceleration);
+    // Location changes by velocity
+    location.add(velocity);
+    // We must clear acceleration each frame
+    acceleration.mult(0);
+  }
+  
+  // Draw Mover
+  void display() {
+    stroke(255);
+    strokeWeight(2);
+    fill(255, 200);
+    ellipse(location.x, location.y, mass*16, mass*16);
+  }
+  
+  // Bounce off bottom of window
+  void checkEdges() {
+    if (location.y > height) {
+      velocity.y *= -0.9;  // A little dampening when hitting the bottom
+      location.y = height;
+    }
+  }
+}
+
+

java/examples/Topics/Simulate/GravitationalAttraction3D/GravitationalAttraction3D.pde

@@ -0,0 +1,71 @@
+/**
+ * Gravitational Attraction (3D) 
+ * by Daniel Shiffman.  
+ * 
+ * Simulating gravitational attraction 
+ * G ---> universal gravitational constant
+ * m1 --> mass of object #1
+ * m2 --> mass of object #2
+ * d ---> distance between objects
+ * F = (G*m1*m2)/(d*d)
+ *
+ * For the basics of working with PVector, see
+ * http://processing.org/learning/pvector/
+ * as well as examples in Topics/Vectors/
+ * 
+ */
+
+// A bunch of planets
+Planet[] planets = new Planet[10];
+// One sun (note sun is not attracted to planets (violation of Newton's 3rd Law)
+Sun s;
+
+// An angle to rotate around the scene
+float angle = 0;
+
+void setup() {
+  size(640, 360, P3D);
+  smooth();
+  // Some random planets
+  for (int i = 0; i < planets.length; i++) {
+    planets[i] = new Planet(random(0.1, 2), random(-width/2, width/2), random(-height/2, height/2), random(-100, 100));
+  }
+  // A single sun
+  s = new Sun();
+}
+
+void draw() {
+  background(0);
+  // Setup the scene
+  sphereDetail(8);
+  lights();
+  translate(width/2, height/2);
+  rotateY(angle);
+
+
+  // Display the Sun
+  s.display();
+
+  // All the Planets
+  for (int i = 0; i < planets.length; i++) {
+    // Sun attracts Planets
+    PVector force = s.attract(planets[i]);
+    planets[i].applyForce(force);
+    // Update and draw Planets
+    planets[i].update();
+    planets[i].display();
+  }
+
+  // Rotate around the scene
+  angle += 0.003;
+}
+
+
+
+
+
+
+
+
+
+

java/examples/Topics/Simulate/GravitationalAttraction3D/Planet.pde

@@ -0,0 +1,45 @@
+// Gravitational Attraction (3D) 
+// Daniel Shiffman <http://www.shiffman.net>
+
+// A class for an orbiting Planet
+
+class Planet {
+  
+  // Basic physics model (location, velocity, acceleration, mass)
+  PVector location;
+  PVector velocity;
+  PVector acceleration;
+  float mass;
+
+  Planet(float m, float x, float y, float z) {
+    mass = m;
+    location = new PVector(x,y,z);
+    velocity = new PVector(1,0);   // Arbitrary starting velocity
+    acceleration = new PVector(0,0);
+  }
+  
+  // Newton's 2nd Law (F = M*A) applied
+  void applyForce(PVector force) {
+    PVector f = PVector.div(force,mass);
+    acceleration.add(f);
+  }
+
+  // Our motion algorithm (aka Euler Integration)
+  void update() {
+    velocity.add(acceleration); // Velocity changes according to acceleration
+    location.add(velocity);     // Location changes according to velocity
+    acceleration.mult(0);
+  }
+
+  // Draw the Planet
+  void display() {
+    noStroke();
+    fill(255);
+    pushMatrix();
+    translate(location.x,location.y,location.z);
+    sphere(mass*8);
+    popMatrix();
+  }
+}
+
+

java/examples/Topics/Simulate/GravitationalAttraction3D/Sun.pde

@@ -0,0 +1,39 @@
+// Gravitational Attraction (3D) 
+// Daniel Shiffman <http://www.shiffman.net>
+
+// A class for an attractive body in our world
+
+class Sun {
+  float mass;         // Mass, tied to size
+  PVector location;   // Location
+  float G;            // Universal gravitational constant (arbitrary value)
+
+  Sun() {
+    location = new PVector(0,0);
+    mass = 20;
+    G = 0.4;
+  }
+
+
+  PVector attract(Planet m) {
+    PVector force = PVector.sub(location,m.location);    // Calculate direction of force
+    float d = force.mag();                               // Distance between objects
+    d = constrain(d,5.0,25.0);                    // Limiting the distance to eliminate "extreme" results for very close or very far objects
+    force.normalize();                                   // Normalize vector (distance doesn't matter here, we just want this vector for direction)
+    float strength = (G * mass * m.mass) / (d * d);      // Calculate gravitional force magnitude
+    force.mult(strength);                                // Get force vector --> magnitude * direction
+    return force;
+  }
+
+  // Draw Sun
+  void display() {
+    stroke(255);
+    noFill();
+    pushMatrix();
+    translate(location.x,location.y,location.z);
+    sphere(mass*2);
+    popMatrix();
+  }
+}
+
+