ruby-processing 1.0.2 → 1.0.3

data/CHANGELOG

@@ -1,3 +1,15 @@
+v1.0.3 Tweaks and Tuneups...
+  * "rp5 watch" is now a bit more robust, and tries to reload every
+  * file, global, and constant that it thinks it needs to.
+  * Many, many examples have been contributed by Marc Chung, 
+    Peter Krenn, and Florian Jenett.
+  * Andreas Haller contributed a patch that added Ruby-1.9 compatibility.
+  * The render mode now defaults to JAVA2D, as does Processing.
+  * "rp5 create" now informs you of the file it just created.
+  * "key" now returns a character, if ASCII and the integer value otherwise,
+    mirroring Processing's behavior.
+  * Numbers now have the methods 'degrees' and 'radians', for ease.
+
 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

data/lib/ruby-processing.rb

@@ -8,10 +8,11 @@ unless defined? RP5_ROOT
 end
 
 require 'ruby-processing/helpers/string'
+require 'ruby-processing/helpers/numeric'
 
 # The top-level namespace, a home for all Ruby-Processing classes.
 module Processing
-  VERSION = [1,0,2]
+  VERSION = [1,0,3] unless defined? Processing::VERSION
   
   # Returns the current version of Ruby-Processing.
   def self.version

data/lib/ruby-processing/app.rb

@@ -8,7 +8,7 @@ module Processing
 
   # Conditionally load core.jar
   require "#{RP5_ROOT}/lib/core/core.jar" unless Object.const_defined?(:JRUBY_APPLET)  
-  include_package "processing.core"
+  import "processing.core"
 
   # This is the main Ruby-Processing class, and is what you'll
   # inherit from when you create a sketch. This class can call
@@ -20,11 +20,11 @@ module Processing
   class App < PApplet
     include Math
 
-    include_class "javax.swing.JFrame"
+    import "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}"
+      import "processing.core.#{klass}"
     end
         
     # Alias some methods for familiarity for Shoes coders.
@@ -175,7 +175,7 @@ module Processing
         :full_screen => false
       }.merge(options)
       @width, @height, @title = options[:width], options[:height], options[:title]
-      @render_mode = P2D
+      @render_mode = JAVA2D
       determine_how_to_display options
     end
 
@@ -235,10 +235,12 @@ module Processing
 
 
     # Fix java conversion problems getting the last key
+    # If it's ASCII, return the character, otherwise the integer
     def key
       field = java_class.declared_field 'key'
       app = Java.ruby_to_java self
-      field.value app
+      int = field.value(app)
+      int < 256 ? int.chr : int
     end
 
 

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

@@ -9,7 +9,10 @@ module Processing
       main_file = File.basename(path, ".rb")
       # Check to make sure that the main file exists
       already_exists = File.exists?(path) || File.exists?("#{File.dirname(path)}/#{main_file.underscore}.rb")
-      puts "That sketch already exists." and exit if already_exists
+      if already_exists
+        puts "That sketch already exists."
+        exit
+      end
       
       # Get the substitutions
       @name =       main_file.camelize
@@ -23,9 +26,9 @@ module Processing
       mkdir_p dir
       template = File.new("#{RP5_ROOT}/lib/templates/create/blank_sketch.rb.erb")
       rendered = render_erb_from_string_with_binding(template.read, binding)
-      File.open(File.join(dir, "#{@file_name}.rb"), "w") do |file|
-        file.print rendered
-      end
+      full_path = File.join(dir, "#{@file_name}.rb")
+      File.open(full_path, "w") {|f| f.print(rendered) }
+      puts "Created Sketch \"#{@title}\" in #{full_path.sub(/\A\.\//, '')}"
     end
     
     # Show the help/usage message for create.

data/lib/ruby-processing/helpers/numeric.rb

@@ -0,0 +1,11 @@
+class Numeric #:nodoc
+  
+  def degrees
+    self*180/Math::PI
+  end
+  
+  def radians
+    self*Math::PI/180
+  end
+
+end

data/lib/ruby-processing/helpers/string.rb

@@ -24,4 +24,12 @@ class String #:nodoc:
       downcase
   end
   
+  # String.ord is Ruby 1.9, so this is a little fix for R 1.8 
+  # to make it forward compatible and readable
+  unless String.method_defined? :ord
+  	def ord
+  		self[0]
+  	end
+  end  
+  
 end

data/lib/ruby-processing/runner.rb

@@ -37,16 +37,17 @@ module Processing
     # Dispatch central.
     def execute!
       case @options.action
-      when 'run'    : run(@options.path)
-      when 'watch'  : watch(@options.path)
-      when 'create' : create(@options.path, @options.args)
-      when 'live'   : live(@options.path)
-      when 'app'    : app(@options.path)
-      when 'applet' : applet(@options.path)
-      when 'unpack' : unpack(@options.path)
-      when /-v/     : show_version
-      when /-h/     : show_help
-      else show_help
+      when 'run'    then run(@options.path)
+      when 'watch'  then watch(@options.path)
+      when 'create' then create(@options.path, @options.args)
+      when 'live'   then live(@options.path)
+      when 'app'    then app(@options.path)
+      when 'applet' then applet(@options.path)
+      when 'unpack' then unpack(@options.path)
+      when /-v/     then show_version
+      when /-h/     then show_help
+      else
+        show_help
       end
     end
     

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

@@ -10,10 +10,12 @@ module Processing
     def initialize(sketch)
       @file = sketch
       @time = Time.now
+      record_state_of_ruby
       load @file
       start_watching
     end
     
+    
     # Kicks off a thread to watch the sketch, reloading Ruby-Processing
     # and restarting the sketch whenever it changes.
     def start_watching
@@ -23,6 +25,7 @@ module Processing
           if file_mtime > @time
             @time = file_mtime
             Processing::App.wipe_out_current_app!
+            rewind_to_recorded_state
             GC.start
             begin
               load @file
@@ -36,6 +39,36 @@ module Processing
       thread.join
     end
     
+    
+    # Do the best we can to take a picture of the current Ruby interpreter.
+    # For now, this means top-level constants and loaded .rb files.
+    def record_state_of_ruby
+      @saved_constants  = Object.send(:constants).dup
+      @saved_load_paths = $LOAD_PATH.dup
+      @saved_features   = $LOADED_FEATURES.dup
+      @saved_globals    = Kernel.global_variables.dup
+    end
+    
+    
+    # Try to go back to the recorded Ruby state.
+    def rewind_to_recorded_state
+      new_constants  = Object.send(:constants).reject {|c| @saved_constants.include?(c) }
+      new_load_paths = $LOAD_PATH.reject {|p| @saved_load_paths.include?(p) }
+      new_features   = $LOADED_FEATURES.reject {|f| @saved_features.include?(f) }
+      new_globals    = Kernel.global_variables.reject {|g| @saved_globals.include?(g) }
+      
+      new_constants.each {|c| Object.send(:remove_const, c) }
+      new_load_paths.each {|p| $LOAD_PATH.delete(p) }
+      new_features.each {|f| $LOADED_FEATURES.delete(f) }
+      new_globals.each do |g| 
+        begin
+          eval("#{g} = nil") # There's no way to undef a global variable in Ruby
+        rescue NameError => e
+          # Some globals are read-only, and we can't set them to nil.
+        end
+      end
+    end
+    
   end
 end
 

data/samples/bezier_playground.rb

@@ -0,0 +1,243 @@
+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)
+    Math.sqrt((x-point_x)**2 + (y-point_y)**2) < Bezier::RADIUS 
+  end
+  
+end
+
+
+class Curve
+  
+  attr_accessor :x1, :y1, :c1x, :c1y, :c2x, :c2y, :x2, :y2
+  
+  def initialize
+    @x1, @y1, @x2, @y2 = Bezier::X1, Bezier::Y1, Bezier::X2, Bezier::Y2
+    set_control_points(  Bezier::X1+30, Bezier::Y1, Bezier::X2-30, Bezier::Y2)
+  end
+  
+  
+  def contains(x, y)
+    return :one if Math.overlaps(@x1, @y1, x, y)
+    return :two if Math.overlaps(@x2, @y2, x, y)
+  end
+  
+  
+  def all_points
+    return x1, y1, c1x, c1y, c2x, c2y, x2, y2
+  end
+  
+  
+  def control_points
+    return c1x, c1y, c2x, c2y
+  end
+  
+  
+  def set_control_points(*points)
+    @c1x, @c1y, @c2x, @c2y = *points
+  end
+  
+  
+  def draw
+    $app.bezier *all_points
+    $app.oval @x1, @y1, 3, 3
+    $app.oval @x2, @y2, 3, 3
+  end
+  
+  
+  def print_equation
+    p = all_points.map {|p| p.to_i }
+    puts ""
+    puts "*** line ##{$app.curves.index(self) + 1} ***"
+    puts "x = (1-t)^3 #{p[0]} + 3(1-t)^2 t#{p[2]} + 3(1-t)t^2 #{p[4]} + t^3 #{p[6]}"
+    puts "y = -1 * ((1-t)^3 #{p[1]} + 3(1-t)^2 t#{p[3]} + 3(1-t)t^2 #{p[5]} + t^3 #{p[7]})"
+    puts ""
+  end
+  
+end
+
+
+class Bezier < Processing::App
+  
+  attr_accessor :curves, :c1x, :c1y, :c2x, :c2y
+  
+  X1, Y1, X2, Y2 = 50.0, 50.0, 250.0, 250.0
+  REDDISH = [250, 100, 100]
+  RADIUS = 7
+  
+  load_library :control_panel
+
+  def setup
+    smooth
+    @curves = []
+    
+    control_panel do |c|
+      c.button :new_curve
+      c.button :print_equations
+    end
+    
+    generate_curve
+  end
+  
+  
+  def print_equations
+    @curves.each {|c| c.print_equation }
+  end
+  
+  
+  def control_points
+    return c1x, c1y, c2x, c2y
+  end
+  
+  
+  def set_control_points(*points)
+    @c1x, @c1y, @c2x, @c2y = points.any? ? points : [X1, Y1, X2, Y2]
+  end
+  
+  
+  def generate_curve
+    @curves << @current_curve = Curve.new
+    @current = @curves.length - 1
+    set_control_points(*current_curve.control_points)
+  end
+  
+  
+  def current_curve
+    @curves[@current]
+  end
+  
+  
+  def new_curve
+    current_curve.set_control_points(c1x, c1y, c2x, c2y)
+    generate_curve
+  end
+  
+  
+  def clicked_control_point?
+    x, y = mouse_x, mouse_y
+    return :one if Math.overlaps(@c1x, @c1y, x, y)
+    return :two if Math.overlaps(@c2x, @c2y, x, y)
+  end
+  
+  
+  def key_pressed
+    case keyCode
+    when 8 # Delete the current line
+      return if @curves.length <= 1
+      @curves.delete(current_curve) 
+      @current = @curves.length - 1
+    when LEFT # Flip forward
+      @current = (@current + 1) % @curves.length
+    when RIGHT # Flip back
+      @current = (@current - 1) % @curves.length
+    end
+    set_control_points(*current_curve.control_points)
+  end
+  
+  
+  def mouse_pressed
+    switch_curve_if_endpoint_clicked
+    @control = clicked_control_point?
+    return if @control
+    curve = @curves.detect {|c| c.contains(mouse_x, mouse_y) }
+    @end_point = curve.contains(mouse_x, mouse_y) if curve
+  end
+  
+  
+  def mouse_released
+    @control, @end_point = nil, nil
+  end
+  
+  
+  def mouse_dragged
+    offs = compute_offsets
+    return if offs.map {|o| o.abs }.max > 100
+    return move_control_point(*offs) if @control
+    return move_end_point(*offs) && move_control_point(*offs) if @end_point
+    move_current_curve(*offs)
+  end
+  
+  
+  def switch_curve_if_endpoint_clicked
+    become = @curves.detect {|c| c.contains(mouse_x, mouse_y) }
+    return unless become && become != current_curve
+    current_curve.set_control_points(*control_points)
+    self.set_control_points(*become.control_points)
+    @current = @curves.index(become)
+  end
+  
+  
+  def move_current_curve(x_off, y_off)
+    @c1x += x_off; @c2x += x_off
+    @c1y += y_off; @c2y += y_off
+    current_curve.set_control_points(*control_points)
+    current_curve.x1 += x_off; current_curve.x2 += x_off
+    current_curve.y1 += y_off; current_curve.y2 += y_off
+  end
+  
+  
+  def move_control_point(x_off, y_off)
+    case @control || @end_point
+    when :one : @c1x += x_off and @c1y += y_off
+    when :two : @c2x += x_off and @c2y += y_off
+    end
+    current_curve.set_control_points(*control_points)
+  end
+  
+  
+  def move_end_point(x_off, y_off)
+    c = current_curve
+    case @end_point
+    when :one : c.x1 += x_off and c.y1 += y_off
+    when :two : c.x2 += x_off and c.y2 += y_off
+    end
+  end
+  
+  
+  def compute_offsets
+    return mouse_x - pmouse_x, mouse_y - pmouse_y
+  end
+  
+  
+  def draw_curves
+    stroke 255
+    no_fill
+    stroke_width 2
+    @curves.each {|curve| curve.draw }
+  end
+  
+  
+  def draw_current_control_points
+    fill *REDDISH
+    no_stroke
+    oval @c1x, @c1y, 5, 5
+    oval @c2x, @c2y, 5, 5
+  end
+  
+  
+  def draw_control_tangent_lines
+    c = current_curve
+    stroke *REDDISH
+    stroke_width 1
+    line @c1x, @c1y, c.x1, c.y1
+    line @c2x, @c2y, c.x2, c.y2
+  end
+    
+  
+  def draw
+    background 50
+    draw_control_tangent_lines
+    draw_curves
+    draw_current_control_points
+  end
+  
+end
+
+Bezier.new :title => "Bezier", :width => 700, :height => 700