ruby-processing 1.0.1

data/samples/flight_patterns.rb

@@ -0,0 +1,64 @@
+# Description:
+# Flight Patterns is that ol' Euruko 2008 demo.
+
+require 'ruby-processing'
+
+class FlightPatterns < Processing::App
+  load_libraries 'boids', 'opengl'
+  include_package "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
+    
+    @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
+  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
+  
+end
+
+FlightPatterns.new(:title => "Flight Patterns", :width => 1100, :height => 800, :full_screen => true)

data/samples/full_screen.rb

@@ -0,0 +1,35 @@
+# 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.
+
+require 'ruby-processing'
+
+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
+    end
+  end
+end
+
+FullScreen.new(:full_screen => true, :title => "Full Screen", :width => 600, :height => 600)

data/samples/getting_started.rb

@@ -0,0 +1,43 @@
+# 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
+
+  # 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
+    
+    translate width/2, height/2
+    rotate @rotation
+
+    fill 255
+    ellipse 0, -60, 20, 20
+
+    @rotation += 0.1
+  end
+  
+end
+
+# 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")

data/samples/jwishy.rb

@@ -0,0 +1,85 @@
+# This one has a long lineage:
+# It was originally adapted to Shoes in Ruby,
+# 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 
+# well as the background.
+
+# This example now demonstrates the use of the control_panel.
+
+# -- omygawshkenas
+
+require 'ruby-processing'
+
+class Sketch < Processing::App
+  load_libraries :control_panel, :net
+  
+  attr_accessor :x_wiggle, :y_wiggle, :magnitude, :bluish
+  
+  def setup
+    control_panel do |c|
+      c.slider    :bluish, 0.0..1.0
+      c.slider    :alpha,  0.0..1.0
+      c.checkbox  :go_big
+      c.button    :reset
+    end
+    
+    @x_wiggle, @y_wiggle = 10.0, 0
+    @magnitude = 8.15
+    @bluish = 0.9
+    @background = [0.06, 0.03, 0.18]
+    @alpha = 1.0
+    color_mode RGB, 1
+    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
+    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
+      oval(x-s/2, y-s/2, s, s)
+      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)

data/samples/kinetic_type.rb

@@ -0,0 +1,100 @@
+# From the Processing Examples
+# by Zach Lieberman
+# Ruby version thanks to Nick Sieger
+
+require 'ruby-processing'
+
+class KineticType < Processing::App
+  load_library :opengl
+
+  WORDS = ["sometimes it's like", "the lines of text", "are so happy", "that they want to dance",
+    "or leave the page or jump", "can you blame them?", "living on the page like that",
+    "waiting to be read..."]
+
+  def setup
+    library_loaded?(:opengl) ? render_mode(OPENGL) : render_mode(P3D)
+
+    frame_rate 30
+
+    # Array of line objects
+    @lns = [];
+
+    # Try to create the font from scratch. 
+    hint(ENABLE_NATIVE_FONTS)
+    f = create_font("Monospaced", 66)
+    text_font f, 1.0
+
+    # White type, black background
+    fill 255
+
+    # Creating the line objects
+    i = -1
+    @lines = WORDS.map do |ln|
+      i += 1
+      Line.new self, ln, 0, i * 70, f
+    end
+  end
+
+  def draw
+    background 0
+
+    translate (width / 2.0) - 350, (height / 2.0) - 240, -450
+    rotateY 0.3
+
+    # Now animate every line object & draw it...
+    @lines.each_with_index do |line,i|
+      f1 = sin((i + 1.0) * (millis() / 10000.0) * TWO_PI)
+      f2 = sin((8.0 - i) * (millis() / 10000.0) * TWO_PI)
+      push_matrix
+      translate 0.0, line.ypos, 0.0
+      0.upto(line.letters.length - 1) do |j|
+        if j != 0
+          translate(text_width(line.letters[j - 1].char)*75, 0.0, 0.0)
+        end
+        rotate_y(f1 * 0.035 * f2)
+        push_matrix
+        scale(75.0, 75.0, 75.0)
+        text(line.letters[j].char, 0.0, 0.0)
+        pop_matrix
+      end
+      pop_matrix
+    end
+  rescue => e
+    puts e.to_s, *e.backtrace
+    raise e
+  end
+
+  # Any class inheriting from this app object
+  # can use all the plain Processing calls.
+  class AppObject
+    attr_accessor :app
+    def method_missing(meth, *args, &block)
+      app.send(meth, *args, &block)
+    end
+  end
+
+  class Line < AppObject
+    attr_accessor :string, :xpos, :ypos, :highlight_num,
+      :font, :speed, :curl_in_x, :letters
+
+    def initialize(app, s, i, j, bagelfont)
+      @app, @string, @xpos, @ypos, @font = app, s, i, j, bagelfont
+      @letters = []
+      f1 = 0.0
+      s.each_byte do |c|
+        f1 += text_width c
+        @letters << Letter.new(c, f1, 0.0)
+      end
+      @curl_in_x = 0.1
+    end
+  end
+
+  class Letter
+    attr_accessor :char, :x, :y
+    def initialize(c, x, y)
+      @char, @x, @y = c, x, y
+    end
+  end
+end
+
+KineticType.new :width => 200, :height => 200, :title => "Kinetic Type"

data/samples/learning_processing/ABOUT

@@ -0,0 +1,11 @@
+"Learning Processing" is a 2008 book that serves as a gentle 
+introduction to the theory and practice of programming. It 
+works by introducing code concepts over the course of 23 
+chapters, and creating a series of examples that build on 
+the sketches that you write over the course of the book.
+
+"Learning Processing" is written by Daniel Shiffman of the 
+ITP in New York City.
+
+More information about the book can be found at:
+http://www.learningprocessing.com/

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

@@ -0,0 +1,34 @@
+# 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.
+
+# Hence, this line, which loads in Processing.
+require 'ruby-processing'
+
+# Here we begin to define the Sketch by making it a 
+# Processing App.
+class StrokeAndFill < Processing::App
+
+  # 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
+
+# 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

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

@@ -0,0 +1,25 @@
+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
+  
+end
+
+# The names of classes are still camel cased.
+NofillApp.new :title => "Nofill", :width => 200, :height => 200

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

@@ -0,0 +1,31 @@
+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
+
+RgbColor.new :title => "Rgb Color", :width => 200, :height => 200

data/samples/learning_processing/chapter_01/4_alpha_transparency.rb

@@ -0,0 +1,36 @@
+require 'ruby-processing'
+
+class AlphaTransparency < Processing::App
+
+  def setup
+    background 0 
+    no_stroke
+    
+    # No fourth argument means 100% opacity
+    fill 0, 0, 255
+    rect 0, 0, 100, 200
+    
+    # 255 means 100% opacity
+    fill 255, 0, 0, 255
+    rect 0, 0, 200, 40
+    
+    # 75% opacity
+    fill 255, 0, 0, 191
+    rect 0, 50, 200, 40
+    
+    # 55% opacity
+    fill 200, 0, 0, 127
+    rect 0, 100, 200, 40
+    
+    # 25% opacity
+    fill 255, 0, 0, 63
+    rect 0, 150, 200, 40
+  end
+  
+  def draw
+  
+  end
+  
+end
+
+AlphaTransparency.new :title => "Alpha Transparency", :width => 200, :height => 200