ruby-processing 1.0.3 → 1.0.4

data/samples/bezier_playground.rb

@@ -1,10 +1,7 @@
-require 'ruby-processing'
-
 # A Bezier playground. Click to shape the curve. Drag to move it.
 # Arrows toggle between curves, delete removes them.
 # You can print out the parametric equations for t = 0..1
 
-
 module Math
   
   def self.overlaps(x, y, point_x, point_y)
@@ -75,6 +72,7 @@ class Bezier < Processing::App
   load_library :control_panel
 
   def setup
+    size 700, 700
     smooth
     @curves = []
     
@@ -240,4 +238,4 @@ class Bezier < Processing::App
   
 end
 
-Bezier.new :title => "Bezier", :width => 700, :height => 700
+Bezier.new

data/samples/fern.rb

@@ -1,49 +1,41 @@
 # The Fern Fractal
 # by Luis Correia
-#
-# port by omygawshkenas
-
-require 'ruby-processing'
+  
+def setup
+  size 500, 500
+  no_loop
+  puts "Be patient. This takes about 10 seconds to render."
+end
 
-class Fern < Processing::App
+def draw
+  background 0
+  load_pixels
+  x0, y0 = 0.0, 0.0
+  x, y, r = 0.0, 0.0, 0.0
+  i, j = 0, 0
+  max_iterations = 200000
   
-  def setup
-    no_loop
-    puts "Be patient. This takes about 10 seconds to render."
-  end
- 
-  def draw
-    background 0
-    load_pixels
-    x0, y0 = 0.0, 0.0
-    x, y, r = 0.0, 0.0, 0.0
-    i, j = 0, 0
-    max_iterations = 200000
-    
-    max_iterations.times do
-      r = rand * 100
-      if r <= 1
-        x = 0.0
-        y = 0.16 * y0
-      elsif r <= 7
-        x = 0.2 * x0 - 0.26 * y0
-        y = 0.23 * x0 + 0.22 * y0
-      elsif r <= 14
-        x = -0.15 * x0 + 0.28 * y0
-        y = 0.26 * x0 + 0.24 * y0
-      else 
-        x = 0.85 * x0 + 0.04 * y0
-        y = -0.004 * x0 + 0.85 * y0 + 1.6
-      end
-      
-      i = height - (y * 45).to_i
-      j = width / 2 + (x * 45).to_i
-      pixels[i * height + j] += 2560 if (i >=0 && i < height && j >= 0 && j < width)
-      x0, y0 = x, y
+  max_iterations.times do
+    r = rand * 100
+    if r <= 1
+      x = 0.0
+      y = 0.16 * y0
+    elsif r <= 7
+      x = 0.2 * x0 - 0.26 * y0
+      y = 0.23 * x0 + 0.22 * y0
+    elsif r <= 14
+      x = -0.15 * x0 + 0.28 * y0
+      y = 0.26 * x0 + 0.24 * y0
+    else 
+      x = 0.85 * x0 + 0.04 * y0
+      y = -0.004 * x0 + 0.85 * y0 + 1.6
     end
     
-    update_pixels
+    i = height - (y * 45).to_i
+    j = width / 2 + (x * 45).to_i
+    pixels[i * height + j] += 2560 if (i >=0 && i < height && j >= 0 && j < width)
+    x0, y0 = x, y
   end
-end
-
-Fern.new :title => "Fern", :width => 500, :height => 500
+  
+  update_pixels
+end

data/samples/flight_patterns.rb

@@ -1,64 +1,58 @@
 # Description:
 # Flight Patterns is that ol' Euruko 2008 demo.
 
-require 'ruby-processing'
+full_screen
+load_libraries 'boids', 'opengl'
+import "processing.opengl" if library_loaded? "opengl"
 
-class FlightPatterns < Processing::App
-  load_libraries 'boids', 'opengl'
-  import "processing.opengl" if library_loaded? "opengl"
+def setup
+  library_loaded?(:opengl) ? setup_opengl : render_mode(P3D)
+  sphere_detail 8
+  color_mode RGB, 1.0
+  no_stroke
+  frame_rate 30
+  shininess 1.0
+  specular 0.3, 0.1, 0.1
+  emissive 0.03, 0.03, 0.1
   
-  def setup
-    library_loaded?(:opengl) ? setup_opengl : render_mode(P3D)
-    sphere_detail 8
-    color_mode RGB, 1.0
-    no_stroke
-    frame_rate 30
-    shininess 1.0
-    specular 0.3, 0.1, 0.1
-    emissive 0.03, 0.03, 0.1
-    
-    @click = false
-    @flocks = []
-    3.times do |i|
-      flock = Boids.flock 20, 0, 0, width, height
-      flock.goal width/2, height/2, 0
-      @flocks << flock
-    end
-  end
-  
-  def setup_opengl
-    render_mode OPENGL
-    hint ENABLE_OPENGL_4X_SMOOTH
+  @click = false
+  @flocks = []
+  3.times do |i|
+    flock = Boids.flock 20, 0, 0, width, height
+    flock.goal width/2, height/2, 0
+    @flocks << flock
   end
-  
-  def mouse_pressed
-    @click = !@click
-  end
-  
-  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
-    @flocks.each_with_index do |flock, i|
-      flock.goal mouse_x, mouse_y, 0, @flee
-      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)
-        case i
-        when 0 then fill 0.55, 0.35, 0.35
-        when 1 then fill 0.35, 0.55, 0.35
-        when 2 then fill 0.35, 0.35, 0.55
-        end
-        push_matrix
-        translate boid.x-r/2, boid.y-r/2, boid.z-r/2
-        @click ? sphere(r/2) : oval(0, 0, r, r)
-        pop_matrix
+end
+
+def setup_opengl
+  render_mode(OPENGL)
+  hint ENABLE_OPENGL_4X_SMOOTH
+end
+
+def mouse_pressed
+  @click = !@click
+end
+
+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
+  @flocks.each_with_index do |flock, i|
+    flock.goal mouse_x, mouse_y, 0, @flee
+    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)
+      case i
+      when 0 then fill 0.55, 0.35, 0.35
+      when 1 then fill 0.35, 0.55, 0.35
+      when 2 then fill 0.35, 0.35, 0.55
       end
+      push_matrix
+      translate boid.x-r/2, boid.y-r/2, boid.z-r/2
+      @click ? sphere(r/2) : oval(0, 0, r, r)
+      pop_matrix
     end
   end
-  
 end
-
-FlightPatterns.new(:title => "Flight Patterns", :width => 1100, :height => 800, :full_screen => true)

data/samples/full_screen.rb

@@ -4,32 +4,27 @@
 # have the OpenGL library installed, you'll get *much* 
 # smoother and faster drawing.
 
-require 'ruby-processing'
+full_screen
+load_library :opengl
 
-class FullScreen < Processing::App
-  load_library :opengl
-  
-  def setup
-    library_loaded?(:opengl) ? render_mode(OPENGL) : render_mode(P3D)
-    no_stroke
-  end
-  
-  def draw
-    lights
-    background 0
-    fill 120, 160, 220
-    (width/100).times do |x|
-      (height/100).times do |y|
-        new_x, new_y = x * 100, y * 100
-        push_matrix
-        translate new_x + 50, new_y + 50
-        rotate_y(((mouse_x.to_f + new_x) / width) * Math::PI)
-        rotate_x(((mouse_y.to_f + new_y) / height) * Math::PI)
-        box 90
-        pop_matrix
-      end
+def setup
+  library_loaded?(:opengl) ? render_mode(OPENGL) : render_mode(P3D)
+  no_stroke
+end
+
+def draw
+  lights
+  background 0
+  fill 120, 160, 220
+  (width/100).times do |x|
+    (height/100).times do |y|
+      new_x, new_y = x * 100, y * 100
+      push_matrix
+      translate new_x + 50, new_y + 50
+      rotate_y(((mouse_x.to_f + new_x) / width) * Math::PI)
+      rotate_x(((mouse_y.to_f + new_y) / height) * Math::PI)
+      box 90
+      pop_matrix
     end
   end
 end
-
-FullScreen.new(:full_screen => true, :title => "Full Screen", :width => 600, :height => 600)

data/samples/getting_started.rb

@@ -1,43 +1,23 @@
-# So, let's get started: The first thing you may notice is
-# that there is a bunch more code around the edges here 
-# than in vanilla Processing sketches. Ruby-Processing
-# doesn't perform any special code munging or pre-processing, 
-# so what you see here is *just Ruby* taking advantage
-# of the Processing library.
-
-# Hence, this line, which loads in Processing.
-require 'ruby-processing'
-
-# Here we begin to define the Sketch by making it a 
-# Processing App.
-class SampleApplication < Processing::App
+# Let's define a setup method, for code that gets
+# run one time when the app is started.
+def setup
+  background 0
+  no_stroke
+  smooth
+  @rotation = 0
+end
 
-  # Now we define a setup method, for code that gets
-  # run one time when the app is started.
-  def setup
-    background 0
-    no_stroke
-    smooth
-    @rotation = 0
-  end
+# And the draw method which will be called repeatedly.
+# Delete this if you don't need animation.
+def draw
+  fill 0, 20
+  rect 0, 0, width, height
   
-  # And the draw method which will be called repeatedly.
-  # Delete this if you don't need animation.
-  def draw
-    fill 0, 20
-    rect 0, 0, width, height
-    
-    translate width/2, height/2
-    rotate @rotation
+  translate width/2, height/2
+  rotate @rotation
 
-    fill 255
-    ellipse 0, -60, 20, 20
-
-    @rotation += 0.1
-  end
-  
-end
+  fill 255
+  ellipse 0, -60, 20, 20
 
-# Now that the sketch is defined, we can start one up.
-# The following line does this, passing in the title, width, and height.
-SampleApplication.new(:width => 200, :height => 200, :title => "SampleApplication")
+  @rotation += 0.1
+end

data/samples/learning_processing/chapter_01/1_stroke_and_fill.rb

@@ -1,34 +1,18 @@
-# So, let's get started: The first thing you may notice is
-# that there is a bunch more code around the edges here 
-# than in the Learning Processing example. Ruby-Processing
-# doesn't perform any special munging or pre-processing, 
-# so what you see here is *just Ruby* taking advantage
-# of the Processing library.
+# This is the simplest form of a Ruby-Processing sketch. A simple sequence
+# of instructions that are run a single time to paint a picture.
 
-# Hence, this line, which loads in Processing.
-require 'ruby-processing'
+# Stretch the canvas to 200 pixels wide by 200 pixels tall.
+size 200, 200
 
-# Here we begin to define the Sketch by making it a 
-# Processing App.
-class StrokeAndFill < Processing::App
+# Paint the background white.
+background 255
 
-  # Now we define a setup method, for code that gets
-  # run one time when the app is started.
-  def setup
-    background 255
-    stroke 0
-    fill 150
-    rect 50, 50, 75, 100    
-  end
-  
-  # And the draw method has nothing inside of it.
-  # If it did, the code inside would be run repeatedly.
-  def draw
-  
-  end
-  
-end
+# Set the color of strokes to black.
+stroke 0
 
-# Now that the sketch is defined, we can start one up.
-# The following line does this, passing in the title, width, and height.
-StrokeAndFill.new :title => "Stroke And Fill", :width => 200, :height => 200
+# Set the color of fills to middle gray.
+fill 150
+
+# Draw a rectangle 50 pixels over and 50 pixels down from the top left corner,
+# with a width of 75 pixels and a height of 100.
+rect 50, 50, 75, 100

data/samples/learning_processing/chapter_01/2_nofill.rb

@@ -1,25 +1,20 @@
-require 'ruby-processing'
-
-class NofillApp < Processing::App
-
-  def setup
-    smooth
-    background 255
-    # In Ruby, methods and variables are under_scored instead of camelCased
-    no_fill
-    stroke 0
-    # You might notice that there are no parenthesis or semicolons.
-    # That's because they're optional.
-    ellipse 60, 60, 100, 100
-    # This line works too:
-    ellipse(60, 60, 100, 100);
-  end
-  
-  def draw
-  
-  end
-  
+# Here we introduce a slightly more sophisticated version of a Ruby-Processing
+# sketch. The code inside of the setup is run a single time, at the beginning.
+def setup
+  size 200, 200
+  smooth
+  background 255
+  # In Ruby, methods and variables are under_scored instead of camelCased
+  no_fill
+  stroke 0
+  # You might notice that there are no parenthesis or semicolons.
+  # That's because they're optional.
+  ellipse 60, 60, 100, 100
+  # This line works too:
+  ellipse(60, 60, 100, 100);
 end
 
-# The names of classes are still camel cased.
-NofillApp.new :title => "Nofill", :width => 200, :height => 200
+# And the code inside of draw, if there were any, would be drawn over and over.
+def draw
+  
+end

data/samples/learning_processing/chapter_01/3_rgb_color.rb

@@ -1,31 +1,19 @@
-require 'ruby-processing'
-
 # RGB color is specified by intensity of red, then green, then blue.
-class RgbColor < Processing::App
 
-  def setup
-    smooth
-    
-    background 255
-    no_stroke
-    
-    # Bright red
-    fill 255, 0, 0
-    ellipse 20, 20, 16, 16
-    
-    # Dark red
-    fill 127, 0, 0
-    ellipse 40, 20, 16, 16
-    
-    # Pink
-    fill 255, 200, 200
-    ellipse 60, 20, 16, 16
-  end
-  
-  def draw
-  
-  end
-  
-end
+size 200, 200
+smooth
+
+background 255
+no_stroke
+
+# Bright red
+fill 255, 0, 0
+ellipse 20, 20, 16, 16
+
+# Dark red
+fill 127, 0, 0
+ellipse 40, 20, 16, 16
 
-RgbColor.new :title => "Rgb Color", :width => 200, :height => 200
+# Pink
+fill 255, 200, 200
+ellipse 60, 20, 16, 16