ruby-processing 2.4.3 → 2.4.4

data/samples/processing_app/basics/transform/birds.rb

@@ -5,34 +5,28 @@
 # pushMatrix() / popMatrix() functions. 
 # Trigonometry functions handle the flapping and sinuous movement.
 
-load_library 'bird' 
+load_library :bird 
 
 BIRD_COUNT = 200
 
-def setup
-  
+def setup  
   size 640, 360, P3D
   no_stroke
   lights
-  @birds = []
-  
-  0.upto(BIRD_COUNT) { |i|
-    
+  @birds = []  
+  0.upto(BIRD_COUNT) do |i|    
     bird = Bird.new rand(-300 .. 300), rand(-300 .. 300), rand(-2500 .. -500), rand(5 .. 30), rand(5 .. 30)    
     bird.set_flight rand(20 .. 340), rand(30 .. 350), rand( 1000 .. 4800 ),
     rand(-160 .. 160), rand(-55 .. 55), rand(-20 .. 20)    
     bird.set_wing_speed rand(0.1 .. 3.75)
     bird.set_rot_speed rand(0.025 .. 0.15)    
     @birds << bird
-  }
-  
+  end  
 end
 
 def draw  
   background 0  
   translate width/2, height/2, -700  
-  @birds.each do |b| 
-    b.fly 
-  end  
+  @birds.each {|b| b.fly} 
 end
 

data/samples/processing_app/basics/transform/cubes_in_cube.rb

@@ -2,11 +2,12 @@
 # by Ira Greenberg.  
 # 
 # Collision detection against all outer cube's surfaces. 
-# Uses the PVector and Cube classes.
+# Uses the Vec3D and Cube classes.
 
 # fjenett, 2010-03-12: did some cleanups and rubyfication here
+# Martin Prout went a bit further on 2014-03-26
 
-load_library 'cube'
+load_libraries :vecmath, :cube
 
 
 def setup
@@ -18,18 +19,14 @@ def setup
   @cube_count = 20
   @cubes = []
   
-  0.upto( @cube_count ) { |i|
-    
-    cube_size = rand(5 .. 15)
-    
-    c = Cube.new(cube_size, cube_size, cube_size)
-    
-    c.position = PVector.new(0.0, 0.0, 0.0)
-    c.speed    = PVector.new(rand(-1 .. 1), rand(-1 .. 1), rand(-1 .. 1)) 
-    c.rotation = PVector.new(rand(40 .. 100), rand(40 .. 100), rand(40 .. 100)) 
-    
+  0.upto( @cube_count ) do |i|    
+    cube_size = rand(5 .. 15)    
+    c = Cube.new(cube_size)    
+    c.position = Vec3D.new(0.0, 0.0, 0.0)
+    c.speed    = Vec3D.new(rand(-1.0 .. 1), rand(-1.0 .. 1), rand(-1.0 .. 1)) 
+    c.rotation = Vec3D.new(rand(40 .. 100), rand(40 .. 100), rand(40 .. 100))    
     @cubes << c
-  }
+  end
   
   @cube_colors = [
   color(0), color(51), color(102), color(153), color(204), color(255)
@@ -37,7 +34,7 @@ def setup
   @cube_colors.reverse
   
   @stage_size = 300
-  @stage = Cube.new @stage_size, @stage_size, @stage_size
+  @stage = Cube.new @stage_size
   
 end
 
@@ -56,7 +53,7 @@ def draw
   
   @stage.draw
   
-  @cubes.each_with_index { |c, i|
+  @cubes.each_with_index do |c, i|
   	
     # draw cube
     push_matrix
@@ -75,25 +72,31 @@ def draw
     pop_matrix
     
     # move it
-		c.position.add c.speed
+		c.position += c.speed
 		
 		# draw lines
 		if i > 0
 		  
 			stroke 0
-			c2 = @cubes[i-1]
+			c2 = @cubes[i - 1]
 			line c.position.x,  c.position.y,  c.position.z,
 			c2.position.x, c2.position.y, c2.position.z
 			
 		end
 		
 		# collision
-		s2 = @stage_size / 2
-		c.speed.x *= -1 if (c.position.x / s2).abs > 1  # note that in Ruby abs(-12) is -12.abs
-		c.speed.y *= -1 if (c.position.y / s2).abs > 1
-		c.speed.z *= -1 if (c.position.z / s2).abs > 1
-	}
+		boundary = Boundary.new(-@stage_size / 2, @stage_size / 2)
+		c.speed.x *= -1 unless boundary.include? c.position.x 
+		c.speed.y *= -1 unless boundary.include? c.position.y
+		c.speed.z *= -1 unless boundary.include? c.position.z
+	end
 	
 end
+  
+Boundary = Struct.new(:lower, :upper) do
+  def include? x
+    (lower ... upper).cover? x
+  end
+end
 
 

data/samples/processing_app/basics/transform/library/cube/cube.rb

@@ -4,25 +4,25 @@ class Cube
 	
 	attr_accessor :vertices
 	attr_accessor :w, :h, :d
-	attr_accessor :position, :speed, :rotation # PVector
+	attr_accessor :position, :speed, :rotation # Vec3D
 	
-	def initialize (w, h, d)
+	def initialize (dim)
 	
-		@w, @h, @d = w, h, d
+		@w, @h, @d = dim, dim, dim
 		
-		w2 = @w/2
-		h2 = @h/2
-		d2 = @d/2
+		w2 = @w / 2
+		h2 = @h / 2
+		d2 = @d / 2
 		
-		tfl = PVector.new(-w2, h2, d2) 	# four points making the top quad:
-		tfr = PVector.new(w2, h2, d2)  	# "tfl" is "top front left", etc
-		tbr = PVector.new(w2, h2,-d2)  
-		tbl = PVector.new(-w2, h2,-d2) 
+		tfl = Vec3D.new(-w2, h2, d2) 	# four points making the top quad:
+		tfr = Vec3D.new(w2, h2, d2)  	# "tfl" is "top front left", etc
+		tbr = Vec3D.new(w2, h2,-d2)  
+		tbl = Vec3D.new(-w2, h2,-d2) 
 		
-		bfl = PVector.new(-w2,-h2, d2) 	# bottom quad points
-		bfr = PVector.new(w2,-h2, d2)  
-		bbr = PVector.new(w2,-h2,-d2)  
-		bbl = PVector.new(-w2,-h2,-d2) 
+		bfl = Vec3D.new(-w2,-h2, d2) 	# bottom quad points
+		bfr = Vec3D.new(w2,-h2, d2)  
+		bbr = Vec3D.new(w2,-h2,-d2)  
+		bbl = Vec3D.new(-w2,-h2,-d2) 
 		
 		@vertices = [
 			[tfl, tfr, tbr, tbl],		# top
@@ -42,9 +42,9 @@ class Cube
 			
 			fill side_colors[i] if side_colors && i < side_colors.length
 		
-			quad.each { |pvec|
+			quad.each { |vec|
 				
-				vertex pvec.x, pvec.y, pvec.z
+				vertex vec.x, vec.y, vec.z
 			}
 							
 			end_shape

data/samples/processing_app/basics/transform/rotate_push_pop.rb

@@ -12,7 +12,7 @@ attr_reader :offset, :a, :num
 def setup
   size(640, 360, P3D)
   no_stroke 
-  @offset = PI/24.0
+  @offset = PI / 24.0
   @num = 12
   @a  = 0
 end 

data/samples/processing_app/demos/graphics/bezier_patch.rb

@@ -70,17 +70,9 @@ end
 def build_geometry
   @outp = []
   @normp = []
-  @inp = []
-  uitang = PVector.new
-  ujtang = PVector.new
-  
-  (0 ... NI).each do |i|
-    row = Array.new  
-    (0 ... NJ).each do |j|
-      row << PVector.new(i, j, rand(-3.0 .. 3.0))  
-    end
-    inp << row
-  end
+  @inp = Array.new(NI){|i| Array.new(NJ){|j| Vec3D.new(i, j, rand(-3.0 .. 3))}}
+  uitang = Vec3D.new
+  ujtang = Vec3D.new  
   
   (0 ... RESI).each do |i|
     mui = i.fdiv(RESI - 1)
@@ -88,34 +80,29 @@ def build_geometry
     row_n = []
     (0 ... RESJ).each do |j|
       muj = j.fdiv(RESJ - 1)
-      vect = PVector.new
-      uitang.set(0, 0, 0)
-      ujtang.set(0, 0, 0)
+      vect = Vec3D.new
+      uitang.x, uitang.y, uitang.z = 0, 0, 0
+      ujtang.x, ujtang.y, ujtang.z = 0, 0, 0
       (0 ... NI).each do |ki|
         bi = bezier_blend(ki, mui, NI)
         dbi = d_bezier_blend(ki, mui, NI)
         (0 ... NJ).each do |kj|
           bj = bezier_blend(kj, muj, NJ)
           dbj = d_bezier_blend(kj, muj, NJ)
-          vect.x += (inp[ki][kj].x * bi * bj)
-          vect.y += (inp[ki][kj].y * bi * bj)
-          vect.z += (inp[ki][kj].z * bi * bj)
-           
-          uitang.x += (inp[ki][kj].x * dbi * bj)
-          uitang.y += (inp[ki][kj].y * dbi * bj)
-          uitang.z += (inp[ki][kj].z * dbi * bj)
-           
-          ujtang.x += (inp[ki][kj].x * bi * dbj)
-          ujtang.y += (inp[ki][kj].y * bi * dbj)
-          ujtang.z += (inp[ki][kj].z * bi * dbj)
+
+          vect += inp[ki][kj] * bi * bj        
+
+          uitang += inp[ki][kj] * dbi * bj
+
+          ujtang += inp[ki][kj] * bi * dbj
         end
       end
-      vect.add(PVector.new(-NI/2,-NJ/2,0))
-      vect.mult(100)
-      row << vect.array()       
-      uitang.normalize
-      ujtang.normalize
-      row_n << uitang.cross(ujtang).array()     
+      vect += Vec3D.new(-NI / 2, -NJ / 2, 0)
+      vect *= 100
+      row << vect.to_a       
+      uitang.normalize!
+      ujtang.normalize!
+      row_n << uitang.cross(ujtang).to_a    
     end
     @outp << row
     @normp << row_n

data/samples/processing_app/demos/graphics/trefoil.rb

@@ -2,6 +2,8 @@
 # A parametric surface is textured procedurally
 # by drawing on an offscreen PGraphics surface.
 
+load_library :vecmath
+
 attr_reader :pg, :trefoil
 
 def setup
@@ -43,7 +45,7 @@ end
 # Code to draw a trefoil knot surface, with normals and texture 
 # coordinates.
 # Adapted from the parametric equations example by Philip Rideout:
-# http:#iphone-3d-programming.labs.oreilly.com/ch03.html
+# http://iphone-3d-programming.labs.oreilly.com/ch03.html
 
 # This function draws a trefoil knot surface as a triangle mesh derived
 # from its parametric equation.
@@ -100,12 +102,11 @@ def eval_normal(u, v)
   p = eval_point(u, v)
   tangU = eval_point(u + 0.01, v)
   tangV = eval_point(u, v + 0.01)
-  tangU.sub(p)
-  tangV.sub(p)
+  tangU -= p
+  tangV -= p
   
-  normUV = tangV.cross(tangU)
-  normUV.normalize
-  return normUV
+  normUV = tangV.cross(tangU)  
+  return normUV.normalize!
 end
 
 # Evaluates the surface point corresponding to normalized 
@@ -115,26 +116,25 @@ def eval_point(u, v)
   b = 0.3
   c = 0.5
   d = 0.1
-  s = TWO_PI * u
-  t = (TWO_PI * (1 - v)) * 2  
+  s = TAU * u
+  t = (TAU * (1 - v)) * 2  
         
   r = a + b * cos(1.5 * t)
   x = r * cos(t)
   y = r * sin(t)
   z = c * sin(1.5 * t)
         
-  dv = PVector.new
+  dv = Vec3D.new
   dv.x = -1.5 * b * sin(1.5 * t) * cos(t) - (a + b * cos(1.5 * t)) * sin(t)
   dv.y = -1.5 * b * sin(1.5 * t) * sin(t) + (a + b * cos(1.5 * t)) * cos(t)
   dv.z = 1.5 * c * cos(1.5 * t)
         
-  q = dv      
-  q.normalize
-  qvn = PVector.new(q.y, -q.x, 0)
-  qvn.normalize
-  ww = q.cross(qvn)
+  dv.normalize!                  
+  qvn = Vec3D.new(dv.y, -dv.x, 0)
+  qvn.normalize!           
+  ww = dv.cross(qvn)
         
-  pt = PVector.new
+  pt = Vec3D.new
   pt.x = x + d * (qvn.x * cos(s) + ww.x * sin(s))
   pt.y = y + d * (qvn.y * cos(s) + ww.y * sin(s))
   pt.z = z + d * ww.z * sin(s)

data/samples/processing_app/library/vecmath/acceleration_with_vectors.rb

@@ -57,9 +57,9 @@ class Mover
     # Velocity changes according to acceleration vector
     @velocity += acceleration
     # Limit the velocity to topspeed, PVector has a limit function 
-    if velocity.mag_squared > topspeed**2
-      velocity.set_mag topspeed
-    end
+    # here we supply a block that evaluates to a boolean to set
+    # the velocit conditionally
+    velocity.set_mag topspeed {velocity.mag_squared > topspeed**2}
     # Location changes by velocity vector
     @location += velocity
   end

data/samples/processing_app/library/vecmath/hilbert_fractal.rb

@@ -7,13 +7,13 @@
 ########################################################
 
 load_libraries :hilbert, :vecmath
-import 'vecmath'
+
 attr_reader :hilbert, :arcball
 
 def setup
   size 1024, 768, P3D
   @arcball = ArcBall.new(width/2.0, height/2.0, min(width - 20, height - 20) * 0.5)
-  @hilbert = Hilbert.new(height/2, 3)
+  @hilbert = Hilbert.new(size: height/2, gen: 3)
   no_stroke
 end
 

data/samples/processing_app/library/vecmath/library/flock/flock.rb

@@ -13,6 +13,10 @@ class Flock
     boids.each &block	  
   end
   
+  def reject &block
+    boids &block
+  end
+
   def << obj
     boids << obj
   end
@@ -72,10 +76,8 @@ class Boid
   def update
     # Update velocity
     @velocity += acceleration
-    # Limit speed
-    if velocity.mag_squared > maxspeed**2
-      velocity.set_mag(maxspeed)
-    end
+    # Limit speed   
+    velocity.set_mag(maxspeed) {velocity.mag_squared > maxspeed**2}
     @location += velocity
     # Reset accelertion to 0 each cycle
     @acceleration *= 0
@@ -90,9 +92,8 @@ class Boid
     desired *= maxspeed
     # Steering = Desired minus Velocity
     steer = desired - velocity
-    if steer.mag_squared > maxforce**2 # Limit to maximum steering force
-      steer.set_mag(maxforce)
-    end  
+    # Limit to maximum steering force
+    steer.set_mag(maxforce) {steer.mag_squared > maxforce**2}   
     return steer
   end
 
@@ -134,10 +135,10 @@ class Boid
     desiredseparation = 25.0
     steer = Vec2D.new
     count = 0
-    # For every boid in the system, check if it's too close
-    boids.each do |other|
+    # 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)
-      # If the distance is greater than 0 and less than an arbitrary amount (0 when you are yourself)
+      # If the distance is greater than 0 and less than an arbitrary amount 
       if ((d > 0) && (d < desiredseparation))
         # Calculate vector pointing away from neighbor
         diff = location - other.location
@@ -157,21 +158,19 @@ class Boid
       # Implement Reynolds: Steering = Desired - Velocity
       steer.normalize!
       steer *= maxspeed
-      steer -= velocity
-      if steer.mag_squared > maxforce**2
-        steer.set_mag(maxforce)
-      end
+      steer -= velocity      
+      steer.set_mag(maxforce){steer.mag_squared > maxforce**2} 
     end
     return steer
   end
     
   # Alignment
-  # For every nearby boid in the system, calculate the average velocity
+  # For every other nearby boid in the system, calculate the average velocity
   def align boids
     neighbordist = 50
     sum = Vec2D.new
     count = 0
-    boids.each do |other|
+    boids.reject{|bd| bd.equal? self}.each do |other|
       d = Vec2D.dist_squared(location, other.location)
       if ((d > 0) && (d < neighbordist * neighbordist))
         sum += other.velocity
@@ -183,9 +182,7 @@ class Boid
       sum.normalize!
       sum *= maxspeed
       steer = sum - velocity
-      if steer.mag_squared > maxforce**2
-        steer.set_mag(maxforce)
-      end
+      steer.set_mag(maxforce){steer.mag_squared > maxforce**2} 
       return steer
     else
       return Vec2D.new
@@ -193,12 +190,12 @@ class Boid
   end
     
   # Cohesion
-  # For the average location (i.e. center) of all nearby boids, calculate steering vector towards that location
+  # 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.each do |other|
+    boids.reject{|bd| bd.equal? self}.each do |other|
       d = Vec2D.dist_squared(location, other.location)
       if ((d > 0) && (d < neighbordist * neighbordist))
         sum += other.location # Add location