ruby-processing 2.4.3 → 2.4.4

data/samples/processing_app/topics/shaders/landscape.rb

@@ -27,6 +27,6 @@ def draw
   shader(landscape) 
   rect(0, 0, width, height)
 
-  frame.set_title "frame: #{frame_count} - fps: #{frame_rate}"     
+  frame.set_title "frame: #{frame_count} - fps: #{format("%.2f", frame_rate)}"     
 end
 

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

@@ -8,7 +8,7 @@
 # 
 # Click the mouse to add a new boid.
 #
-load_library :flock
+load_libraries :flock, :vecmath
 
 attr_reader :flock
 

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

@@ -30,15 +30,20 @@ end
 class Boid
   include Processing::Proxy
   
-  attr_reader :location, :velocity, :acceleration, :r, :maxforce, :maxspeed
+  MAXSPEED = 2
+  MAXFORCE = 0.03
+  
+  attr_reader :width, :height
+  attr_reader :location, :velocity, :acceleration, :sz, :maxforce_squared, :maxspeed_squared
   
   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
+    @width, @height = $app.width, $app.height
+    @acceleration = Vec2D.new(0, 0)
+    @velocity = Vec2D.new(rand(-1.0 .. 1), rand(-1.0 .. 1))
+    @location = Vec2D.new(x, y)
+    @sz = 4.0
+    @maxspeed_squared = MAXSPEED * MAXSPEED
+    @maxforce_squared = MAXFORCE * MAXFORCE
   end
   
   def run(boids)
@@ -50,7 +55,7 @@ class Boid
   
   def apply_force(force)
     # We could add mass here if we want A = F / M
-    acceleration.add(force)
+    @acceleration += force
   end
   
   # We accumulate a new acceleration each time based on three rules
@@ -59,9 +64,9 @@ class Boid
     ali = align(boids)      # Alignment
     coh = cohesion(boids)   # Cohesion
     # Arbitrarily weight these forces
-    sep.mult(1.5)
-    ali.mult(1.0)
-    coh.mult(1.0)
+    sep *= 1.5
+    ali *= 1.0
+    coh *= 1.0
     # Add the force vectors to acceleration
     apply_force(sep)
     apply_force(ali)
@@ -71,25 +76,25 @@ class Boid
   # Method to update location
   def update
     # Update velocity
-    velocity.add(acceleration)
+    @velocity += acceleration
     # Limit speed
-    velocity.limit(maxspeed)
-    location.add(velocity)
+    velocity.set_mag(MAXSPEED) {velocity.mag_squared > maxspeed_squared}
+    @location += velocity
     # Reset accelertion to 0 each cycle
-    acceleration.mult(0)
+    @acceleration *= 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
+    desired = target - location  # A vector pointing from the location to the target
     # Normalize desired and scale to maximum speed
-    desired.normalize
-    desired.mult(maxspeed)
+    desired.normalize!
+    desired *= MAXSPEED
     # Steering = Desired minus Velocity
-    steer = PVector.sub(desired,velocity)
-    steer.limit(maxforce)  # Limit to maximum steering force
-    return steer
+    steer = desired - velocity
+    steer.set_mag(MAXFORCE) {steer.mag_squared > maxforce_squared} # Limit to maximum steering force
+    steer
   end
 
   def render
@@ -101,26 +106,26 @@ class Boid
     translate(location.x,location.y)
     rotate(theta)
     begin_shape(TRIANGLES)
-    vertex(0, -r*2)
-    vertex(-r, r*2)
-    vertex(r, r*2)
+    vertex(0, -sz)
+    vertex(-sz * 0.5, sz)
+    vertex(sz * 0.5, sz)
     end_shape
     pop_matrix
   end
 
   # Wraparound
   def borders
-    if (location.x < -r) 
-      location.x = $app.width+r
+    if (location.x < -sz * 0.5) 
+      location.x = width + sz * 0.5
     end
-    if (location.y < -r) 
-      location.y = $app.height+r
+    if (location.y < -sz * 0.5)
+      location.y = height + sz * 0.5
     end
-    if (location.x > $app.width+r)
-      location.x = -r
+    if (location.x >  width + sz * 0.5)
+      location.x = -sz
     end
-    if (location.y > $app.height+r)
-      location.y = -r
+    if (location.y > height + sz * 0.5)
+      location.y = -sz * 0.5
     end
   end
           
@@ -128,33 +133,33 @@ class Boid
   # Method checks for nearby boids and steers away
   def separate boids
     desiredseparation = 25.0
-    steer = PVector.new(0, 0, 0)
+    steer = Vec2D.new
     count = 0
     # For every boid in the system, check if it's too close
     boids.each do |other|
-      d = PVector.dist(location, other.location)
+      d = Vec2D.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)
+        diff = location - other.location
+        diff.normalize!
+        diff /= d             # Weight by distance
+        steer += diff
         count += 1            # Keep track of how many
       end
     end
     # Average -- divide by how many
     if (count > 0)
-      steer.div(count.to_f)
+      steer /= 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)
+      steer.normalize!
+      steer *= MAXSPEED
+      steer -= velocity
+      steer.set_mag(MAXFORCE) {steer.mag_squared > maxforce_squared}
     end
     return steer
   end
@@ -163,24 +168,24 @@ class Boid
   # For every nearby boid in the system, calculate the average velocity
   def align boids
     neighbordist = 50
-    sum = PVector.new(0, 0)
+    sum = Vec2D.new(0, 0)
     count = 0
     boids.each do |other|
-      d = PVector.dist(location, other.location)
+      d = Vec2D.dist(location, other.location)
       if ((d > 0) && (d < neighbordist))
-        sum.add(other.velocity)
+        sum += 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)
+      sum /= (count.to_f)
+      sum.normalize!
+      sum *= MAXSPEED
+      steer = sum - velocity
+      steer.set_mag(MAXFORCE) {steer.mag_squared > maxforce_squared}
       return steer
     else
-      return PVector.new(0,0)
+      return Vec2D.new
     end
   end
     
@@ -188,17 +193,17 @@ class Boid
   # 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
+    sum = Vec2D.new   # Start with empty vector to accumulate all locations
     count = 0
     boids.each do |other|
-      d = PVector.dist(location, other.location)
+      d = Vec2D.dist(location, other.location)
       if ((d > 0) && (d < neighbordist))
-        sum.add(other.location) # Add location
+        sum += 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) 
+    sum /= count unless (count == 0)        # avoid div by zero
+    return (count > 0)? seek(sum) : Vec2D.new 
   end
 end
 

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

@@ -5,6 +5,8 @@
 # Each burst is one instance of a particle system with Particles and
 # CrazyParticles (a subclass of Particle).
 
+load_library :vecmath
+
 module Runnable
   def run
     self.reject! { |item| item.dead? }
@@ -12,28 +14,6 @@ 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 
   extend Enumerable
@@ -70,7 +50,7 @@ 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))
+  @particle_systems = ParticleSystem.new(rand(21) + 5, Vec2D.new(width/2, height/2))
 end
 
 def draw
@@ -80,7 +60,7 @@ end
 
 def mouse_pressed
   origin = rand(21) + 5
-  vector = Vector.new(mouse_x, mouse_y)
+  vector = Vec2D.new(mouse_x, mouse_y)
   @particle_systems << ParticleSystem.new(origin, vector)
 end
 
@@ -88,8 +68,8 @@ end
 class Particle
   def initialize(origin)
     @origin = origin
-    @velocity = Vector.new(rand(-1.0 .. 1), rand(-2.0 .. 0))
-    @acceleration = Vector.new(0, 0.05)
+    @velocity = Vec2D.new(rand(-1.0 .. 1), rand(-2.0 .. 0))
+    @acceleration = Vec2D.new(0, 0.05)
     @radius = 10
     @lifespan = 100
   end
@@ -129,7 +109,7 @@ class Particle
     translate(@origin.x, @origin.y)
     rotate(@velocity.heading)
     
-    length = @velocity.magnitude * scale
+    length = @velocity.mag * scale
     
     line 0, 0, length, 0
     line length, 0, length - arrow_size, arrow_size / 2
@@ -155,7 +135,7 @@ class CrazyParticle < Particle
   
   def update
     super
-    @theta += @velocity.x * @velocity.magnitude / 10
+    @theta += @velocity.x * @velocity.mag / 10
   end
   
   def grow

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

@@ -4,11 +4,13 @@
 # time. A ParticleSystem (Array) object manages a variable size list of
 # particles.
 
+load_library :vecmath
+
 attr_reader :ps
 
 def setup
   size(640,360)
-  @ps = ParticleSystem.new(PVector.new(width/2, 50))
+  @ps = ParticleSystem.new(Vec2D.new(width/2, 50))
 end
 
 def draw
@@ -32,7 +34,7 @@ class ParticleSystem
 
   def initialize(loc)
     @particle_system = []
-    @origin = loc.get
+    @origin = loc.dup
   end
   
   def each &block
@@ -60,9 +62,9 @@ class Particle
   
   attr_reader :loc, :vel, :acc, :lifespan
   def initialize(l) 
-    @acc = PVector.new(0, 0.05)
-    @vel = PVector.new(rand(-1.0 .. 1), rand(-2.0 .. 0))
-    @loc = l.get
+    @acc = Vec2D.new(0, 0.05)
+    @vel = Vec2D.new(rand(-1.0 .. 1), rand(-2.0 .. 0))
+    @loc = l.dup
     @lifespan = 255.0
   end
 
@@ -73,8 +75,8 @@ class Particle
 
   # Method to update loc
   def update
-    vel.add(acc)
-    loc.add(vel)
+    @vel += acc
+    @loc += vel
     @lifespan -= 1.0
   end
 

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

@@ -3,20 +3,21 @@
 #
 # A ParticleSystem (Array) object manages a variable size list of
 # particles.
+load_library :vecmath
 
 attr_reader :ps, :img, :wind
 
 def setup
   size(640,360)
   @img = load_image("texture.png")
-  @ps = ParticleSystem.new(0, PVector.new(width/2, height - 60), img)
+  @ps = ParticleSystem.new(0, Vec2D.new(width/2, height - 60), img)
 end
 
 def draw
   background(0)  
   # Calculate a "wind" force based on mouse horizontal position
   dx = map(mouse_x, 0, width, -0.2, 0.2)
-  @wind = PVector.new(dx, 0)
+  @wind = Vec2D.new(dx, 0)
   ps.apply_force(wind)
   ps.run
   2.times do
@@ -24,7 +25,7 @@ def draw
   end
   
   # Draw a horizontal arrow representing the wind force
-  draw_vector(wind, PVector.new(width / 2, 50, 0), 500)
+  draw_vector(wind, Vec2D.new(width / 2, 50, 0), 500)
   
 end
 
@@ -33,7 +34,7 @@ def draw_vector(v, loc, scayl)
   push_matrix
   # Translate to location to render vector
   translate(loc.x, loc.y)  
-  rotate(v.heading2D)
+  rotate(v.heading)
   # Calculate length of vector & scale as necessary
   len = v.mag * scayl
   # Draw three lines to make an arrow 
@@ -63,7 +64,7 @@ class ParticleSystem
   
   def initialize(num, location, image)
     @particles = []
-    @origin = location.get
+    @origin = location.dup
     @image = image    
     (0 ... num).each do
       particles << Particle.new(origin, image)
@@ -98,11 +99,11 @@ class Particle
   attr_reader :loc, :acc, :vel, :lifespan, :img, :generator
   
   def initialize(l, img_) 
-    @acc = PVector.new(0, 0)
+    @acc = Vec2D.new(0, 0)
     vx = random_gaussian * 0.3
     vy = random_gaussian * 0.3 - 1.0
-    @vel = PVector.new(vx, vy)
-    @loc = l.get()
+    @vel = Vec2D.new(vx, vy)
+    @loc = l.dup()
     @lifespan = 100.0
     @img = img_
   end
@@ -114,8 +115,8 @@ class Particle
   
   # Method to update location
   def update
-    vel.add(acc)
-    loc.add(vel)
+    @vel += acc
+    @loc += vel
     @lifespan -= 1.0
   end
   
@@ -128,7 +129,7 @@ class Particle
   
   # Method to add a force vector to all particles currently in the system
   def apply_force(f) 
-    @acc.add(f)
+    @acc += f
   end
   
 end