ruby-processing 1.0.11 → 2.4.1

data/samples/contributed/empathy.rb

@@ -11,6 +11,8 @@ ROTATION        = 0.004
 LINE_LENGTH     = 37
 MULTI_THREADED  = true
 
+attr_reader :cells
+
 def setup
   size(500, 500, P3D)
   stroke(0, 0, 0, 25)
@@ -22,19 +24,19 @@ def initialize_cells
   @cells  = []
   n = CELL_COUNT
   n.times do |i|
-    a = i + rand * (Math::PI / 9.0)
-    r = ((i / n.to_f) * (width / 2) * (((n - i) / n.to_f) * 3.3)) + (rand * 6)
-    @cells[i] = Cell.new((r * Math.cos(a) + width/2).to_i, (r * Math.sin(a) + height/2).to_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)
   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?
@@ -42,11 +44,11 @@ def started?
 end
 
 def mouse_pressed
-  @cells.each {|cell| cell.reset }
+  cells.each {|cell| cell.reset }
 end
 
 class Cell
-
+  attr_reader :x, :y, :spin, :angle
   def initialize(x, y)
     @x, @y  = x, y
     @spin   = 0
@@ -58,16 +60,16 @@ class Cell
   end
 
   def update
-    det = ((pmouse_x-@x) * (mouse_y-@y) - (mouse_x-@x) * (pmouse_y-@y)).to_f
-    @spin += ROTATION * det / dist(@x, @y, mouse_x, mouse_y).to_f
+    det = ((pmouse_x - x) * (mouse_y - y) - (mouse_x - x) * (pmouse_y - y)).to_f
+    @spin += ROTATION * det / dist(x, y, mouse_x, mouse_y).to_f
     @spin *= SLOW_DOWN
-    @angle += @spin
+    @angle += spin
   end
 
   def sense
     update unless MULTI_THREADED
-    d = LINE_LENGTH * @spin + 0.001
-    line(@x, @y, @x + d * Math.cos(@angle), @y + d * Math.sin(@angle))
+    d = LINE_LENGTH * spin + 0.001
+    line(x, y, x + d * cos(angle), y + d * sin(angle))
   end
 
 end

data/samples/contributed/fern.rb

@@ -16,7 +16,7 @@ def draw
   max_iterations = 200000
   
   max_iterations.times do
-    r = rand * 100
+    r = rand(100.0)
     if r <= 1
       x = 0.0
       y = 0.16 * y0

data/samples/contributed/fibonacci_sphere.rb

@@ -0,0 +1,125 @@
+# fibonacci_sphere.rb
+# After a vanilla processing sketch by Jim Bumgardner
+# http://www.openprocessing.org/sketch/41142
+#
+# Controls:
+# 1. drag mouse to rotate sphere (uses builtin arcball library)
+# 2. click mouse to toggle add box to sphere surface
+# 3. press x, y, or z to constrain arcball rotation to that axis
+#
+
+load_library :vecmath
+import "arcball"
+
+X = 0
+Y = 1
+Z = 2
+
+PHI = (sqrt(5)+1) / 2 - 1   # golden ratio
+GA = PHI * TWO_PI           # golden angle
+
+KMAX_POINTS = 100000
+
+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)
+  @rotation_x = 0
+  @rotation_y = 0
+  @nbr_points = 2000
+  @radius = 0.8 * height / 2
+  @add_points = true
+  @pts = Array.new(KMAX_POINTS)
+  init_sphere(nbr_points)
+  background(0)
+end
+
+def draw    
+  if add_points 
+    @nbr_points += 1
+    @nbr_points = min(nbr_points, KMAX_POINTS)
+    init_sphere(nbr_points)
+  end
+  
+  background 0            
+  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
+##################################
+
+def render_globe
+  push_matrix
+  (0 .. min(nbr_points, pts.length)).each do |i|    
+    lat = pts[i].lat 
+    lon = pts[i].lon    
+    push_matrix
+    rotate_y(lon)
+    rotate_z(-lat)
+    fill(200, 10, 10)
+    translate(radius, 0, 0)
+    box(4, 7, 7)
+    pop_matrix
+  end
+  pop_matrix  
+end
+
+def mouse_clicked
+  @add_points = !add_points
+end
+
+SpherePoint = Struct.new(:lat, :lon) do
+end
+
+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    
+    # Convert dome height (which is proportional to surface area) to latitude
+    # 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/flight_patterns.rb

@@ -1,13 +1,12 @@
 # Description:
 # Flight Patterns is that ol' Euruko 2008 demo.
+# Since processing 2.0 'ovals' don't look too hot
 
-full_screen
-load_libraries 'boids', 'opengl'
-import "processing.opengl" if library_loaded? "opengl"
+load_libraries 'boids'
 
 def setup
-  library_loaded?(:opengl) ? setup_opengl : render_mode(P3D)
-  sphere_detail 8
+  size(displayWidth, displayHeight, P3D)
+  sphere_detail 12
   color_mode RGB, 1.0
   no_stroke
   frame_rate 30
@@ -24,11 +23,6 @@ def setup
   end
 end
 
-def setup_opengl
-  render_mode(OPENGL)
-  hint ENABLE_OPENGL_4X_SMOOTH
-end
-
 def mouse_pressed
   @click = !@click
 end
@@ -37,13 +31,12 @@ def draw
   background 0.05
   ambient_light 0.01, 0.01, 0.01
   light_specular 0.4, 0.2, 0.2
-  point_light 1.0, 1.0, 1.0, mouse_x, mouse_y, 190
+  point_light 1.0, 1.0, 1.0, mouse_x, mouse_y, width / 4.0
   @flocks.each_with_index do |flock, i|
     flock.goal mouse_x, mouse_y, 0, @flee
-    flock.update(:goal => 185, :limit => 13.5)
+    flock.update(goal: 185, limit: 13.5)
     for boid in flock do
-      r = 20 + (boid.z * 0.15)
-      alpha = 0.5 + (boid.z * 0.01)
+      r = 20 + (boid.z * 0.15)      
       case i
       when 0 then fill 0.55, 0.35, 0.35
       when 1 then fill 0.35, 0.55, 0.35

data/samples/contributed/full_screen.rb

@@ -1,14 +1,12 @@
 # Description:
-# This full-screen demo can demonstrate the kinds of speedups 
-# that are possible with OpenGL-accelerated rendering. If you
-# have the OpenGL library installed, you'll get *much* 
-# smoother and faster drawing.
+# This is a full-screen demo 
+# Since processing-2.0 it is opengl
 
 full_screen
-load_library :opengl
+
 
 def setup
-  library_loaded?(:opengl) ? render_mode(OPENGL) : render_mode(P3D)
+  size 1000, 1000, P3D
   no_stroke
 end
 

data/samples/contributed/grapher.rb

@@ -0,0 +1,35 @@
+# Grapher is based on a context free art design
+# by ColorMeImpressed (takes a bit of time to run)
+# http://www.contextfreeart.org/gallery/view.php?id=2844
+#
+
+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    
+  no_stroke
+  color_mode(HSB, 1.0)
+  background(0)
+  frame_rate(4000)
+end
+
+def draw
+  translate(width/2, height/2)
+  dot(rand(-PI .. PI), rand(-PI .. PI), rand(CMIN .. CMAX)) unless frame_count > 200000
+end
+
+def dot(px, py, c)    
+  func = sin(px) + sin(py) + c
+  # change function to change the graph eg.
+  #func = sin(px) + tan(py) + c    
+  #func = cos(px) + 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
+  else
+    dot(rand(-PI .. PI), rand(-PI .. PI), rand(CMIN .. CMAX))
+  end
+end

data/samples/contributed/gravity.rb

@@ -3,14 +3,13 @@
 attr_reader :particles, :grabbed
 
 def setup
-  @particles  = []
-  @grabbed    = nil
-  
   size 600, 500
+  @particles  = []
+  @grabbed    = nil  
   background 0
   smooth
   stroke_weight 4
-  ellipse_mode CENTER_DIAMETER
+  ellipse_mode CENTER
   color_mode RGB, 255
 end
 
@@ -18,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 * 8 + 0.1)
 end
 
 def mouse_released
@@ -32,7 +31,7 @@ def mouse_released
 end
 
 def particle_grab
-  @grabbed = @particles.detect {|p| dist(mouse_x, mouse_y, p.x1, p.y1) < p.radius }
+  @grabbed = particles.detect {|p| dist(mouse_x, mouse_y, p.x1, p.y1) < p.diameter/2 }
 end
 
 
@@ -40,15 +39,14 @@ class Particle
   
   GRAVITY = 1.0
   
-  attr_reader :x0, :y0, :x1, :y1, :radius, :mass_amount
+  attr_reader :x0, :y0, :x1, :y1, :diameter, :mass_amount
   
   def initialize(x, y, mass)
     @x0, @y0, @x1, @y1  = x, y, x, y
     @x_speed, @y_speed  = 0, 0
     @x_accel, @y_accel  = 0, 0
     @mass_amount        = mass
-    @diameter           = Math.sqrt(@mass_amount) * 20
-    @radius             = @diameter / 2.0
+    @diameter           = sqrt(mass_amount) * 20
   end
   
   def collect_force
@@ -56,13 +54,13 @@ 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  = dist(x0, y0, p.x0, p.y0)
+      g_theta = -(angleOf(x0, y0, p.x0, p.y0)).radians
       @min_dist = g_dist if g_dist < @min_dist
-      force = (GRAVITY * @mass_amount * p.mass_amount) / g_dist
-      if g_dist.abs > @diameter
-        @x_accel += force / @mass_amount * Math.cos(g_theta)
-        @y_accel += force / @mass_amount * Math.sin(g_theta)
+      force = (GRAVITY * mass_amount * p.mass_amount) / g_dist
+      if g_dist.abs > diameter
+        @x_accel += force / mass_amount * cos(g_theta)
+        @y_accel += force / mass_amount * sin(g_theta)
       end
     end
   end
@@ -71,7 +69,7 @@ class Particle
     @x_speed, @y_speed = 0, 0 if grabbed?
     @x_speed += @x_accel
     @y_speed += @y_accel
-    @x1, @y1 = @x0 + @x_speed, @y0 + @y_speed
+    @x1, @y1 = x0 + @x_speed, y0 + @y_speed
   end
   
   def grabbed?
@@ -87,27 +85,27 @@ class Particle
     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_3   = @diameter + 8 + 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)
+    ellipse(x1, y1, tot_col_3, tot_col_3)
     fill 0, 255
     stroke tot_col_2, tot_col_2, 255, charge_col * 255 + 3
-    ellipse @x1, @y1, @diameter, @diameter
-    @x0, @y0 = @x1, @y1
+    ellipse x1, y1, diameter, diameter
+    @x0, @y0 = x1, y1
   end
   
   def render_grabbed
     fill 150, 150, 255, 100
-    ellipse mouse_x, mouse_y, @diameter + 8, @diameter + 8
+    ellipse mouse_x, mouse_y, diameter + 8, diameter + 8
     fill 0, 255
     stroke 150, 150, 255, 255
-    ellipse mouse_x, mouse_y, @diameter, @diameter
+    ellipse mouse_x, mouse_y, diameter, diameter
     @x0, @y0 = mouse_x, mouse_y
   end
   
   def angleOf(x1, y1, x2, y2)
     xd, yd = x1 - x2, y1 - y2
-    180 + (-(180 * Math.atan2(yd, xd)) / PI)
+    180 + (-(180 * atan2(yd, xd)) / PI)
   end
   
 end

data/samples/contributed/jwishy.rb

@@ -11,76 +11,88 @@
 
 # -- omygawshkenas
 
-class Sketch < Processing::App
-  load_library :control_panel
-  
-  attr_accessor :x_wiggle, :y_wiggle, :magnitude, :bluish
-  
-  def setup
-    control_panel do |c|
-      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']
-    end
-    
-    @shape = 'oval'
-    @alpha, @bluish = 0.5, 0.5
-    @x_wiggle, @y_wiggle = 10.0, 0
-    @magnitude = 8.15
-    @background = [0.06, 0.03, 0.18]
-    color_mode RGB, 1
-    ellipse_mode CORNER
-    smooth
+load_library :control_panel
+
+attr_accessor :x_wiggle, :y_wiggle, :magnitude, :bluish, :panel, :laf, :hide  
+
+def setup
+  size 600, 600  
+  @show = false
+  control_panel do |c|
+    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']
+    @panel = c
   end
+  @hide = false
   
-  def background=(*args)
-    @background = args.flatten
+  @shape = 'oval'
+  @alpha, @bluish = 0.5, 0.5
+  @x_wiggle, @y_wiggle = 10.0, 0
+  @magnitude = 8.15
+  @background = [0.06, 0.03, 0.18]
+  color_mode RGB, 1
+  ellipse_mode CORNER
+  smooth
+end
+
+def background=(*args)
+  @background = args.flatten
+end
+
+
+def draw_background
+  @background[3] = @alpha
+  fill *@background if @background[0]
+  rect 0, 0, width, height
+end
+
+def reset
+  @y_wiggle = 0
+end
+
+def draw
+  # only make control_panel visible once, or again when hide is false
+  unless hide
+    @hide = true
+    panel.setVisible(hide)    
   end
+  draw_background
   
-  def draw_background
-    @background[3] = @alpha
-    fill *@background if @background[0]
-    rect 0, 0, width, height
+  # 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
   
-  def reset
-    @y_wiggle = 0
+  blu = bluish
+  x, y = (self.width / 2), -27
+  c = 0.0
+  
+  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]
+    @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
 
-  def draw
-    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
-    c = 0.0
-    
-    64.times do |i|
-      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]
-      @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
 end
 
-# Try setting full screen to true.
-Sketch.new(:width => 600, :height => 600, :title => "WishyWorm", :full_screen => false)
+def mouse_pressed
+  @hide = false if hide
+end
+