ruby-processing 2.4.4 → 2.5.0

data/samples/processing_app/library/vecmath/vec2d/Rakefile

@@ -0,0 +1,30 @@
+# Simple demo Rakefile to autorun samples in current directory
+# adjust path to rp5 executable, and or opts as required
+
+SAMPLES_DIR = './'
+
+desc 'run demo'
+task default: [:demo]
+
+desc 'demo'
+task :demo do
+  samples_list.shuffle.each{ |sample| run_sample sample }
+end
+
+def samples_list
+  files = []
+  Dir.chdir(SAMPLES_DIR)
+  Dir.glob('*.rb').each do |file|
+    files << File.join(SAMPLES_DIR, file)
+  end
+  return files
+end
+
+def run_sample(sample_name)
+  puts "Running #{sample_name}...quit to run next sample"
+  open("|rp5 --nojruby run #{sample_name}", 'r') do |io|
+    while l = io.gets
+      puts(l.chop)
+    end      
+  end
+end

data/samples/processing_app/library/vecmath/{acceleration_with_vectors.rb → vec2d/acceleration_with_vectors.rb}

@@ -5,7 +5,8 @@
 # 
 # Demonstration of the basics of motion with vector.
 # A "Mover" object stores location, velocity, and acceleration as vectors
-# The motion is controlled by affecting the acceleration (in this case towards the mouse)
+# The motion is controlled by affecting the acceleration (in this case 
+# towards the mouse)
 #
 # For more examples of simulating motion and physics with vectors, see 
 # Simulate/ForcesWithVectors, Simulate/GravitationalAttraction3D
@@ -16,13 +17,12 @@ load_library 'vecmath'
 attr_reader :mover
 
 def setup
-  size(640,360)
+  size(640, 360)
   @mover = Mover.new(width, height)
 end
 
 def draw
   background(0)
-  
   # Update the location
   mover.update
   # Display the Mover
@@ -59,7 +59,7 @@ class Mover
     # Limit the velocity to topspeed, PVector has a limit function 
     # here we supply a block that evaluates to a boolean to set
     # the velocit conditionally
-    velocity.set_mag topspeed {velocity.mag_squared > topspeed**2}
+    velocity.set_mag(topspeed) { velocity.mag > topspeed }
     # Location changes by velocity vector
     @location += velocity
   end
@@ -70,6 +70,5 @@ class Mover
     fill(127)
     ellipse(location.x, location.y, 48, 48)
   end
-  
 end
 

data/samples/processing_app/library/vecmath/{bouncing_ball.rb → vec2d/bouncing_ball.rb}

@@ -8,44 +8,38 @@
 # See AccelerationWithVectors for an example of how to simulate motion using vectors in an object
 #
 load_library :vecmath
+RADIUS = 24
 
 attr_reader :loc,  # Location of shape
             :velocity,  # Velocity of shape
             :gravity   # Gravity acts at the shape's acceleration
 
 def setup
-  size(640,360)
+  size(640, 360)
   smooth 4
-  @loc = Vec2D.new(100,100)
-  @velocity = Vec2D.new(1.5,2.1)
-  @gravity = Vec2D.new(0,0.2)
+  @loc = Vec2D.new(100, 100)
+  @velocity = Vec2D.new(1.5, 2.1)
+  @gravity = Vec2D.new(0, 0.2)
 
 end
 
 def draw
   background(0)
-  
   # Add velocity to the location.
   @loc += velocity
   # Add gravity to velocity
   @velocity += gravity
-  
   # Bounce off edges
-if ((loc.x > width) || (loc.x < 0))
-    velocity.x *= -1
-  end
-if (loc.y > height)
+  velocity.x *= -1 unless (RADIUS .. width - RADIUS).include?(loc.x)
+  if loc.y > (height - RADIUS)
     # We're reducing velocity ever so slightly 
     # when it hits the bottom of the window
     velocity.y *= -0.95 
-    loc.y = height
+    loc.y = height - RADIUS
   end
-
   # Display circle at location vector
   stroke(255)
   stroke_weight(2)
   fill(127)
-  ellipse(loc.x,loc.y,48,48)
+  ellipse(loc.x, loc.y, RADIUS * 2, RADIUS * 2)
 end
-
-

data/samples/processing_app/library/vecmath/{circle_collision.rb → vec2d/circle_collision.rb}

@@ -6,30 +6,30 @@ load_library :vecmath
 # This inner class demonstrates the use of Ruby-Processing's emulation of
 # Java inner classes. The Balls are able to call Processing::App methods.
 class Ball
-  attr_accessor :x, :y, :r, :m, :vec
-  def initialize(r = 0.0, vec = nil, x = 0.0, y = 0.0)
-    @x, @y, @r = x, y, r
+  attr_accessor :position, :r, :m, :velocity, :current
+  def initialize(r = 0.0, velocity = nil, position = Vec2D.new)
+    @position, @velocity, @r = position, velocity, r
     @m = r * 0.1
-    @vec = vec
   end
   
   def move
-    @x += @vec.x
-    @y += @vec.y
+    @position += velocity
   end
   
   def draw
-    r = @r * 2
-    ellipse @x, @y, r, r
-    @px, @py = @x, @y
+    d = r * 2
+    ellipse position.x, position.y, d, d
+    @current = position.copy
   end
   
   def erase
-    r = @r * 2
-    rect @px, @py, r, r
+    d = r * 2
+    rect current.x, current.y, d, d
   end
 end
 
+attr_reader :balls
+
 
 def setup
   size 400, 400
@@ -37,8 +37,8 @@ def setup
   frame_rate 30
   rect_mode RADIUS    
   @balls = []
-  5.times { @balls << Ball.new(10, Vec2D.new(2.15, -1.35), *empty_space(15)) }
-  2.times { @balls << Ball.new(40, Vec2D.new(-1.65, 0.42), *empty_space(45)) }    
+  5.times { balls << Ball.new(10, Vec2D.new(2.15, -1.35), empty_space(15)) }
+  2.times { balls << Ball.new(40, Vec2D.new(-1.65, 0.42), empty_space(45)) }    
   @frame_time = nil
   @frame_count = 0
 end
@@ -55,12 +55,12 @@ def draw
     background 51
   else
     fill 51
-    @balls.each { |ball| ball.erase }
+    balls.each { |ball| ball.erase }
   end
   
   # move the balls 
   fill 240
-  @balls.each do |ball|
+  balls.each do |ball|
     ball.move
     ball.draw
     check_boundary_collision ball
@@ -70,21 +70,17 @@ end
 
 
 def empty_space(r)
-  x = y = nil
-  while !x || !empty_space?(x, y, r) do
-    x = rand(width - 3 * r) + r
-    y = rand(height - 3 * r) + r
+  pos = nil
+  while !pos || !empty_space?(pos, r) do
+    pos = Vec2D.new(rand(r .. width - r), rand(r .. height - r))
   end
-  return x, y
+  return pos
 end
 
 
-def empty_space?(x, y, r)
-  @balls.each do |ball|
-    vx = x - ball.x
-    vy = y - ball.y
-    mag = sqrt(vx * vx + vy * vy)
-    return false if mag < r + ball.r
+def empty_space?(position, r)
+  balls.each do |ball|
+    return false if position.dist(ball.position) < r + ball.r
   end
   return true
 end
@@ -92,14 +88,14 @@ end
 
 def check_object_collisions
   
-  (0...(@balls.length)).each do |ia|
-    ((ia+1)...(@balls.length)).each do |ib|
+  (0...(balls.length)).each do |ia|
+    ((ia+1)...(balls.length)).each do |ib|
       
-      ba = @balls[ia]
-      bb = @balls[ib]
+      ba = balls[ia]
+      bb = balls[ib]
       
       # get distances between the balls components
-      bVect = Vec2D.new( bb.x - ba.x, bb.y - ba.y)      
+      bVect = bb.position - ba.position   
       # calculate magnitude of the vector separating the balls
       bVectMag = bVect.mag
       next if bVectMag >= ba.r + bb.r
@@ -118,15 +114,15 @@ def check_object_collisions
       # bTemp[0].x and bTemp[0].y will initialize
       # automatically to 0.0, which is what you want
       # since bb will rotate around ba
-      bTemp[1].x  = cosine * bVect.x + sine * bVect.y
-      bTemp[1].y  = cosine * bVect.y - sine * bVect.x
+      bTemp[1].position.x  = cosine * bVect.x + sine * bVect.y
+      bTemp[1].position.y  = cosine * bVect.y - sine * bVect.x
       
       # rotate Temporary velocities
       vTemp = [Vec2D.new, Vec2D.new]
-      vTemp[0].x  = cosine * ba.vec.x + sine * ba.vec.y
-      vTemp[0].y  = cosine * ba.vec.y - sine * ba.vec.x
-      vTemp[1].x  = cosine * bb.vec.x + sine * bb.vec.y
-      vTemp[1].y  = cosine * bb.vec.y - sine * bb.vec.x
+      vTemp[0].x  = cosine * ba.velocity.x + sine * ba.velocity.y
+      vTemp[0].y  = cosine * ba.velocity.y - sine * ba.velocity.x
+      vTemp[1].x  = cosine * bb.velocity.x + sine * bb.velocity.y
+      vTemp[1].y  = cosine * bb.velocity.y - sine * bb.velocity.x
       
       # Now that velocities are rotated, you can use 1D
       # conservation of momentum equations to calculate 
@@ -144,22 +140,21 @@ def check_object_collisions
       # in the opposite direction
       # rotate balls
       bFinal = [Ball.new, Ball.new]
-      bFinal[0].x = cosine * bTemp[0].x - sine * bTemp[0].y
-      bFinal[0].y = cosine * bTemp[0].y + sine * bTemp[0].x
-      bFinal[1].x = cosine * bTemp[1].x - sine * bTemp[1].y
-      bFinal[1].y = cosine * bTemp[1].y + sine * bTemp[1].x
+      bFinal[0].position.x = cosine * bTemp[0].position.x - sine * bTemp[0].position.y
+      bFinal[0].position.y = cosine * bTemp[0].position.y + sine * bTemp[0].position.x
+      bFinal[1].position.x = cosine * bTemp[1].position.x - sine * bTemp[1].position.y
+      bFinal[1].position.y = cosine * bTemp[1].position.y + sine * bTemp[1].position.x
       
       # update balls to screen position
-      bb.x = ba.x + bFinal[1].x
-      bb.y = ba.y + bFinal[1].y
-      ba.x = ba.x + bFinal[0].x
-      ba.y = ba.y + bFinal[0].y
+      bb.position = ba.position + bFinal[1].position     
+      ba.position = ba.position + bFinal[0].position
+
       
       # update velocities
-      ba.vec.x = cosine * vFinal[0].x - sine * vFinal[0].y
-      ba.vec.y = cosine * vFinal[0].y + sine * vFinal[0].x
-      bb.vec.x = cosine * vFinal[1].x - sine * vFinal[1].y
-      bb.vec.y = cosine * vFinal[1].y + sine * vFinal[1].x
+      ba.velocity.x = cosine * vFinal[0].x - sine * vFinal[0].y
+      ba.velocity.y = cosine * vFinal[0].y + sine * vFinal[0].x
+      bb.velocity.x = cosine * vFinal[1].x - sine * vFinal[1].y
+      bb.velocity.y = cosine * vFinal[1].y + sine * vFinal[1].x
     end
   end
   
@@ -167,8 +162,8 @@ end
 
 # reverse ball velocity if at sketch boundary
 def check_boundary_collision(ball)  
-  ball.vec.x *= -1 unless (ball.r .. width - ball.r).include? ball.x 
-  ball.vec.y *= -1 unless (ball.r .. height - ball.r).include? ball.y 
+  ball.velocity.x *= -1 unless (ball.r .. width - ball.r).include? ball.position.x 
+  ball.velocity.y *= -1 unless (ball.r .. height - ball.r).include? ball.position.y 
 end
 
 

data/samples/processing_app/library/vecmath/{flocking.rb → vec2d/flocking.rb}

@@ -15,11 +15,8 @@ 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
+  # Add an initial set of boids into the system at the center
+  @flock = Flock.new(150, Vec2D.new(width / 2.0, height / 2.0))
 end
 
 def draw
@@ -29,5 +26,5 @@ end
 
 # Add a new boid into the System
 def mouse_pressed
-  flock << Boid.new(mouse_x, mouse_y)
+  flock << Boid.new(Vec2D.new(mouse_x, mouse_y))
 end

data/samples/processing_app/library/vecmath/{library → vec2d/library}/flock/flock.rb

@@ -1,24 +1,13 @@
 # The Flock (a list of Boid objects)
+require 'forwardable'
 
 class Flock 
-  extend Enumerable
+  extend Forwardable
+  def_delegators(:@boids, :each, :<<, :reject)
+  include Enumerable
   
-  attr_reader :boids
-  
-  def initialize
-    @boids = []	  
-  end
-
-  def each &block
-    boids.each &block	  
-  end
-  
-  def reject &block
-    boids &block
-  end
-
-  def << obj
-    boids << obj
+  def initialize(size, position)
+    @boids = (0 .. size).map{ Boid.new(position) }	  
   end
 
   def run
@@ -35,14 +24,16 @@ class Boid
   include Processing::Proxy
   import 'vecmath'
   attr_reader :location, :velocity, :acceleration, :r, :maxforce, :maxspeed
-  
-  def initialize(x, y)
+  attr_reader :width, :height
+  def initialize(loc)
     @acceleration = Vec2D.new
     @velocity = Vec2D.new(rand(-1.0 .. 1), rand(-1.0 .. 1))
-    @location = Vec2D.new(x, y)
+    @location = loc
     @r = 2.0
     @maxspeed = 2
     @maxforce = 0.03
+    @width = $app.width    
+    @height = $app.height
   end
   
   def run(boids)
@@ -58,7 +49,7 @@ class Boid
   end
   
   # We accumulate a new acceleration each time based on three rules
-  def flock boids
+  def flock(boids)
     sep = separate(boids)   # Separation
     ali = align(boids)      # Alignment
     coh = cohesion(boids)   # Cohesion
@@ -76,8 +67,8 @@ class Boid
   def update
     # Update velocity
     @velocity += acceleration
-    # Limit speed   
-    velocity.set_mag(maxspeed) {velocity.mag_squared > maxspeed**2}
+    # Limit speed
+    velocity.set_mag(maxspeed) { velocity.mag > maxspeed }
     @location += velocity
     # Reset accelertion to 0 each cycle
     @acceleration *= 0
@@ -93,86 +84,79 @@ class Boid
     # Steering = Desired minus Velocity
     steer = desired - velocity
     # Limit to maximum steering force
-    steer.set_mag(maxforce) {steer.mag_squared > maxforce**2}   
+    steer.set_mag(maxforce) { steer.mag > maxforce }   
     return steer
   end
 
   def render
     # Draw a triangle rotated in the direction of velocity
-    theta = velocity.heading + Math::PI/2.0
-    fill(200,100)
+    theta = velocity.heading + Math::PI/2
+    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)
+    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
+    location.x = width + r if location.x < -r
+    location.y = height + r if location.y < -r
+    location.x = -r if location.x > width + r
+    location.y = -r if location.y > height + r
   end
           
   # Separation
   # Method checks for nearby boids and steers away
-  def separate boids
+  def separate(boids)
     desiredseparation = 25.0
     steer = Vec2D.new
     count = 0
     # For every other bird in the system, check if it's too close
-    boids.reject{|bd| bd.equal? self}.each do |other|
-      d = Vec2D.dist(location, other.location)
+    boids.reject{ |bd| bd.equal? self }.each do |other|
+      d = location.dist(other.location)
       # If the distance is greater than 0 and less than an arbitrary amount 
-      if ((d > 0) && (d < desiredseparation))
+      if (0.0001 .. desiredseparation).include? d
         # Calculate vector pointing away from neighbor
         diff = location - other.location
         diff.normalize!
-        diff /= d        # Weight by distance
+        diff /= d             # Weight by distance
         steer += diff
         count += 1            # Keep track of how many
       end
     end
     # Average -- divide by how many
-    if (count > 0)
+    if count > 0
       steer /= count.to_f
     end
     
     # As long as the vector is greater than 0
-    if (steer.mag > 0)
+    if steer.mag > 0
       # Implement Reynolds: Steering = Desired - Velocity
       steer.normalize!
       steer *= maxspeed
       steer -= velocity      
-      steer.set_mag(maxforce){steer.mag_squared > maxforce**2} 
+      steer.set_mag(maxforce) { steer.mag > maxforce } 
     end
     return steer
   end
     
   # Alignment
   # For every other nearby boid in the system, calculate the average velocity
-  def align boids
+  def align(boids)
     neighbordist = 50
     sum = Vec2D.new
+    steer = Vec2D.new
     count = 0
-    boids.reject{|bd| bd.equal? self}.each do |other|
-      d = Vec2D.dist_squared(location, other.location)
-      if ((d > 0) && (d < neighbordist * neighbordist))
+    boids.reject{ |bd| bd.equal? self }.each do |other|
+      d = location.dist(other.location)
+      if (0 .. neighbordist).include? d
         sum += other.velocity
         count += 1
       end
@@ -182,30 +166,26 @@ class Boid
       sum.normalize!
       sum *= maxspeed
       steer = sum - velocity
-      steer.set_mag(maxforce){steer.mag_squared > maxforce**2} 
-      return steer
-    else
-      return Vec2D.new
+      steer.set_mag(maxforce) { steer.mag > maxforce }
     end
+    return steer
   end
     
   # Cohesion
-  # For the average location (i.e. center) of all other nearby boids, calculate steering vector towards that location
-  def cohesion boids
+  # For the average location (i.e. center) of all other nearby boids, calculate
+  # steering vector towards that location
+  def cohesion(boids)
     neighbordist = 50
     sum = Vec2D.new   # Start with empty vector to accumulate all locations
     count = 0
-    boids.reject{|bd| bd.equal? self}.each do |other|
-      d = Vec2D.dist_squared(location, other.location)
-      if ((d > 0) && (d < neighbordist * neighbordist))
+    boids.reject { |bd| bd.equal? self }.each do |other|
+      d = location.dist(other.location)
+      if (0.0001 .. neighbordist).include? d
         sum += other.location # Add location
         count += 1
       end
     end
-    sum /= count unless (count == 0)        # avoid div by zero
-    return (count > 0)? seek(sum) : Vec2D.new 
+    sum /= count unless count == 0        # avoid div by zero
+    (count > 0) ? seek(sum) : Vec2D.new 
   end
 end
-
-
-