ruby-processing 2.4.4 → 2.5.0

data/samples/processing_app/demos/performance/cubic_grid_retained.rb

@@ -1,6 +1,6 @@
 ########################
-# NB: Slow to get going 
-# but, performs Ok after 
+# NB: Bit slow to get going
+# but, performs Ok after
 ########################
 
 BOX_SIZE = 20
@@ -16,15 +16,15 @@ def setup
   @fcount = 0
   @lastm = 0
   no_smooth
-  no_stroke 
-  @grid = create_shape(GROUP)    
-  # Build grid using multiple translations 
+  no_stroke
+  @grid = create_shape(GROUP)
+  # Build grid using multiple translations
   (-(DEPTH/2 + MARGIN) ... (DEPTH/2 - MARGIN)).step(BOX_SIZE) do |i|
     (-(height + MARGIN) ... (height - MARGIN)).step(BOX_SIZE) do |j|
       (-(width + MARGIN) ... (width - MARGIN)).step(BOX_SIZE) do |k|
-        # Base fill color on counter values, abs function 
+        # Base fill color on counter values, abs function
         # ensures values stay within legal range
-        @box_fill = color(i.abs.to_i, j.abs.to_i, k.abs.to_i, 50)        
+        @box_fill = color(i.abs.to_i, j.abs.to_i, k.abs.to_i, 50)
         cube = create_shape(BOX, BOX_SIZE.to_f, BOX_SIZE.to_f, BOX_SIZE.to_f)
         cube.set_fill(box_fill)
         cube.translate(k, j, i)
@@ -35,24 +35,24 @@ def setup
 end
 
 def draw
-  background(255)  
-  hint(DISABLE_DEPTH_TEST)  
+  background(255)
+  hint(DISABLE_DEPTH_TEST)
   # Center and spin grid
   push_matrix()
   translate(width/2, height/2, -DEPTH)
   rotate_y(frame_count * 0.01)
   rotate_x(frame_count * 0.01)
   shape(grid)
-  pop_matrix()  
-  hint(ENABLE_DEPTH_TEST)  
+  pop_matrix()
+  hint(ENABLE_DEPTH_TEST)
   @fcount += 1
   m = millis()
-  if (m - lastm > 1000 * FINT) 
+  if (m - lastm > 1000 * FINT)
     @frate = fcount / FINT
     @fcount = 0
     @lastm = m
-    puts("fps: #{frate}") 
-  end 
+    puts("fps: #{frate}")
+  end
   fill(0)
   text("fps: #{frate}", 10, 20)
 end

data/samples/processing_app/demos/performance/esfera.rb

@@ -1,13 +1,13 @@
 #
 # Esfera
-# by David Pena.  
+# by David Pena.
 # Somewhat re-factored for ruby-processing
 # by Martin Prout
-# Distribucion aleatoria uniforme sobre la superficie de una esfera. 
+# Distribucion aleatoria uniforme sobre la superficie de una esfera.
 #
+load_library :vecmath
 
-
-QUANTITY = 16000 
+QUANTITY = 16000
 
 attr_reader :orb, :phi, :radius, :rx, :ry
 
@@ -19,26 +19,20 @@ java_alias :stroke_float_float, :stroke, [Java::float, Java::float]
 
 def setup
   size(800, 600, P3D)
+  ArcBall.init(self, width / 2.0, height / 2.0)
   @rx = 0
   @ry =0
   no_smooth
   @radius = height/3.5
   @orb = HairyOrb.new(self, radius)
   QUANTITY.times do
-    orb << HairFactory.create_hair(radius) 
+    orb << create_hair(radius)
   end
   noise_detail(3)
 end
 
 def draw
   background_int(0)
-  translate(width/2,height/2)
-  rxp = ((mouse_x - (width/2))*0.005)
-  ryp = ((mouse_y - (height/2))*0.005)
-  @rx = (rx*0.9)+(rxp*0.1)
-  @ry = (ry*0.9)+(ryp*0.1)
-  rotate_y(rx)
-  rotate_x(ry)
   fill_int 0
   no_stroke
   sphere(radius)
@@ -48,21 +42,30 @@ def draw
   end
 end
 
-class HairyOrb 
+def create_hair radius
+  z = rand(-radius .. radius)
+  phi = rand(0 .. TAU)
+  len = rand(1.15 .. 1.2)
+  theta = Math.asin(z / radius)
+  Hair.new(z, phi, len, theta)
+end
+
+require 'forwardable'
+
+class HairyOrb
   extend Enumerable
+  extend Forwardable
+  def_delegators(:@hairs, :each, :<<)
+
   attr_reader :app, :hairs, :radius
-  
+
   def initialize app, radius
     @app, @radius = app, radius
-    @hairs = []    
+    @hairs = []
   end
-  
-  def << item
-    hairs << item
-  end      
-  
-  def render   
-    hairs.each do |hair|
+
+  def render
+    self.each do |hair|
       off = (app.noise(app.millis() * 0.0005, sin(hair.phi)) - 0.5) * 0.3
       offb = (app.noise(app.millis() * 0.0007, sin(hair.z) * 0.01) - 0.5) * 0.3
       thetaff = hair.theta + off
@@ -83,23 +86,8 @@ class HairyOrb
       app.stroke_float_float(200, 150)
       app.vertex(xb, yb, zb)
       app.end_shape()
-    end 
+    end
   end
 end
 
-class HairFactory 
-  def self.create_hair radius
-    z = rand(-radius .. radius)
-    phi = rand * Math::PI * 2
-    len = rand(1.15 .. 1.2)
-    theta = Math.asin(z / radius)
-    return Hair.new(z, phi, len, theta)
-  end 
-end
-
-class Hair
-  attr_reader :z, :phi, :len, :theta  
-  def initialize z, phi, len, theta 
-    @z, @phi, @len, @theta = z, phi, len, theta 
-  end
-end
+Hair = Struct.new(:z, :phi, :len, :theta )

data/samples/processing_app/demos/performance/text_rendering.rb

@@ -3,7 +3,7 @@ def setup
   fill(0)
 end
 
-def draw     
+def draw
   background(255)
   (0 .. 10000).each do
     x = rand(width)

data/samples/processing_app/library/fastmath/clock.rb

@@ -0,0 +1,44 @@
+# The current time can be read with the second(), minute(), and hour()
+# functions. In this example, DegLut.sin() and DegLut.cos() values are used to
+# set the position of the hands, perfect for degree precision Lookup Table.
+load_library :fastmath
+
+def setup
+  size 200, 200
+  stroke 255
+  smooth 8
+end
+
+def draw
+  background 0
+  fill 80
+  no_stroke
+  # adj factor to map 0-60 to 0-360 (seconds/minutes) & 0-12 to 0-360 (hours)
+  # since angles for DegLut.sin() and DegLut.cos() start at 3 o'clock we
+  # subtract 90 degrees to make them start at the top.
+  clock_x = lambda do |val, adj, length|
+    DegLut.cos((val * adj).to_i - 90) * length + width / 2
+  end
+  clock_y = lambda do |val, adj, length|
+    DegLut.sin((val * adj).to_i - 90) * length + height / 2
+  end
+  ellipse 100, 100, 160, 160
+  stroke 220
+  stroke_weight 6
+  line(100, 100, clock_x.call(hour % 12 + (minute / 60.0), 30, 50),
+                 clock_y.call(hour % 12 + (minute / 60.0), 30, 50))
+  stroke_weight 3
+  line(100, 100, clock_x.call(minute + (second / 60.0), 6, 60),
+                 clock_y.call(minute + (second / 60.0), 6, 60))
+  stroke 255, 0, 0
+  stroke_weight 1
+  line(100, 100, clock_x.call(second, 6, 72), clock_y.call(second, 6, 72))
+  # Draw the minute ticks
+  stroke_weight 2
+  stroke 255
+  (0..360).step(6) do |a|
+    x = 100 + DegLut.cos(a) * 72
+    y = 100 + DegLut.sin(a) * 72
+    point x, y
+  end
+end

data/samples/processing_app/library/pdf/complex_3D.rb

@@ -2,7 +2,7 @@
 #  Geometry 
 #  by Marius Watz. 
 #  
-load_library 'pdf'
+load_libraries :pdf, :fastmath
 include_package 'processing.pdf'
 
 attr_reader :num, :pt, :style, :dosave
@@ -18,37 +18,38 @@ def setup
   # Set up arc shapes
   index = 0
   (0 ... num).each do |i|
-    pt.push(rand(TWO_PI)) # Random X axis rotation
-    pt.push(rand(TWO_PI)) # Random Y axis rotation
+    pt << rand(TAU) # Random X axis rotation
+    pt << rand(TAU) # Random Y axis rotation
     
-    pt.push(rand(60 .. 80)) # Short to quarter-circle arcs
+    pt << rand(60 .. 80) # Short to quarter-circle arcs
     if (rand(100)>90)
       pt[pt.length - 1] = rand(8 .. 27) * 10
     end     
-    pt.push(rand(2 .. 50) * 5) # Radius. Space them out nicely
+    pt << rand(2 .. 50) * 5 # Radius. Space them out nicely
     
-    pt.push(rand(4 .. 32)) # Width of band
+    pt << rand(4 .. 32) # Width of band
     if (rand(100) > 90)
       pt[pt.length - 1] = rand(40 .. 60) # Width of band
     end
     
-    pt.push(rand(0.005 .. 0.0334))# Speed of rotation
+    pt << rand(0.005 .. 0.0334)# Speed of rotation
     
     # get colors
     prob = rand(100)
-    if (prob < 30)
+    case prob
+    when (0 .. 30)
       style[i*2] = color_blended(rand, 255,0,100, 255,0,0, 210)
-    elsif(prob < 70) 
+    when (30 .. 70) 
       style[i*2] = color_blended(rand, 0,153,255, 170,225,255, 210)
-    elsif(prob<90) 
+    when (70 .. 90) 
       style[i*2] = color_blended(rand, 200,255,0, 150,255,0, 210)
     else 
       style[i*2] = color(255,255,255, 220)
     end
-    
-    if (prob < 50)
+    case prob
+    when (0 .. 50)
       style[i*2] = color_blended(rand, 200,255,0, 50,120,0, 210)
-    elsif(prob < 90)
+    when (50 .. 90)
       style[i*2] = color_blended(rand, 255,100,0, 255,255,0, 210)
     else
       style[i*2] = color(255, 255, 255, 220)
@@ -78,13 +79,14 @@ def draw
     rotate_x(pt[index])
     rotate_y(pt[index + 1])
     index += 2
-    if (style[i*2+1] == 0)
+    case (style[i*2+1])
+    when 0
       stroke(style[i*2])
       no_fill
       stroke_weight(1)
       arc_line(0,0, pt[index],pt[index + 1],pt[index + 2])
       index += 3
-    elsif (style[i*2+1] == 1)
+    when 1
       fill(style[i*2])
       no_stroke
       arc_line_bars(0,0, pt[index],pt[index + 1],pt[index + 2])
@@ -113,7 +115,7 @@ def color_blended(fract, r, g, b, r2, g2, b2, a)
   r2 = (r2 - r)
   g2 = (g2 - g)
   b2 = (b2 - b)
-  return color(r + r2 * fract, g + g2 * fract, b + b2 * fract, a)
+  color(r + r2 * fract, g + g2 * fract, b + b2 * fract, a)
 end
 
 
@@ -124,7 +126,7 @@ def arc_line(x, y, deg, rad, w)
   (0 ... numlines).each do 
     begin_shape
     (0 ... a).each do |i|                 
-      vertex(cos(i.radians)*rad+x,sin(i.radians)*rad+y)
+      vertex(DegLut.cos(i)*rad+x,DegLut.sin(i)*rad+y)
     end
     end_shape 
     rad += 2        
@@ -136,21 +138,21 @@ def arc_line_bars(x, y, deg, rad, w)
   a=(deg < 360)? deg / 16 : 0   
   begin_shape(QUADS)
   (0 ... a).step(4) do |i|
-    vertex(cos(i.radians)*(rad)+x,sin(i.radians)*(rad)+y)
-    vertex(cos(i.radians)*(rad+w)+x,sin(i.radians)*(rad+w)+y)
-    vertex(cos((i + 2).radians)*(rad+w)+x,sin((i + 2).radians)*(rad+w)+y)
-    vertex(cos((i + 2).radians)*(rad)+x,sin((i + 2).radians)*(rad)+y)
+    vertex(DegLut.cos(i)*(rad)+x,DegLut.sin(i)*(rad)+y)
+    vertex(DegLut.cos(i)*(rad+w)+x,DegLut.sin(i)*(rad+w)+y)
+    vertex(DegLut.cos((i + 2))*(rad+w)+x,DegLut.sin((i + 2))*(rad+w)+y)
+    vertex(DegLut.cos((i + 2))*(rad)+x,DegLut.sin((i + 2))*(rad)+y)
   end
   end_shape
 end
   
 # Draw solid arc
-def arc(x,y,deg,rad,w) 
+def arc(x, y, deg, rad, w) 
   a = (deg < 360)? deg : 0
   begin_shape(QUAD_STRIP)
   (0 ... a).each do |i|
-    vertex(cos(i.radians)*(rad)+x,sin(i.radians)*(rad)+y)
-    vertex(cos(i.radians)*(rad+w)+x,sin(i.radians)*(rad+w)+y)
+    vertex(DegLut.cos(i)*(rad)+x,DegLut.sin(i)*(rad)+y)
+    vertex(DegLut.cos(i)*(rad+w)+x,DegLut.sin(i)*(rad+w)+y)
   end
   end_shape
 end

data/samples/processing_app/library/vecmath/{Rakefile → arcball/Rakefile}

@@ -1,20 +1,20 @@
 # Simple demo Rakefile to autorun samples in current directory
 # adjust path to rp5 executable, and or opts as required
 
-SAMPLES_DIR="./"
+SAMPLES_DIR = './'
 
 desc 'run demo'
-task :default => [:demo]
+task default: [:demo]
 
 desc 'demo'
 task :demo do
-  samples_list.shuffle.each{|sample| run_sample sample}
+  samples_list.shuffle.each{ |sample| run_sample sample }
 end
 
 def samples_list
   files = []
   Dir.chdir(SAMPLES_DIR)
-  Dir.glob("*.rb").each do |file|
+  Dir.glob('*.rb').each do |file|
     files << File.join(SAMPLES_DIR, file)
   end
   return files
@@ -22,9 +22,9 @@ end
 
 def run_sample(sample_name)
   puts "Running #{sample_name}...quit to run next sample"
-  open("|rp5 --nojruby run #{sample_name}", "r") do |io|
+  open("|rp5 run #{sample_name}", 'r') do |io|
     while l = io.gets
-      puts(l.chop) 
+      puts(l.chop)
     end      
   end
 end

data/samples/processing_app/library/vecmath/arcball/arcball_box.rb

@@ -0,0 +1,23 @@
+load_library :vecmath
+
+############################
+# Use mouse drag to rotate
+# the arcball. Use mousewheel
+# to zoom. Hold down x, y, z
+# to constrain rotation axis.
+############################
+
+def setup
+  size(600, 600, P3D)
+  smooth(16)
+  ArcBall.init(self, 300, 300)
+  fill 180
+end
+
+def draw
+  background(50)  
+  box(300, 300, 300)
+end
+
+
+

data/samples/processing_app/library/vecmath/arcball/arcball_radius.rb

@@ -0,0 +1,23 @@
+load_library :vecmath
+
+############################
+# Use mouse drag to rotate
+# the arcball. Use mousewheel
+# to zoom. Hold down x, y, z
+# to constrain rotation axis.
+############################
+
+def setup
+  size(600, 600, P3D)
+  smooth(16)
+  ArcBall.init(self, 300, 300, 250)
+  fill 180
+end
+
+def draw
+  background(50)  
+  box(300, 300, 300)
+end
+
+
+

data/samples/processing_app/library/vecmath/arcball/arcball_shape.rb

@@ -0,0 +1,29 @@
+load_library :vecmath
+
+attr_reader :my_cube
+
+def setup
+  size(600, 600, P3D)
+  smooth(16)
+  ArcBall.init(self)
+  @my_cube = create_shape(BOX, 400, 400, 400)
+  my_cube.set_fill(color(100, 10, 100))
+
+end
+
+def draw
+  background(50, 50, 100)
+  define_lights
+  lights
+  stroke(0)
+  shape(my_cube)
+end
+
+def define_lights
+  ambient(20, 20, 20)
+  ambient_light(50, 50, 50)
+  point_light(30, 30, 30, 200, -150, 0)
+  directional_light(0, 30, 50, 1, 0, 0)
+  spot_light(30, 30, 30, 0, 40, 200, 0, -0.5, -0.5, PI / 2, 2)
+end
+