ruby-processing 1.0.1 → 1.0.2

data/CHANGELOG

@@ -1,3 +1,9 @@
+v1.0.2 Bugfixes and Java Args...
+  * Application exporting, long plagued, should now be a little
+    closer to rock-solid. If you need to pass command-line options
+    to the JVM, add a java_args.txt file in your sketch's data 
+    folder that sets stack size, memory size, or whatever ails you.
+
 v1.0.1 Gemmin' it up.
   * The smallest version bump is the biggest change:
     Ruby-Processing has undergone a great refactor, kicked off by

data/lib/ruby-processing.rb

@@ -11,7 +11,7 @@ require 'ruby-processing/helpers/string'
 
 # The top-level namespace, a home for all Ruby-Processing classes.
 module Processing
-  VERSION = [1,0,1]
+  VERSION = [1,0,2]
   
   # Returns the current version of Ruby-Processing.
   def self.version

data/lib/ruby-processing/app.rb

@@ -22,6 +22,11 @@ module Processing
 
     include_class "javax.swing.JFrame"
     
+    # Include some processing classes that we'd like to use:
+    %w(PShape PImage PGraphics PFont PVector).each do |klass|
+      include_class "processing.core.#{klass}"
+    end
+        
     # Alias some methods for familiarity for Shoes coders.
     attr_accessor :frame, :title
     alias_method :oval, :ellipse
@@ -52,7 +57,7 @@ module Processing
 
     # Class methods that we should make available in the instance.
     [:map, :pow, :norm, :lerp, :second, :minute, :hour, :day, :month, :year, 
-     :sq, :constrain, :dist, :blend_color].each do |meth|
+     :sq, :constrain, :dist, :blend_color, :degrees, :radians, :mag].each do |meth|
       method = <<-EOS
         def #{meth}(*args)
           self.class.#{meth}(*args)
@@ -91,6 +96,7 @@ module Processing
     end
     def self.load_library(*args); self.load_libraries(*args); end
 
+
     # For pure ruby libraries.
     # The library should have an initialization ruby file 
     # of the same name as the library folder.
@@ -184,7 +190,9 @@ module Processing
     # If you'd like to do something fancy, feel free.
     def set_sketch_path(path=nil)
       field = self.java_class.declared_field('sketchPath')
-      field.set_value(Java.ruby_to_java(self), path || File.dirname(SKETCH_PATH))
+      local = File.dirname(SKETCH_PATH)
+      default = $__windows_app_mode__ ? "#{local}/lib" : local
+      field.set_value(Java.ruby_to_java(self), path || default)
     end
 
 

data/lib/ruby-processing/exporters/base_exporter.rb

@@ -63,9 +63,9 @@ module Processing
       libs = []
       code = source.dup
       loop do
-        matchdata = code.match(/load_\w+_library.+?["':](\S+?)["'\s]/)
+        matchdata = code.match(/load\w+librar(y|ies).+?["':](\S+?)["'\s]/)
         break unless matchdata
-        match = matchdata[1]
+        match = matchdata[2]
         @opengl = true if match.match(/opengl/i)
         local_path = "#{local_dir}/library/#{match}"
         rp5_path = "#{RP5_ROOT}/library/#{match}"

data/lib/ruby-processing/runner.rb

@@ -117,13 +117,22 @@ module Processing
     
     # Trade in this Ruby instance for a JRuby instance, loading in a 
     # starter script and passing it some arguments.
-    def spin_up(starter_script, args)
+    def spin_up(starter_script, sketch)
       runner = "#{RP5_ROOT}/lib/ruby-processing/runners/#{starter_script}"
-      command = "java -cp #{jruby_complete} #{dock_icon} org.jruby.Main #{runner} #{args}"
+      java_args = discover_java_args(sketch)
+      command = "java #{java_args} -cp #{jruby_complete} #{dock_icon} org.jruby.Main #{runner} #{sketch}"
       exec(command)
       # exec replaces the Ruby process with the JRuby one.
     end
     
+    # If you need to pass in arguments to Java, such as the ones on this page:
+    # http://java.sun.com/j2se/1.4.2/docs/tooldocs/windows/java.html
+    # then type them into a java_args.txt in your data directory next to your sketch.
+    def discover_java_args(sketch)
+      arg_file = "#{File.dirname(sketch)}/data/java_args.txt"
+      File.exists?(arg_file) ? File.read(arg_file).gsub("\n", " ") : ''
+    end
+    
     def ensure_exists(sketch)
       puts "Couldn't find: #{sketch}" and exit unless File.exists?(sketch)
     end

data/lib/ruby-processing/runners/run.rb

@@ -1,5 +1,10 @@
 # Windows apps start life in the wrong folder.
-ARGV[1] = nil and Dir.chdir('lib') if ARGV[1] == '--windows-app'
+# TODO: Fix this crud as soon as possible.
+if ARGV[1] == '--windows-app'
+  ARGV[1] = nil
+  Dir.chdir('lib')
+  $__windows_app_mode__ = true
+end
 
 require "#{File.dirname(__FILE__)}/base.rb"
 require Processing::SKETCH_PATH

data/samples/processing_app/3D/camera/ortho_vs_perspective.rb

@@ -0,0 +1,46 @@
+require 'ruby-processing'
+
+# Click to see the difference between orthographic projection
+# and perspective projection as applied to a simple box.
+# The ortho function sets an orthographic projection and 
+# defines a parallel clipping volume. All objects with the 
+# same dimension appear the same size, regardless of whether 
+# they are near or far from the camera. The parameters to this 
+# function specify the clipping volume where left and right 
+# are the minimum and maximum x values, top and bottom are the 
+# minimum and maximum y values, and near and far are the minimum 
+# and maximum z values.
+
+class OrthoVsPerspective < Processing::App
+
+  def setup
+    render_mode P3D
+    no_stroke
+    fill 204
+  end
+  
+  def draw
+    background 0
+    lights
+    
+    mouse_pressed? ? show_perspective : show_orthographic
+    
+    translate width/2, height/2, 0
+    rotate_x -PI/6
+    rotate_y PI/3
+    box 160
+  end
+  
+  def show_perspective
+    fov = PI/3.0
+    camera_z = (height/2.0) / tan(PI * fov / 360.0)
+    perspective fov, width.to_f/height.to_f, camera_z/2.0, camera_z*2.0
+  end
+  
+  def show_orthographic
+    ortho -width/2, width/2, -height/2, height/2, -10, 10
+  end
+  
+end
+
+OrthoVsPerspective.new :title => "Ortho Vs Perspective", :width => 640, :height => 360

data/samples/processing_app/3D/camera/perspective.rb

@@ -0,0 +1,44 @@
+require 'ruby-processing'
+
+# Move the mouse left and right to change the field of view (fov).
+# Click to modify the aspect ratio. The perspective method
+# sets a perspective projection applying foreshortening, making 
+# distant objects appear smaller than closer ones. The parameters 
+# define a viewing volume with the shape of truncated pyramid. 
+# Objects near to the front of the volume appear their actual size, 
+# while farther objects appear smaller. This projection simulates 
+# the perspective of the world more accurately than orthographic projection. 
+# The version of perspective without parameters sets the default 
+# perspective and the version with four parameters allows the programmer 
+# to set the area precisely.
+
+class Perspective < Processing::App
+
+  def setup
+    render_mode P3D
+    no_stroke
+  end
+  
+  def draw
+    lights
+    background 204
+    camera_y = height/2.0
+    fov = mouse_x/width.to_f * PI/2.0
+    camera_z = camera_y / tan(fov / 2.0)
+    aspect = width.to_f / height.to_f
+    
+    aspect /= 2.0 if mouse_pressed?
+    
+    perspective(fov, aspect, camera_z/10.0, camera_z*10.0)
+    
+    translate width/2.0+30, height/2.0, 0
+    rotate_x -PI/6
+    rotate_y PI/3 + mouse_y/height.to_f * PI
+    box 45
+    translate 0, 0, -50
+    box 30
+  end
+  
+end
+
+Perspective.new :title => "Perspective", :width => 640, :height => 360

data/samples/processing_app/3D/form/brick_tower.rb

@@ -0,0 +1,94 @@
+require 'ruby-processing'
+
+# Original by Ira Greenberg
+
+# 3D castle tower constructed out of individual bricks.
+# Uses the PVecor and Cube classes.
+ 
+class BrickTower < Processing::App
+
+  def setup
+    @bricks_per_layer = 16
+    @brick_layers = 18
+    @brick_width, @brick_height, @brick_depth = 60, 25, 25
+    @radius = 175.0
+    @angle = 0
+    render_mode P3D
+    @brick = Cubeish.new(@brick_width, @brick_height, @brick_depth)
+  end
+  
+  def draw
+    background 0
+    @temp_x, @temp_y, @temp_z = 0, 0, 0
+    fill 182, 62, 29
+    no_stroke
+    lights
+    translate(width/2.0, height*1.2, -380)                  # move viewpoint into position
+    rotate_x(radians(-45))                                  # tip tower to see inside
+    rotate_y(frame_count * PI/600)                          # slowly rotate tower
+    @brick_layers.times {|i| draw_layer(i) }
+  end
+  
+  def draw_layer(layer_num)
+    @layer_num = layer_num
+    @temp_y -= @brick_height                                # increment rows                 
+    @angle = 360.0 / @bricks_per_layer * @layer_num / 2.0   # alternate brick seams
+    @bricks_per_layer.times {|i| draw_bricks(i) }
+  end
+  
+  def draw_bricks(brick_num)
+    @brick_num = brick_num
+    @temp_z = cos(radians(@angle)) * @radius
+    @temp_x = sin(radians(@angle)) * @radius
+    push_matrix
+    translate @temp_x, @temp_y, @temp_z
+    rotate_y(radians(@angle))
+    top_layer = @layer_num == @brick_layers - 1
+    even_brick = @brick_num % 2 == 0
+    @brick.create unless top_layer                          # main tower
+    @brick.create if top_layer && even_brick                # add crenelation
+    pop_matrix
+    @angle += 360.0 / @bricks_per_layer
+  end
+end
+
+
+# The Cubeish class works a little different than the cube in the
+# Processing example. SIDES tells you where the negative numbers go.
+# We dynamically create each of the PVectors by passing in the
+# appropriate signs.
+class Cubeish
+  SIDES = {:front  => ['-- ', ' - ', '   ', '-  '],
+           :left   => ['-- ', '---', '- -', '-  '],
+           :right  => [' - ', ' --', '  -', '   '],
+           :back   => ['---', ' --', '  -', '- -'],
+           :top    => ['-- ', '---', ' --', ' - '],
+           :bottom => ['-  ', '- -', '  -', '   ']}
+           
+  SIGNS = {'-' => -1, 
+           ' ' =>  1}
+  
+  def initialize(width, height, depth)
+    @vertices = {}
+    @w, @h, @d = width, height, depth
+    
+    SIDES.each do |side, signs|
+      @vertices[side] = signs.map do |s|
+        s = s.split('').map {|el| SIGNS[el] }
+        Processing::PVector.new(s[0]*@w/2, s[1]*@h/2, s[2]*@d/2)
+      end
+    end
+  end
+  
+  def create
+    @vertices.each do |name, vectors|
+      $app.begin_shape BrickTower::QUADS
+      vectors.each {|v| $app.vertex(v.x, v.y, v.z) }
+      $app.end_shape
+    end
+  end
+  
+end
+
+
+BrickTower.new :title => "Brick Tower", :width => 640, :height => 360

data/samples/processing_app/3D/typography/kinetic_type.rb

@@ -0,0 +1,79 @@
+# 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
+    # Load the font from the sketch's data directory.
+    text_font load_font("Univers66.vlw.gz"), 1.0
+    fill 255
+
+    # Creating the line objects
+    @lines = Array.new(WORDS.length) do |i|
+      Line.new(WORDS[i], 0, i*70)
+    end
+  end
+
+  def draw
+    background 0
+    translate -240, -120, -450
+    rotate_y 0.3
+    # Now animate every line object & draw it...
+    @lines.each_with_index do |line, i| 
+      push_matrix
+      translate 0.0, line.ypos, 0.0
+      line.draw(i)
+      pop_matrix
+    end
+  end
+end
+
+class Line
+  include Math
+  attr_accessor :string, :xpos, :ypos, :letters
+
+  def initialize(string, x, y)
+    @string, @xpos, @ypos = string, x, y
+    spacing = 0.0
+    @letters = @string.split('').map do |c|
+      spacing += $app.text_width(c)
+      Letter.new(c, spacing, 0.0)
+    end
+  end
+  
+  def compute_curve(line_num)
+    base = $app.millis / 10000.0 * PI * 2
+    sin((line_num + 1.0) * base) * sin((8.0 - line_num) * base)
+  end
+  
+  def draw(line_num)
+    curve = compute_curve(line_num)
+    @letters.each_with_index do |letter, i|
+      $app.translate($app.text_width(@letters[i-1].char)*75, 0.0, 0.0) if i > 0
+      $app.rotate_y(curve * 0.035)
+      $app.push_matrix
+      $app.scale(75.0, 75.0, 75.0)
+      $app.text(letter.char, 0.0, 0.0)
+      $app.pop_matrix
+    end
+  end
+end
+
+class Letter
+  attr_accessor :char, :x, :y
+  def initialize(c, x, y)
+    @char, @x, @y = c, x, y
+  end
+end
+
+KineticType.new :width => 200, :height => 200, :title => "Kinetic Type"

data/samples/processing_app/ABOUT

@@ -0,0 +1,3 @@
+Here lie a scattering of examples that come with the Processing download.
+They are categorized by kind, and some of the code has been converted 
+into more idiomatic Ruby.

data/samples/processing_app/topics/effects/lens.rb

@@ -0,0 +1,95 @@
+require 'ruby-processing'
+
+# Original by luis2048
+
+# A picture is shown and it looks like a magnifying glass 
+# is drawn over the picture. One of the most famous demos 
+# that has a lens effect is 2nd reality by future crew.
+# The trick is to precalculate the entire effect. Just make 
+# an array that for each pixel in the destination picture 
+# tells which pixel to take from the source picture. This 
+# array is called the transformation array. The tricky part 
+# is to calculate the transformation array to make the 
+# destination look like a lens is beeing held over the source 
+# picture. Based on lens formula by on Abe Racadabra.
+
+class Lens < Processing::App
+
+  def setup
+    @lens_d            = 160
+    @lens_list         = []
+    @xx, @yy, @dx, @dy = 0, 0, 3, 3
+    
+    # Create buffered image for lens effect.
+    @lens_effect = create_graphics(width, height, P2D)
+    
+    # Load background image.
+    @lens_effect.begin_draw
+    @lens_effect.image(load_image('red_smoke.jpg'), 0, 0, width, height)
+    @lens_effect.end_draw
+    image(@lens_effect, 0, 0, width, height)
+    
+    # Create buffered image for warping.
+    @lens_image  = create_graphics(@lens_d, @lens_d, P2D)
+    @lens_image2 = create_graphics(@lens_d, @lens_d, P2D)
+    
+    compute_lens_transformation
+  end
+  
+  def compute_lens_transformation
+    mag_factor = 40
+    m, a, b    = 0, 0, 0
+    r          = @lens_d / 2
+    s          = sqrt(r*r - mag_factor*mag_factor)
+    
+    for y in (-r...r)
+      for x in (-r..r)
+        if (x*x + y*y >= s*s)
+          a, b = x, y
+        else
+          z = sqrt(r*r - x*x - y*y)
+          a = (x * mag_factor / z + 0.5).to_i
+          b = (y * mag_factor / z + 0.5).to_i
+        end
+        @lens_list[(y+r) * @lens_d + (x+r)] = (b+r) * @lens_d + (a+r)
+      end
+    end
+  end
+  
+  def bounce_lens
+    @dx = -@dx if (@xx+@dx+@lens_d > @lens_effect.width)  || (@xx+@dx < 0)
+    @dy = -@dy if (@yy+@dy+@lens_d > @lens_effect.height) || (@yy+@dy < 0)
+  end
+  
+  def move_lens
+    @xx += @dx
+    @yy += @dy
+  end
+  
+  def draw
+    bounce_lens
+    move_lens
+        
+    # Save the background of image at the coordinate where the
+    # lens effect will be applied.
+    @lens_image2.copy(@lens_effect, @xx, @yy, @lens_d, @lens_d, 0, 0, @lens_d, @lens_d)
+    
+    # Output into a buffered image for reuse.
+    @lens_image.load_pixels
+    
+    # For each pixel in the destination, apply the color from the 
+    # appropriate pixel in the saved background. The @lens_list array
+    # tells us the appropriate offset.
+    # This inner loop has been optimized a bit.
+    px, px2  = @lens_image.pixels, @lens_image2.pixels
+    list     = @lens_list
+    px.length.times {|i| px[i] = px2[list[i]] }
+    @lens_image.update_pixels
+    
+    # Overlay the lens
+    image(@lens_image, @xx, @yy, @lens_d, @lens_d)
+  end
+  
+end
+
+Lens.new :title => "Lens", :width => 640, :height => 360

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ruby-processing
 version: !ruby/object:Gem::Version 
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors: 
 - Jeremy Ashkenas
@@ -12,7 +12,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-17 00:00:00 -05:00
+date: 2009-01-20 00:00:00 -05:00
 default_executable: rp5
 dependencies: []
 
@@ -183,7 +183,6 @@ files:
 - samples/full_screen.rb
 - samples/getting_started.rb
 - samples/jwishy.rb
-- samples/kinetic_type.rb
 - samples/learning_processing
 - samples/learning_processing/ABOUT
 - samples/learning_processing/chapter_01
@@ -307,6 +306,23 @@ files:
 - samples/learning_processing/chapter_16
 - samples/learning_processing/chapter_16/01_display_video.rb
 - samples/learning_processing/chapter_16/02_manipulate_video_image.rb
+- samples/processing_app
+- samples/processing_app/3D
+- samples/processing_app/3D/camera
+- samples/processing_app/3D/camera/ortho_vs_perspective.rb
+- samples/processing_app/3D/camera/perspective.rb
+- samples/processing_app/3D/form
+- samples/processing_app/3D/form/brick_tower.rb
+- samples/processing_app/3D/typography
+- samples/processing_app/3D/typography/data
+- samples/processing_app/3D/typography/data/Univers66.vlw.gz
+- samples/processing_app/3D/typography/kinetic_type.rb
+- samples/processing_app/ABOUT
+- samples/processing_app/topics
+- samples/processing_app/topics/effects
+- samples/processing_app/topics/effects/data
+- samples/processing_app/topics/effects/data/red_smoke.jpg
+- samples/processing_app/topics/effects/lens.rb
 - samples/reflection.rb
 - samples/simple_buffer.rb
 - samples/tree.rb

data/samples/kinetic_type.rb

@@ -1,100 +0,0 @@
-# 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"