ruby-processing 2.4.4 → 2.5.0

data/samples/contributed/circle_collision.rb

@@ -18,17 +18,11 @@ class Ball
   end
   
   def check_boundary width, height 
-    if (position.x > width - r) 
-      position.x = width - r
+    if !(r .. width - r).include?(position.x)
+      (position.x > width - r)? position.x = width - r : position.x = 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
+    elsif !(r .. height - r).include?(position.y)
+      (position.y > height - r)? position.y = height - r : position.y = r
       velocity.y *= -1
     end    
   end
@@ -39,10 +33,9 @@ class Ball
     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)
+    if difference.mag < (r + other_ball.r) 
       # get angle of difference
       theta  = difference.heading
       # precalculate trig values

data/samples/contributed/elegant_ball.rb

@@ -5,8 +5,11 @@
 
 load_library :vecmath
 
+attr_reader :renderer
+
 def setup
   size(800, 800, P3D)
+  @renderer = AppRender.new(self) 
   color_mode(RGB, 1)
 end
 
@@ -79,20 +82,18 @@ def draw_icosahedron(depth, r, spherical)
   gr = (1.0 + Math.sqrt(5.0)) / 2.0
   h = r / Math.sqrt(1.0 + gr * gr)
   v =
-    [
-  Vec3D.new(0, -h, h*gr), Vec3D.new(0, -h, -h*gr), Vec3D.new(0, h, -h*gr), Vec3D.new(0, h, h*gr),
-  Vec3D.new(h, -h*gr, 0), Vec3D.new(h, h*gr, 0), Vec3D.new(-h, h*gr, 0), Vec3D.new(-h, -h*gr, 0),
-  Vec3D.new(-h*gr, 0, h), Vec3D.new(-h*gr, 0, -h), Vec3D.new(h*gr, 0, -h), Vec3D.new(h*gr, 0, h)
+  [
+  Vec3D.new(0, -h, h * r), Vec3D.new(0, -h, -h * r), Vec3D.new(0, h, -h * r), Vec3D.new(0, h, h * r),
+  Vec3D.new(h, -h * r, 0), Vec3D.new(h, h * r, 0), Vec3D.new(-h, h * r, 0), Vec3D.new(-h, -h * r, 0),
+  Vec3D.new(-h * r, 0, h), Vec3D.new(-h * r, 0, -h), Vec3D.new(h * r, 0, -h), Vec3D.new(h * r, 0, h)
   ]
   
   # Draw the 20 triangular faces of the icosahedron.
-  unless spherical then
-    r = 0.0
-  end
+  r = 0.0 unless spherical
   
   begin_shape(TRIANGLES)
     
-  draw_triangle(depth, r, v[0], v[7],v[4])
+  draw_triangle(depth, r, v[0], v[7], v[4])
   draw_triangle(depth, r, v[0], v[4], v[11])
   draw_triangle(depth, r, v[0], v[11], v[3])
   draw_triangle(depth, r, v[0], v[3], v[8])
@@ -124,16 +125,16 @@ end
 #
 def draw_triangle(depth, r, p1, p2, p3)
   
-  if (depth == 1) then
-    vertex(p1.x, p1.y, p1.z)
-    vertex(p2.x, p2.y, p2.z)
-    vertex(p3.x, p3.y, p3.z)
+  if (depth == 1)
+    p1.to_vertex(renderer)
+    p2.to_vertex(renderer)
+    p3.to_vertex(renderer)
   else
     # Calculate the mid points of this triangle.
     v1 = (p1 + p2) * 0.5
     v2 = (p2 + p3) * 0.5
     v3 = (p3 + p1) * 0.5
-    unless (r == 0.0) then
+    unless (r == 0.0)
       # Project the verticies out onto the sphere with radius r.
       v1.normalize!
       v1 *= r
@@ -150,9 +151,5 @@ def draw_triangle(depth, r, p1, p2, p3)
     # Uncomment out the next line to include the central part of the triangle.
     # draw_triangle(depth, r, v1, v2, v3)
   end
-  
 end
 
-
-
-

data/samples/contributed/empathy.rb

@@ -26,17 +26,17 @@ def initialize_cells
   n.times do |i|
     a = i + rand(PI / 9.0)
     r = ((i / n.to_f) * (width / 2) * (((n - i) / n.to_f) * 3.3)) + rand(6.0)
-    cells << Cell.new((r * cos(a) + width/2).to_i, (r * sin(a) + height/2).to_i)
+    cells << Cell.new((r * cos(a) + width / 2).to_i, (r * sin(a) + height / 2).to_i)
   end
 end
 
 def start_cell_updates
-  Thread.new { Kernel.loop { cells.each {|cell| cell.update } } }
+  Thread.new { Kernel.loop { cells.each { |cell| cell.update } } }
 end
 
 def draw
   background 255
-  cells.each {|cell| cell.sense } if started?
+  cells.each { |cell| cell.sense } if started?
 end
 
 def started?
@@ -44,9 +44,13 @@ def started?
 end
 
 def mouse_pressed
-  cells.each {|cell| cell.reset }
+  cells.each { |cell| cell.reset }
 end
 
+##
+# The cell responds to mouse movement
+##
+
 class Cell
   attr_reader :x, :y, :spin, :angle
   def initialize(x, y)
@@ -71,5 +75,4 @@ class Cell
     d = LINE_LENGTH * spin + 0.001
     line(x, y, x + d * cos(angle), y + d * sin(angle))
   end
-
 end

data/samples/contributed/fibonacci_sphere.rb

@@ -9,23 +9,18 @@
 #
 
 load_library :vecmath
-import "arcball"
 
-X = 0
-Y = 1
-Z = 2
+PHI = (sqrt(5) + 1) / 2 - 1   # golden ratio
+GA = PHI * TAU           # golden angle
 
-PHI = (sqrt(5)+1) / 2 - 1   # golden ratio
-GA = PHI * TWO_PI           # golden angle
-
-KMAX_POINTS = 100000
+KMAX_POINTS = 100_000
 
 attr_reader :pts, :rotation_x, :rotation_y, :nbr_points, :radius, :add_points
 attr_reader :my_ball # for arcball rotation
 
 def setup
   size(1024, 768, P3D)
-  @my_ball = ArcBall.new(width/2.0, height/2.0, min(width - 20, height - 20) * 0.5)
+  ArcBall.init(self, width / 2.0, height / 2.0)
   @rotation_x = 0
   @rotation_y = 0
   @nbr_points = 2000
@@ -47,41 +42,10 @@ def draw
   lights
   ambient(200, 10, 10)
   ambient_light(150, 150, 150)
-  translate(width/2.0, height/2.0, 0)
-  update  # for arcball rotation
   render_globe   
 end
 
-# arcball functionality ##################
-##########################################
-
-def update
-  theta, x, y, z = my_ball.update
-  rotate(theta, x, y, z)
-end
-
-def mouse_pressed
-  my_ball.mouse_pressed(mouse_x, mouse_y)
-end
-
-def mouse_dragged
-  my_ball.mouse_dragged(mouse_x, mouse_y)
-end
-
-def key_pressed                
-  case(key)
-  when 'x'
-    my_ball.select_axis(X)
-  when 'y'
-    my_ball.select_axis(Y)
-  when 'z'
-    my_ball.select_axis(Z)
-  end
-end
 
-def key_released
-  my_ball.select_axis(-1)
-end
 ###########################################
 # For Fibonacci Sphere
 ##################################
@@ -106,20 +70,17 @@ def mouse_clicked
   @add_points = !add_points
 end
 
-SpherePoint = Struct.new(:lat, :lon) do
-end
+SpherePoint = Struct.new(:lat, :lon)
 
 def init_sphere(num)  
   (0 .. num).each do |i| 
     lon = GA * i
-    lon /= TAU 
-    lon -= lon.floor 
-    lon *= TAU 
-    if (lon > PI)
-      lon -= TAU
-    end    
+    lon /= TAU
+    lon -= lon.floor
+    lon *= TAU    
+    lon -= TAU if lon > PI
     # Convert dome height (which is proportional to surface area) to latitude
-    # lat = asin(-1 + 2 * i / num.to_f)    
+    # lat = asin(-1 + 2 * i / num.to_f)
     pts[i] = SpherePoint.new(asin(-1 + 2 * i / num.to_f), lon)
   end
 end

data/samples/contributed/full_screen.rb

@@ -2,7 +2,7 @@
 # This is a full-screen demo 
 # Since processing-2.0 it is opengl
 
-#full_screen # not working correctly in processing-2.1+?
+full_screen
 
 
 def setup

data/samples/contributed/grapher.rb

@@ -3,13 +3,15 @@
 # http://www.contextfreeart.org/gallery/view.php?id=2844
 #
 
+load_library :fastmath
+
 CMIN = -2.0 # Important to specify float else get random int from range?
 CMAX = 2.0
 FUZZ = 0.04
 SZ = 5
 
 def setup
-  size 600, 600    
+  size 600, 600
   no_stroke
   color_mode(HSB, 1.0)
   background(0)
@@ -17,19 +19,18 @@ def setup
 end
 
 def draw
-  translate(width/2, height/2)
-  dot(rand(-PI .. PI), rand(-PI .. PI), rand(CMIN .. CMAX)) unless frame_count > 200000
+  translate(width / 2, height / 2)
+  dot(rand(-180 .. 180), rand(-180 .. 180), rand(CMIN .. CMAX)) unless frame_count > 200_000
 end
 
-def dot(px, py, c)    
-  func = sin(px) + sin(py) + c
+def dot(px, py, c)
+  func = DegLut.sin(px) + DegLut.sin(py) + c
   # change function to change the graph eg.
-  #func = sin(px) + tan(py) + c    
-  #func = cos(px) + sin(py) + c
+  # func = DegLut.cos(px) + DegLut.sin(py) + c
   if func.abs <= FUZZ
     fill(((CMIN - c) / (CMIN - CMAX)), 1, 1)
-    ellipse px * width / TWO_PI, py * height / TWO_PI, SZ, SZ
+    ellipse px * width / 360, py * height / 360, SZ, SZ
   else
-    dot(rand(-PI .. PI), rand(-PI .. PI), rand(CMIN .. CMAX))
+    dot(rand(-180 .. 180), rand(-180 .. 180), rand(CMIN .. CMAX))
   end
 end

data/samples/contributed/gravity.rb

@@ -7,7 +7,7 @@ def setup
   @particles  = []
   @grabbed    = nil  
   background 0
-  smooth
+  smooth 4
   stroke_weight 4
   ellipse_mode CENTER
   color_mode RGB, 255
@@ -17,13 +17,13 @@ def draw
   no_stroke
   fill 0, 60
   rect 0, 0, width, height
-  particles.each {|p| p.collect_force; p.move; p.render }
+  particles.each { |p| p.collect_force; p.move; p.render }
 end
 
 def mouse_pressed
   return if mouse_x == 0 || mouse_y == 0
   return if particle_grab
-  particles << Particle.new(mouse_x, mouse_y, rand * 8 + 0.1)
+  particles << Particle.new(mouse_x, mouse_y, rand(0.1 .. 8))
 end
 
 def mouse_released
@@ -31,14 +31,11 @@ def mouse_released
 end
 
 def particle_grab
-  @grabbed = particles.detect {|p| dist(mouse_x, mouse_y, p.x1, p.y1) < p.diameter/2 }
+  @grabbed = particles.detect { |p| dist(mouse_x, mouse_y, p.x1, p.y1) < p.diameter/2 }
 end
 
-
 class Particle
-  
-  GRAVITY = 1.0
-  
+  GRAVITY = 1.0  
   attr_reader :x0, :y0, :x1, :y1, :diameter, :mass_amount
   
   def initialize(x, y, mass)
@@ -54,8 +51,8 @@ class Particle
     @min_dist = 1000
     $app.particles.each do |p|
       next if p == self
-      g_dist  = dist(x0, y0, p.x0, p.y0)
-      g_theta = -(angleOf(x0, y0, p.x0, p.y0)).radians
+      g_dist  = Math.hypot(x0 - p.x0, y0 - p.y0)
+      g_theta = -angle_of(x0, y0, p.x0, p.y0)
       @min_dist = g_dist if g_dist < @min_dist
       force = (GRAVITY * mass_amount * p.mass_amount) / g_dist
       if g_dist.abs > diameter
@@ -84,7 +81,7 @@ class Particle
   def render_free
     charge_col  = 1000.0 / @min_dist / 50.0
     tot_col_1   = 100 + charge_col * 6
-    tot_col_2   = 150 + charge_col*charge_col
+    tot_col_2   = 150 + charge_col * charge_col
     tot_col_3   = diameter + 8 + charge_col
     fill(tot_col_1, tot_col_1, 255, charge_col * 150 + 3)
     ellipse(x1, y1, tot_col_3, tot_col_3)
@@ -103,9 +100,7 @@ class Particle
     @x0, @y0 = mouse_x, mouse_y
   end
   
-  def angleOf(x1, y1, x2, y2)
-    xd, yd = x1 - x2, y1 - y2
-    180 + (-(180 * atan2(yd, xd)) / PI)
-  end
-  
+  def angle_of(x1, y1, x2, y2)
+    Math::PI - atan2(y1 - y2, x1 - x2)
+  end  
 end

data/samples/contributed/jwishy.rb

@@ -3,8 +3,8 @@
 # from a Python example for Nodebox, and then, now
 # to Ruby-Processing.
 
-# For fun, try running it via jirb, and 
-# playing with the attr_accessors, as 
+# For fun, try running it via jirb, and
+# playing with the attr_accessors, as
 # well as the background.
 
 # This example now demonstrates the use of the control_panel.
@@ -13,21 +13,20 @@
 
 load_library :control_panel
 
-attr_accessor :x_wiggle, :y_wiggle, :magnitude, :bluish, :panel, :laf, :hide  
+attr_accessor :x_wiggle, :y_wiggle, :magnitude, :bluish, :panel, :laf, :hide
 
 def setup
-  size 600, 600  
+  size 600, 600
   control_panel do |c|
-    c.look_feel "Nimbus"
+    c.look_feel 'Nimbus'
     c.slider    :bluish, 0.0..1.0, 0.5
     c.slider    :alpha,  0.0..1.0, 0.5
     c.checkbox  :go_big
     c.button    :reset
-    c.menu      :shape, ['oval', 'square']
+    c.menu      :shape, %w(oval square)
     @panel = c
   end
   @hide = false
-  
   @shape = 'oval'
   @alpha, @bluish = 0.5, 0.5
   @x_wiggle, @y_wiggle = 10.0, 0
@@ -45,7 +44,7 @@ end
 
 def draw_background
   @background[3] = @alpha
-  fill *@background if @background[0]
+  fill(*@background) if @background[0]
   rect 0, 0, width, height
 end
 
@@ -57,38 +56,37 @@ def draw
   # only make control_panel visible once, or again when hide is false
   unless hide
     @hide = true
-    panel.setVisible(hide)    
+    panel.set_visible(hide)
   end
   draw_background
-  
+
   # Seed the random numbers for consistent placement from frame to frame
   srand(0)
   horiz, vert, mag = @x_wiggle, @y_wiggle, @magnitude
-  
+
   if @go_big
     mag  *= 2
     vert /= 2
   end
-  
+
   blu = bluish
-  x, y = (self.width / 2), -27
+  x, y = (width / 2), -27
   c = 0.0
-  
-  64.times do 
-    x += cos(horiz)*mag
-    y += log10(vert)*mag + sin(vert) * 2
+
+  64.times do
+    x += cos(horiz) * mag
+    y += log10(vert) * mag + sin(vert) * 2
     fill(sin(@y_wiggle + c), rand * 0.2, rand * blu, 0.5)
     s = 42 + cos(vert) * 17
-    args = [x-s/2, y-s/2, s, s]
+    args = [x - s / 2, y - s / 2, s, s]
     @shape == 'oval' ? oval(*args) : rect(*args)
     vert += rand * 0.25
     horiz += rand * 0.25
     c += 0.1
   end
-  
+
   @x_wiggle += 0.05
   @y_wiggle += 0.1
-
 end
 
 def mouse_pressed