ruby-processing 1.0.11 → 2.4.1

data/samples/contributed/circle_collision.rb

@@ -1,200 +1,193 @@
 # Based on http://processing.org/learning/topics/circlecollision.html
 # by Joe Holt
 
-class Sketch < Processing::App
-  
-  # 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
-      @m = r * 0.1
-      @vec = vec
-    end
-    
-    def move
-      @x += @vec.x
-      @y += @vec.y
-    end
+
+
+# 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, :px, :py
+  def initialize(r = 0.0, vec = nil, x = 0.0, y = 0.0)
+    @x, @y, @r = x, y, r
+    @m = r * 0.1
+    @vec = vec
+  end
   
-    def draw
-      r = @r * 2
-      ellipse @x, @y, r, r
-      @px, @py = @x, @y
-    end
+  def move
+    @x += vec.x
+    @y += vec.y
+  end
   
-    def erase
-      r = @r * 2
-      rect @px, @py, r, r
-    end
+  def draw
+    d = r * 2
+    ellipse x, y, d, d
+    @px, @py = x, y
   end
   
-
-  def setup
-    smooth
-    no_stroke
-    frame_rate 30
-    rect_mode RADIUS
-
-    @balls = []
-    5.times { @balls << Ball.new(10, PVector.new(2.15, -1.35), *empty_space(15)) }
-    2.times { @balls << Ball.new(40, PVector.new(-1.65, 0.42), *empty_space(45)) }
-
-    @frame_time = nil
-    @frame_count = 0
+  def erase
+    d = r * 2
+    rect px, py, d, d
   end
+end
 
 
-  def draw
-    t = Time.now
-    fps = 1.0 / (t - @frame_time) if @frame_time
-    @frame_time = t
-    @frame_count += 1
-
-    # erase previous screen
-    if @frame_count == 1
-      background 51
-    else
-      fill 51
-      @balls.each { |ball| ball.erase }
-    end
-
-    # move the balls 
-    fill 240
-    @balls.each do |ball|
-      ball.move
-      ball.draw
-      check_boundary_collision ball
-    end
-    check_object_collisions
-  end
+def setup
+  size 400, 400
+  no_stroke
+  frame_rate 30
+  rect_mode RADIUS    
+  @balls = []
+  5.times { @balls << Ball.new(10, PVector.new(2.15, -1.35), *empty_space(15)) }
+  2.times { @balls << Ball.new(40, PVector.new(-1.65, 0.42), *empty_space(45)) }    
+  @frame_time = nil
+  @frame_count = 0
+end
 
 
-  def empty_space(r)
-    x = y = nil
-    while !x || !empty_space?(x, y, r) do
-      x = rand(width)
-      y = rand(height)
-    end
-    return x, y
+def draw
+  t = Time.now
+  fps = 1.0 / (t - @frame_time) if @frame_time
+  @frame_time = t
+  @frame_count += 1
+  
+  # erase previous screen
+  if @frame_count == 1
+    background 51
+  else
+    fill 51
+    @balls.each { |ball| ball.erase }
   end
+  
+  # move the balls 
+  fill 240
+  @balls.each do |ball|
+    ball.move
+    ball.draw
+    check_boundary_collision ball
+  end
+  check_object_collisions
+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
-    end
-    return true
+def empty_space(r)
+  x = y = nil
+  while !x || !empty_space?(x, y, r) do
+    x = rand(width)
+    y = rand(height)
   end
+  return x, y
+end
 
 
-  def check_object_collisions
+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
+  end
+  return true
+end
 
-    (0...(@balls.length)).each do |ia|
-      ((ia+1)...(@balls.length)).each do |ib|
 
-        ba = @balls[ia]
-        bb = @balls[ib]
+def check_object_collisions
   
-        # get distances between the balls components
-        bVect = PVector.new
-        bVect.x = bb.x - ba.x
-        bVect.y = bb.y - ba.y
-
-        # calculate magnitude of the vector separating the balls
-        bVectMag = sqrt(bVect.x * bVect.x + bVect.y * bVect.y)
-        next if bVectMag >= ba.r + bb.r
-        # get angle of bVect
-        theta  = atan2(bVect.y, bVect.x)
-        # precalculate trig values
-        sine = sin(theta)
-        cosine = cos(theta)
-
-        # bTemp will hold rotated ball positions. You just
-        # need to worry about bTemp[1] position
-        bTemp = [Ball.new, Ball.new]
-        # bb's position is relative to ba's
-        # so you can use the vector between them (bVect) as the 
-        # reference point in the rotation expressions.
-        # 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
-
-        # rotate Temporary velocities
-        vTemp = [PVector.new, PVector.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
-
-        # Now that velocities are rotated, you can use 1D
-        # conservation of momentum equations to calculate 
-        # the final velocity along the x-axis.
-        vFinal = [PVector.new, PVector.new]
-        # final rotated velocity for ba
-        vFinal[0].x = ((ba.m - bb.m) * vTemp[0].x + 2 * bb.m * 
-          vTemp[1].x) / (ba.m + bb.m)
-        vFinal[0].y = vTemp[0].y
-        # final rotated velocity for ba
-        vFinal[1].x = ((bb.m - ba.m) * vTemp[1].x + 2 * ba.m * 
-          vTemp[0].x) / (ba.m + bb.m)
-        vFinal[1].y = vTemp[1].y
-
-        # hack to avoid clumping
-        bTemp[0].x += vFinal[0].x
-        bTemp[1].x += vFinal[1].x
-
-        # Rotate ball positions and velocities back
-        # Reverse signs in trig expressions to rotate 
-        # 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
-
-        # 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
-
-        # 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
-      end
+  (0...(@balls.length)).each do |ia|
+    ((ia+1)...(@balls.length)).each do |ib|
+      
+      ba = @balls[ia]
+      bb = @balls[ib]
+      
+      # get distances between the balls components
+      bVect = PVector.new
+      bVect.x = bb.x - ba.x
+      bVect.y = bb.y - ba.y
+      
+      # calculate magnitude of the vector separating the balls
+      bVectMag = sqrt(bVect.x * bVect.x + bVect.y * bVect.y)
+      next if bVectMag >= ba.r + bb.r
+      # get angle of bVect
+      theta  = atan2(bVect.y, bVect.x)
+      # precalculate trig values
+      sine = sin(theta)
+      cosine = cos(theta)
+      
+      # bTemp will hold rotated ball positions. You just
+      # need to worry about bTemp[1] position
+      bTemp = [Ball.new, Ball.new]
+      # bb's position is relative to ba's
+      # so you can use the vector between them (bVect) as the 
+      # reference point in the rotation expressions.
+      # 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
+      
+      # rotate Temporary velocities
+      vTemp = [PVector.new, PVector.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
+      
+      # Now that velocities are rotated, you can use 1D
+      # conservation of momentum equations to calculate 
+      # the final velocity along the x-axis.
+      vFinal = [PVector.new, PVector.new]
+      # final rotated velocity for ba
+      vFinal[0].x = ((ba.m - bb.m) * vTemp[0].x + 2 * bb.m * vTemp[1].x) / (ba.m + bb.m)
+      vFinal[0].y = vTemp[0].y
+      # final rotated velocity for ba
+      vFinal[1].x = ((bb.m - ba.m) * vTemp[1].x + 2 * ba.m * vTemp[0].x) / (ba.m + bb.m)
+      vFinal[1].y = vTemp[1].y
+      
+      # hack to avoid clumping
+      bTemp[0].x += vFinal[0].x
+      bTemp[1].x += vFinal[1].x
+      
+      # Rotate ball positions and velocities back
+      # Reverse signs in trig expressions to rotate 
+      # 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
+      
+      # 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
+      
+      # 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
     end
-
   end
+  
+end
 
 
-  def check_boundary_collision(ball)
-    if ball.x > width-ball.r
-      ball.x = width-ball.r
-      ball.vec.x *= -1
-    elsif ball.x < ball.r
-      ball.x = ball.r
-      ball.vec.x *= -1
-    end
-    if ball.y > height-ball.r
-      ball.y = height-ball.r
-      ball.vec.y *= -1
-    elsif ball.y < ball.r
-      ball.y = ball.r
-      ball.vec.y *= -1
-    end
+def check_boundary_collision(ball)
+  if ball.x > width-ball.r
+    ball.x = width-ball.r
+    ball.vec.x *= -1
+  elsif ball.x < ball.r
+    ball.x = ball.r
+    ball.vec.x *= -1
+  end
+  if ball.y > height-ball.r
+    ball.y = height-ball.r
+    ball.vec.y *= -1
+  elsif ball.y < ball.r
+    ball.y = ball.r
+    ball.vec.y *= -1
   end
-
 end
 
 
-Sketch.new(:width => 400, :height => 400, :title => "CircleCollision2")

data/samples/contributed/drawolver.rb

@@ -1,182 +1,131 @@
 # Drawolver: draw 2D & revolve 3D
 
-# Example to show how to extend Ruby classes in a usefull way and how to
-# use PVector.
+# Example to show how to extend Ruby classes in a useful way and how to
+# use PVector and the Array is extended to yield one_of_each 
+# pair of pts. See the drawolver library. Also features the use each_cons, 
+# possibly a rare use for this ruby Enumerable method?
+# 2010-03-22 - fjenett (last revised by monkstone 2013-09-13)
 
-# 2010-03-22 - fjenett
+attr_reader :drawing_mode, :points, :rot_x, :rot_y, :vertices
 
-class Drawvolver < Processing::App
+module ExtendedArray
+  # send one item from each array, expects array to be 2D:
+  # array [[1,2,3], [a,b,c]] sends
+  # [1,a] , [2,b] , [3,c]
+  def one_of_each( &block )
+    i = 0
+    one = self[0]
+    two = self[1]
+    mi = one.length > two.length ? two.length : one.length
+    while i < mi do
+      yield( one[i], two[i] )
+      i += 1
+    end
+  end
+end
 
-	load_library :opengl
 
-  def setup
-    
-    size 640, 360, (library_loaded?(:opengl) ? OPENGL : P3D)
-    frame_rate 30
-    
-    reset_scene
-  end
-  
-  def draw
-  
-  	background 255
-  	
-  	if ( !@drawing_mode )
-	
-		translate width/2, height/2
-		rotate_x @rot_x
-		rotate_y @rot_y
-		@rot_x += 0.01
-		@rot_y += 0.02
-		translate( -width/2, -height/2 )
-	end
-  	
-	no_fill
-	stroke 0
-	
-	@points.each_pair { |ps, pe|
-	
-		line ps.x, ps.y, pe.x, pe.y
-	}
-	
-	if ( !@drawing_mode )
-		
-		no_stroke
-		fill 120
-		lights
-			
-		@vertices.each_pair { |r1, r2|
-		
-			begin_shape TRIANGLE_STRIP
-				
-				[r1,r2].one_of_each { |v1, v2|
-					
-					vertex v1.x, v1.y, v1.z
-					vertex v2.x, v2.y, v2.z
-				}
-			end_shape
-		}
-	end
-	
-  end
-  
-  def reset_scene
-  
-  	@drawing_mode = true
-  	@points = []
-    @rot_x = 0.0
-    @rot_y = 0.0
-  end
-  
-  def mouse_pressed
-    reset_scene
-    @points.push RPVector.new( mouse_x, mouse_y )
-  end
-  
-  def mouse_dragged
-  	@points.push RPVector.new( mouse_x, mouse_y )
-  end
-  
-  def mouse_released
-  	@points.push RPVector.new( mouse_x, mouse_y )
-  	recalculate_shape
-  end
-  
-  def recalculate_shape
-  	
-  	@vertices = []
-  	@points.each_pair { |ps, pe|
-		
-		b = @points.last - @points.first
-		len = b.mag
-		b.normalize
-		
-		a = ps - @points.first
-		
-		dot = a.dot b
-		
-			b = b * dot
-		
-			normal = @points.first + b
-			
-			c = ps - normal
-			nlen = c.mag
-			
-			@vertices.push []
-			
-			(0..360).step( 12 ) { |deg|
-				
-				ang = radians deg
-				e = normal + c * cos( ang )
-				e.z = c.mag * sin( ang )
-				
-				@vertices.last.push e
-			}
-	}
-  	@drawing_mode = false
-  end
-  
+def setup 
+  size 1024, 768, P3D
+  frame_rate 30 
+  reset_scene
 end
 
+def draw  
+  background 0    
+  if (!drawing_mode)      
+    translate(width/2, height/2)
+    rotate_x rot_x
+    rotate_y rot_y
+    @rot_x += 0.01
+    @rot_y += 0.02
+    translate(-width/2, -height/2)
+  end 
+  no_fill
+  stroke 255
+  points.each_cons(2) { |ps, pe| line ps.x, ps.y, pe.x, pe.y}
 
-# this is a custom extension of the default Array class allowing for
-# more readable code above.
-#
-class Array
-
-	# send pairs into a block:
-	# array [1,2,3,4] sends
-	# [1,2] , [2,3] , [3,4]
-	def each_pair ( &block )
-		i = 1
-		while i < self.length do
-			yield( self[i-1], self[i] );
-			i = i + 1
-		end
-	end
-	
-	# send one item from each array, expects array to be 2D:
-	# array [[1,2,3], [a,b,c]] sends
-	# [1,a] , [2,b] , [3,c]
-	def one_of_each ( &block )
-		
-		i = 0
-		one = self[0]
-		two = self[1]
-		mi = one.length > two.length ? two.length : one.length
-		while i < mi do
-			yield( one[i], two[i] )
-			i = i + 1
-		end
-	end
+  if (!drawing_mode)    
+    stroke 125
+    fill 120
+    lights 
+    ambient_light 120, 120, 120
+    vertices.each_cons(2) do |r1, r2|
+      begin_shape(TRIANGLE_STRIP)
+      ext_array = [r1,r2].extend ExtendedArray # extend an instance of Array
+      ext_array.one_of_each do |v1, v2|          
+        vertex v1.x, v1.y, v1.z
+        vertex v2.x, v2.y, v2.z
+      end
+      end_shape 
+    end
+  end 
+end
+
+def reset_scene 
+  @drawing_mode = true
+  @points = []
+  @rot_x = 0.0
+  @rot_y = 0.0
+end
+
+def mouse_pressed
+  reset_scene
+  points << RPVector.new(mouse_x, mouse_y)
+end
 
+def mouse_dragged
+  points << RPVector.new(mouse_x, mouse_y)
 end
 
+def mouse_released
+  points << RPVector.new(mouse_x, mouse_y)
+  recalculate_shape
+end
+
+def recalculate_shape  
+  @vertices = []
+  points.each_cons(2) do |ps, pe|   
+    b = points.last - points.first
+    len = b.mag
+    b.normalize   
+    a = ps - points.first   
+    dot = a.dot b   
+    b = b * dot   
+    normal = points.first + b    
+    c = ps - normal
+    nlen = c.mag    
+    vertices << []    
+    (0..TWO_PI).step(PI/15) do |ang|     
+      e = normal + c * cos(ang)
+      e.z = c.mag * sin(ang)      
+      vertices.last << e
+    end
+  end
+  @drawing_mode = false
+end
 
 # a wrapper around PVector that implements operators methods for +, -, *, /
 #
 class RPVector < Java::ProcessingCore::PVector
 
-	def + ( other )
-		v = RPVector.add( self, other )
-		RPVector.new v.x, v.y, v.z
-	end
-	
-	def - ( other )
-		v = RPVector.sub( self, other )
-		RPVector.new v.x, v.y, v.z
-	end
-	
-	def * ( other )
-		v = RPVector.mult( self, other )
-		RPVector.new v.x, v.y, v.z
-	end
-	
-	def / ( other )
-		v = RPVector.div( self, other )
-		RPVector.new v.x, v.y, v.z
-	end
+  def + (vect)
+    RPVector.new self.x + vect.x, self.y + vect.y, self.z + vect.z
+  end
+
+  def - (vect)
+    RPVector.new self.x - vect.x, self.y - vect.y, self.z - vect.z
+  end
+
+  def * (scalar)
+    RPVector.new self.x * scalar, self.y * scalar, self.z * scalar
+  end
+
+  def / (scalar)
+    RPVector.new(self.x / scalar, self.y / scalar, self.z / scalar) unless scalar == 0
+  end
 
 end
 
-Drawvolver.new :title => "Drawvolver - fjenett 2010-03"
+
+