ruby-processing 1.0.11 → 2.4.1

data/samples/processing_app/topics/simulate/data/java_args.txt

@@ -0,0 +1,2 @@
+-XX:+OptimizeStringConcat -XX:CompileCommand=dontinline,org.jruby.runtime.invokedynamic.InvokeDynamicSupport::invocationFallback 
+

data/samples/processing_app/topics/simulate/flocking.rb

@@ -0,0 +1,32 @@
+#
+# Flocking 
+# by Daniel Shiffman.  
+# 
+# An implementation of Craig Reynold's Boids program to simulate
+# the flocking behavior of birds. Each boid steers itself based on 
+# rules of avoidance, alignment, and coherence.
+# 
+# Click the mouse to add a new boid.
+#
+load_library :flock
+
+attr_reader :flock
+
+def setup
+  size(640, 360)
+  @flock = Flock.new
+  # Add an initial set of boids into the system
+  150.times do
+    flock << Boid.new(width/2, height/2)
+  end
+end
+
+def draw
+  background(50)
+  flock.run
+end
+
+# Add a new boid into the System
+def mouse_pressed
+  flock << Boid.new(mouse_x, mouse_y)
+end

data/samples/processing_app/topics/simulate/library/flock/flock.rb

@@ -0,0 +1,206 @@
+# The Flock (a list of Boid objects)
+
+class Flock 
+  extend Enumerable
+  
+  attr_reader :boids
+  
+  def initialize
+    @boids = []	  
+  end
+
+  def each &block
+    boids.each &block	  
+  end
+  
+  def << obj
+    boids << obj
+  end
+
+  def run
+    self.each do |bird|
+      bird.run(self)  # Passing the entire list of boids to each boid individually
+    end
+  end
+  
+end
+
+# The Boid class
+
+class Boid
+  include Processing::Proxy
+  
+  attr_reader :location, :velocity, :acceleration, :r, :maxforce, :maxspeed
+  
+  def initialize(x, y)
+    @acceleration = PVector.new(0, 0)
+    @velocity = PVector.new(rand(-1.0 .. 1), rand(-1.0 .. 1))
+    @location = PVector.new(x, y)
+    @r = 2.0
+    @maxspeed = 2
+    @maxforce = 0.03
+  end
+  
+  def run(boids)
+    flock(boids)
+    update
+    borders
+    render
+  end
+  
+  def apply_force(force)
+    # We could add mass here if we want A = F / M
+    acceleration.add(force)
+  end
+  
+  # We accumulate a new acceleration each time based on three rules
+  def flock boids
+    sep = separate(boids)   # Separation
+    ali = align(boids)      # Alignment
+    coh = cohesion(boids)   # Cohesion
+    # Arbitrarily weight these forces
+    sep.mult(1.5)
+    ali.mult(1.0)
+    coh.mult(1.0)
+    # Add the force vectors to acceleration
+    apply_force(sep)
+    apply_force(ali)
+    apply_force(coh)
+  end
+  
+  # Method to update location
+  def update
+    # Update velocity
+    velocity.add(acceleration)
+    # Limit speed
+    velocity.limit(maxspeed)
+    location.add(velocity)
+    # Reset accelertion to 0 each cycle
+    acceleration.mult(0)
+  end
+  
+  # A method that calculates and applies a steering force towards a target
+  # STEER = DESIRED MINUS VELOCITY
+  def seek(target)
+    desired = PVector.sub(target,location)  # A vector pointing from the location to the target
+    # Normalize desired and scale to maximum speed
+    desired.normalize
+    desired.mult(maxspeed)
+    # Steering = Desired minus Velocity
+    steer = PVector.sub(desired,velocity)
+    steer.limit(maxforce)  # Limit to maximum steering force
+    return steer
+  end
+
+  def render
+    # Draw a triangle rotated in the direction of velocity
+    theta = velocity.heading + radians(90)
+    fill(200,100)
+    stroke(255)
+    push_matrix
+    translate(location.x,location.y)
+    rotate(theta)
+    begin_shape(TRIANGLES)
+    vertex(0, -r*2)
+    vertex(-r, r*2)
+    vertex(r, r*2)
+    end_shape
+    pop_matrix
+  end
+
+  # Wraparound
+  def borders
+    if (location.x < -r) 
+      location.x = $app.width+r
+    end
+    if (location.y < -r) 
+      location.y = $app.height+r
+    end
+    if (location.x > $app.width+r)
+      location.x = -r
+    end
+    if (location.y > $app.height+r)
+      location.y = -r
+    end
+  end
+          
+  # Separation
+  # Method checks for nearby boids and steers away
+  def separate boids
+    desiredseparation = 25.0
+    steer = PVector.new(0, 0, 0)
+    count = 0
+    # For every boid in the system, check if it's too close
+    boids.each do |other|
+      d = PVector.dist(location, other.location)
+      # If the distance is greater than 0 and less than an arbitrary amount (0 when you are yourself)
+      if ((d > 0) && (d < desiredseparation))
+        # Calculate vector pointing away from neighbor
+        diff = PVector.sub(location,other.location)
+        diff.normalize
+        diff.div(d)        # Weight by distance
+        steer.add(diff)
+        count += 1            # Keep track of how many
+      end
+    end
+    # Average -- divide by how many
+    if (count > 0)
+      steer.div(count.to_f)
+    end
+    
+    # As long as the vector is greater than 0
+    if (steer.mag > 0)
+      # Implement Reynolds: Steering = Desired - Velocity
+      steer.normalize
+      steer.mult(maxspeed)
+      steer.sub(velocity)
+      steer.limit(maxforce)
+    end
+    return steer
+  end
+    
+  # Alignment
+  # For every nearby boid in the system, calculate the average velocity
+  def align boids
+    neighbordist = 50
+    sum = PVector.new(0, 0)
+    count = 0
+    boids.each do |other|
+      d = PVector.dist(location, other.location)
+      if ((d > 0) && (d < neighbordist))
+        sum.add(other.velocity)
+        count += 1
+      end
+    end
+    if (count > 0)
+      sum.div(count.to_f)
+      sum.normalize
+      sum.mult(maxspeed)
+      steer = PVector.sub(sum, velocity)
+      steer.limit(maxforce)
+      return steer
+    else
+      return PVector.new(0,0)
+    end
+  end
+    
+  # Cohesion
+  # For the average location (i.e. center) of all nearby boids, calculate steering vector towards that location
+  def cohesion boids
+    neighbordist = 50
+    sum = PVector.new(0, 0)   # Start with empty vector to accumulate all locations
+    count = 0
+    boids.each do |other|
+      d = PVector.dist(location, other.location)
+      if ((d > 0) && (d < neighbordist))
+        sum.add(other.location) # Add location
+        count += 1
+      end
+    end
+    sum.div(count) unless (count == 0)        # avoid div by zero
+    return (count > 0)? seek(sum) : PVector.new(0, 0) 
+  end
+end
+
+
+

data/samples/processing_app/topics/simulate/multiple_particle_systems.rb

@@ -12,156 +12,168 @@ module Runnable
   end
 end
 
-
 class Vector
   attr_accessor :x, :y
-
+  
   def initialize(x, y)
     @x, @y = x, y
   end
-
+  
   def +(other)
     return Vector.new(@x + other, @y + other)     if other.is_a?(Numeric)
     return Vector.new(@x + other.x, @y + other.y) if other.is_a?(Vector)
     self
   end
-
+  
   def heading
     -1 * Math::atan2(-@y, @x)
   end
-
+  
   def magnitude
     @x * @x + @y * @y
   end
 end
 
 
-class ParticleSystem < Array
-  include Runnable
-  alias_method :dead?, :empty?
-
+class ParticleSystem 
+  extend Enumerable
+  include Runnable    
+  
+  attr_reader :particle_systems 
+  
   def initialize(number, origin)
-    super()
+    @particle_systems = [] 
     @origin = origin
     kind = rand < 0.5 ? Sketch::Particle : Sketch::CrazyParticle
     number.times { self << kind.new(origin) }
   end
-end
-
-
-class Sketch < Processing::App
-  def setup
-    smooth
-    color_mode(RGB, 255, 255, 255, 100)
-    ellipse_mode(CENTER)
-
-    @particle_systems = []
-    @particle_systems.extend Runnable
-  end
-
-  def draw
-    background 0
-    @particle_systems.run
+  
+  def each &block
+    particle_systems.each &block    
   end
-
-  def mouse_pressed
-    origin = rand(21) + 5
-    vector = Vector.new(mouse_x, mouse_y)
-    @particle_systems << ParticleSystem.new(origin, vector)
+  
+  def << obj
+    particle_systems << obj
   end
   
+  def reject! &block
+    particle_systems.reject! &block
+  end
   
-  class Particle
-    def initialize(origin)
-      @origin = origin
-      @velocity = Vector.new(rand * 2 - 1, rand * 2 - 2)
-      @acceleration = Vector.new(0, 0.05)
-      @radius = 10
-      @lifespan = 100
-    end
-
-    def run
-      update
-      grow
-      render
-      render_velocity_vector
-    end
+  def dead?
+    particle_systems.empty?
+  end  
+end
 
-    def update
-      @velocity += @acceleration
-      @origin += @velocity
-    end
 
-    def grow
-      @lifespan -= 1
-    end
+def setup
+  size 640, 580   
+  color_mode(RGB, 255, 255, 255, 100)
+  ellipse_mode(CENTER)    
+  @particle_systems = ParticleSystem.new(rand(21) + 5, Vector.new(width/2, height/2))
+end
 
-    def dead?
-      @lifespan <= 0
-    end
+def draw
+  background 0
+  @particle_systems.run
+end
 
-    def render
-      stroke(255, @lifespan)
-      fill(100, @lifespan)
-      ellipse(@origin.x, @origin.y, @radius, @radius)
-    end
+def mouse_pressed
+  origin = rand(21) + 5
+  vector = Vector.new(mouse_x, mouse_y)
+  @particle_systems << ParticleSystem.new(origin, vector)
+end
 
-    def render_velocity_vector
-      scale = 10
-      arrow_size = 4
 
-      push_matrix
-      
-      translate(@origin.x, @origin.y)
-      rotate(@velocity.heading)
+class Particle
+  def initialize(origin)
+    @origin = origin
+    @velocity = Vector.new(rand(-1.0 .. 1), rand(-2.0 .. 0))
+    @acceleration = Vector.new(0, 0.05)
+    @radius = 10
+    @lifespan = 100
+  end
+  
+  def run
+    update
+    grow
+    render
+    render_velocity_vector
+  end
+  
+  def update
+    @velocity += @acceleration
+    @origin += @velocity
+  end
+  
+  def grow
+    @lifespan -= 1
+  end
+  
+  def dead?
+    @lifespan <= 0
+  end
+  
+  def render
+    stroke(255, @lifespan)
+    fill(100, @lifespan)
+    ellipse(@origin.x, @origin.y, @radius, @radius)
+  end
+  
+  def render_velocity_vector
+    scale = 10
+    arrow_size = 4
+    
+    push_matrix
+    
+    translate(@origin.x, @origin.y)
+    rotate(@velocity.heading)
+    
+    length = @velocity.magnitude * scale
+    
+    line 0, 0, length, 0
+    line length, 0, length - arrow_size, arrow_size / 2
+    line length, 0, length - arrow_size, -arrow_size / 2
+    
+    pop_matrix
+  end
+end
 
-      length = @velocity.magnitude * scale
 
-      line 0, 0, length, 0
-      line length, 0, length - arrow_size, arrow_size / 2
-      line length, 0, length - arrow_size, -arrow_size / 2
-      
-      pop_matrix
-    end
+class CrazyParticle < Particle
+  def initialize(origin)
+    super
+    @theta = 0
   end
   
+  def run
+    update
+    grow
+    render
+    render_rotation_line
+  end
   
-  class CrazyParticle < Particle
-    def initialize(origin)
-      super
-      @theta = 0
-    end
-
-    def run
-      update
-      grow
-      render
-      render_rotation_line
-    end
-    
-    def update
-      super
-      @theta += @velocity.x * @velocity.magnitude / 10
-    end
-
-    def grow
-      @lifespan -= 0.8
-    end
-
-    def render_rotation_line
-      push_matrix
-      
-      translate(@origin.x, @origin.y)
-      rotate(@theta)
-      
-      stroke(255, @lifespan)
-      
-      line(0, 0, 25, 0)
-      
-      pop_matrix
-    end
+  def update
+    super
+    @theta += @velocity.x * @velocity.magnitude / 10
   end
   
+  def grow
+    @lifespan -= 0.8
+  end
+  
+  def render_rotation_line
+    push_matrix
+    
+    translate(@origin.x, @origin.y)
+    rotate(@theta)
+    
+    stroke(255, @lifespan)
+    
+    line(0, 0, 25, 0)
+    
+    pop_matrix
+  end
 end
 
-Sketch.new :width => 640, :height => 340
+