ruby-processing 2.4.3 → 2.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: af2855010f2d2de32e8e7dc8c1828f51c84f56af
-  data.tar.gz: dab785b90f956a8ef19af5bffe4e449577397fcb
+  metadata.gz: b4495d11c567dab0a4324cbb26cfb493f18e413a
+  data.tar.gz: 49efbea8dca4fcbbc160312bb6888b38217e935d
 SHA512:
-  metadata.gz: 50cf01b0dd1f3a1e327abbd76448dfacb202ba8f366337b12c80a6a2d7807b7b4b8a1020c2a4ecbee25ad1e0459c837791e6491bc0741f1c591f60ac0c47c141
-  data.tar.gz: 844bc75fbdaea88f0f2e83d282da9c5bbb467475c56021177f60a8e01caccdfd57c95deb3a022fc86e47535a978da780d1ec975444170bd1c3eb7d152b5517c9
+  metadata.gz: c3fd10e43df37279cd790a9705ee42fec592335461f09490127097f3bf0aaa649bd9968faa86193df6bdb7dc30be4b12c1a04aa46cb2cc8aa2ae82a25b9aebee
+  data.tar.gz: 3b01b98834983da3428190813ac6e2a1d9c834d078d578b55a9131fcaaa75978fa4eec3d7fb39137f93745149cf1c501ec5aad8983ec4806c2e064ce64f8d41c

data/.gitignore

@@ -1,7 +1,7 @@
 syntax: glob
 .DS_Store
 *.sw*
-*.*~
+*~
 *.pdf
 *.gem
 *.tgz
@@ -9,3 +9,5 @@ syntax: glob
 *.zip
 samples/processing_app/topics/file_io/output/*.png
 Gemfile.lock
+.ruby-version
+.jrubyrc

data/CHANGELOG

@@ -1,3 +1,8 @@
+v2.4.4 Update to JRuby-1.7.12
+* Enhancement to Vec2D & Vec3D (preferred to PVector as
+* providing a more ruby-like interface), now provide a
+* conditional set_mag method, via optional &block.
+
 v2.4.3 Update to JRuby-1.7.11
 * Added an autorun demo Rakefile to some sample directories
 * Support utf-8 in sketches

data/README.md

@@ -1,5 +1,5 @@
 # Ruby-Processing
-[![Gem Version](https://badge.fury.io/rb/ruby-processing.png)](http://badge.fury.io/rb/ruby-processing)
+[![Gem Version](https://badge.fury.io/rb/ruby-processing.svg)](http://badge.fury.io/rb/ruby-processing)
 
 Is a ruby wrapper around the [Processing][] code art framework, built using [JRuby][].
 
@@ -11,6 +11,7 @@ Is a ruby wrapper around the [Processing][] code art framework, built using [JRu
   smooth, text_align, translate, triangle...
 
 ## Installation
+MacOSX users please try out this new  [method](https://github.com/jashkenas/ruby-processing/wiki/Installing-ruby-processing-on-the-mac)
 
 Ideally you should install [jruby](http://jruby.org/download), at the very least you will have at least ruby-1.9.3 installed.  You should [download][] and install vanilla [processing-2.0.3](https://processing.org/download/) (MacOSX) or [processing-2.1.0](https://processing.org/download/) (Windows, Linux) prior to installing this version of ruby-processing. You must also set the `PROCESSING_ROOT` in the .rp5rc yaml configuration file, the easiest way to do this is by running the [SetProcessingRoot.pde](https://gist.github.com/monkstone/7438749) sketch in the processing ide. 
 
@@ -95,6 +96,7 @@ This library has been tested with the following ruby implementations
 
 * Ruby 1.9.3
 * Ruby 2.0.0
+* Ruby 2.1.0
 * [JRuby][] preferred (required to use rubygems in sketches)
 
 [License][]
@@ -111,7 +113,7 @@ This library has been tested with the following ruby implementations
 
 ## What's new
 
-New capabilities since processing-2.0 include ability to use OPENGL VBO (PShape) and GLSL shaders (PShader), to keep abreast of latest shader developments for processing check out the [codeanticode blog](http://codeanticode.wordpress.com/2013/06/04/processing-2-0-is-out-processing-2-0-is-in/). Some worked examples using new feature are included in the samples. The update to the latest jruby is also significant as the default is to run with ruby-1.9 support (or even use ruby-2.0 syntax with `compat.version=2.0` in your `.jrubyrc` config), and there have been many performance improvements. Some performance improvements will not be available on the Mac as they require at least java-7+, and there is even more to come with java-8+ (adventurous Mac users can read more about [Oracle java here](http://www.java.com/en/download/faq/java_mac.xml) ). More than 330 worked examples are included in the [Samples][], many of which are rubified version of the examples included with vanilla processing, and or the contributed libraries, additions are welcome.
+New capabilities since processing-2.0 include ability to use OPENGL VBO (PShape) and GLSL shaders (PShader), to keep abreast of latest shader developments for processing check out the [codeanticode blog](http://codeanticode.wordpress.com/2013/06/04/processing-2-0-is-out-processing-2-0-is-in/). Some worked examples using new feature are included in the samples. The update to the latest jruby is also significant as the default is to run with ruby-1.9 support (or even use ruby-2.0 syntax with `compat.version=2.0` in your `.jrubyrc` config), and there have been many performance improvements. Some performance improvements will not be available on the Mac as they require at least java-7+, and there is even more to come with java-8+ (adventurous Mac users can read more about [Oracle java here](http://www.java.com/en/download/faq/java_mac.xml) ). More than 330 worked examples are included in the [Samples][], many of which are rubified version of the examples included with vanilla processing, and or the contributed libraries, additions are welcome. In my experience ruby-processing works even better with the recently released jdk-8 (try `-XX:+TieredCompilation` option in java_args.txt). But please note you will not be able to use jdk-8 with vanilla-processing, at least for the forseeable future. 
 
 
 

data/lib/ruby-processing/exporters/application_exporter.rb

@@ -11,6 +11,7 @@ module Processing
     The application exporter will generate a Mac application for you.
     Usage: script/application <path_to_sketch>
     Example: script/applet samples/jwishy.rb 
+    Probably won't work with Oracle Java on Mac
       
     EOS
     

data/lib/ruby-processing/version.rb

@@ -1,3 +1,3 @@
 module RubyProcessing
-  VERSION="2.4.3"
+  VERSION="2.4.4"
 end

data/library/boids/boids.rb

@@ -18,8 +18,8 @@ class Boid
     # Boids gravitate towards the center of the flock,
     # Which is the averaged position of the rest of the boids.
     cvx, cvy, cvz = 0.0, 0.0, 0.0
-    boids.each do |boid|
-      cvx, cvy, cvz = cvx+boid.x, cvy+boid.y, cvz+boid.z unless boid.equal? self
+    boids.reject{|bd| bd.equal? self}.each do |boid|
+      cvx, cvy, cvz = cvx+boid.x, cvy+boid.y, cvz+boid.z 
     end
     count = boids.length - 1.0
     cvx, cvy, cvz = cvx/count, cvy/count, cvz/count
@@ -29,13 +29,11 @@ class Boid
   def separation(radius = 10.0)
     # Boids don't like to cuddle.
     svx, svy, svz = 0.0, 0.0, 0.0
-    boids.each do |boid|
-      unless boid.equal? self
-        dvx, dvy, dvz = x - boid.x, y - boid.y, z - boid.z
-        svx += dvx if dvx.abs < radius
-        svy += dvy if dvy.abs < radius
-        svz += dvz if dvz.abs < radius
-      end
+    boids.reject{|bd| bd.equal? self}.each do |boid|
+      dvx, dvy, dvz = x - boid.x, y - boid.y, z - boid.z
+      svx += dvx if dvx.abs < radius
+      svy += dvy if dvy.abs < radius
+      svz += dvz if dvz.abs < radius
     end
     return svx, svy, svz
   end
@@ -43,10 +41,8 @@ class Boid
   def alignment(d = 5.0)
     # Boids like to fly at the speed of traffic.
     avx, avy, avz = 0.0, 0.0, 0.0
-    boids.each do |boid|
-      unless boid.equal? self
-        avx, avy, avz = avx+boid.vx, avy+boid.vy, avz+boid.vz
-      end
+    boids.reject{|bd| bd.equal? self}.each do |boid|
+      avx, avy, avz = avx+boid.vx, avy+boid.vy, avz+boid.vz
     end
     count = boids.length - 1.0
     avx, avy, avz = avx / count, avy / count, avz / count
@@ -94,6 +90,11 @@ class Boids
   def each &block
     boids.each &block	  
   end
+  
+  def reject &block
+    boids.reject &block
+  end
+
 
   def shuffle!
     boids.shuffle!	  

data/library/vecmath/lib/vec.rb

@@ -112,8 +112,14 @@ class Vec2D
     @x, @y = x / magnitude, y / magnitude
     return self
   end
-  
-  def set_mag(scalar)
+
+  # The &block option means we can conditionally set_mag to
+  # a limit value for example, when given &block returns true.
+
+  def set_mag(scalar, &block)
+    if block_given? && yield == false
+      return self
+    end      
     magnitude = Math.hypot(x, y)	  
     @x, @y = (x * scalar) / magnitude, (y * scalar) / magnitude
     return self    
@@ -146,6 +152,10 @@ class Vec2DR < Vec2D
 end
 
 class Vec3D < Vec2D
+  
+  def mag_squared
+    x**2 + y**2 + z**2
+  end
 
   def modulus
     Math.sqrt(x**2 + y**2 + z**2)
@@ -197,8 +207,14 @@ class Vec3D < Vec2D
     @x, @y, @z = x / magnitude, y / magnitude, z / magnitude
     return self
   end
-  
-  def set_mag(scalar)
+
+  # The optional &block should evaluate to a boolean
+  # if given, the set_mag becomes conditional (eg set max/min)
+
+  def set_mag(scalar, &block)
+    if block_given? && yield == false
+      return self
+    end
     magnitude = Math.sqrt(x**2 + y**2 + z**2)
     @x, @y, @z = (x * scalar) / magnitude, (y * scalar) / magnitude, (z * scalar) / magnitude
     return self    

data/samples/contributed/circle_collision.rb

@@ -1,193 +1,136 @@
 # Based on http://processing.org/learning/topics/circlecollision.html
-# by Joe Holt
 
+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, :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 move
-    @x += vec.x
-    @y += vec.y
-  end
-  
-  def draw
-    d = r * 2
-    ellipse x, y, d, d
-    @px, @py = x, y
-  end
+  attr_accessor :position, :r, :m, :velocity
   
-  def erase
-    d = r * 2
-    rect px, py, d, d
-  end
-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 draw
-  t = Time.now
-  fps = 1.0 / (t - @frame_time) if @frame_time
-  @frame_time = t
-  @frame_count += 1
+  def initialize(x = 0.0, y = 0.0, r = 0.0)
+    @position = Vec2D.new(x, y)
+    @r = r
+    @m = r * 0.1
+    @velocity = Vec2D.new(rand(-3.0 .. 3), rand(-3.0 .. 3))
+  end 
   
-  # erase previous screen
-  if @frame_count == 1
-    background 51
-  else
-    fill 51
-    @balls.each { |ball| ball.erase }
+  def update
+    @position += velocity
   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(r)
-  x = y = nil
-  while !x || !empty_space?(x, y, r) do
-    x = rand(width)
-    y = rand(height)
+  def check_boundary width, height 
+    if (position.x > width - r) 
+      position.x = width - r
+      velocity.x *= -1
+    elsif (position.x < r) 
+      position.x = r
+      velocity.x *= -1
+    elsif (position.y > height - r) 
+      position.y = height - r
+      velocity.y *= -1
+    elsif (position.y < r) 
+      position.y = r
+      velocity.y *= -1
+    end    
   end
-  return x, y
-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
-end
-
-
-def check_object_collisions
   
-  (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)
+  def check_collision other_ball    
+    
+    # get distances between the balls components
+    difference = other_ball.position - position
+    
+    # calculate magnitude of the vector separating the balls
+    
+    dist_mag_squared = difference.mag_squared
+    
+    if dist_mag_squared < (r + other_ball.r) * (r + other_ball.r)
+      # get angle of difference
+      theta  = difference.heading
       # 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 
+      # ball_array will hold rotated ball positions. You just
+      # need to worry about ball_array[1] position
+      ball_array = [Ball.new, Ball.new]
+      # other_ball's position is relative to ball's
+      # so you can use the vector between them (difference) as the 
       # reference point in the rotation expressions.
-      # bTemp[0].x and bTemp[0].y will initialize
+      # ball_array[0].x and ball_array[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
+      # since other_ball will rotate around ball
+      ball_array[1].position.x  = cosine * difference.x + sine * difference.y
+      ball_array[1].position.y  = cosine * difference.y - sine * difference.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
+      velocity_array = [Vec2D.new, Vec2D.new]
+      velocity_array[0].x  = cosine * velocity.x + sine * velocity.y
+      velocity_array[0].y  = cosine * velocity.y - sine * velocity.x
+      velocity_array[1].x  = cosine * other_ball.velocity.x + sine * other_ball.velocity.y
+      velocity_array[1].y  = cosine * other_ball.velocity.y - sine * other_ball.velocity.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
+      final_velocities = [Vec2D.new, Vec2D.new]
+      # final rotated velocity for ball
+      final_velocities[0].x = ((m - other_ball.m) * velocity_array[0].x + 2 * other_ball.m * velocity_array[1].x) / (m + other_ball.m)
+      final_velocities[0].y = velocity_array[0].y
+      # final rotated velocity for ball
+      final_velocities[1].x = ((other_ball.m - m) * velocity_array[1].x + 2 * m * velocity_array[0].x) / (m + other_ball.m)
+      final_velocities[1].y = velocity_array[1].y
       
       # hack to avoid clumping
-      bTemp[0].x += vFinal[0].x
-      bTemp[1].x += vFinal[1].x
+      #ball_array[0].position.x += final_velocities[0].x
+      #ball_array[1].position.x += final_velocities[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
+      final_positions = [Vec2D.new, Vec2D.new]
+      final_positions[0].x = cosine * ball_array[0].position.x - sine * ball_array[0].position.y
+      final_positions[0].y = cosine * ball_array[0].position.y + sine * ball_array[0].position.x
+      final_positions[1].x = cosine * ball_array[1].position.x - sine * ball_array[1].position.y
+      final_positions[1].y = cosine * ball_array[1].position.y + sine * ball_array[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
+      other_ball.position = position + final_positions[1]
+      @position += final_positions[0]
       
       # 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
+      velocity.x = cosine * final_velocities[0].x - sine * final_velocities[0].y
+      velocity.y = cosine * final_velocities[0].y + sine * final_velocities[0].x
+      other_ball.velocity.x = cosine * final_velocities[1].x - sine * final_velocities[1].y
+      other_ball.velocity.y = cosine * final_velocities[1].y + sine * final_velocities[1].x
+      
     end
   end
   
+  def display
+    no_stroke
+    fill(204)
+    ellipse(position.x, position.y, r * 2, r * 2)
+  end
+  
 end
 
+attr_reader :balls
 
-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
+def setup
+  size 640, 360
+  @balls = [Ball.new(100, 40, 20), Ball.new(200, 100, 80)]
+end
+
+
+def draw
+  background(51)  
+  balls.each do |b| 
+    b.update
+    b.display
+    b.check_boundary width, height
   end
+  
+  balls[0].check_collision(balls[1])
 end