ruby-processing 2.4.4 → 2.5.0

data/library/fastmath/fastmath.rb

@@ -0,0 +1,3 @@
+require 'rpextras'
+
+Java::ProcessingFastmath::DeglutLibrary.new.load(JRuby.runtime, false)

data/library/file_chooser/file_chooser.rb

@@ -12,13 +12,12 @@ module FileChooser
   System = Java::JavaLang::System
   
   class Filter < Java::javax::swing::filechooser::FileFilter
-    attr_reader :description, :extensions   
+    attr_reader :description, :extensions
     def define(description, extensions)
-      @description = description
-      @extensions = extensions
+      @description, @extensions = description, extensions
     end
     
-    def accept fobj
+    def accept(fobj)
       return true if extensions.include?(File.extname(fobj.to_s).downcase)
       return true if fobj.isDirectory
     end
@@ -35,24 +34,23 @@ module FileChooser
     HOST = 'host_os'
     UHOME = 'user.home'
     UDIR = 'user.dir'
-    OS = case RbConfig::CONFIG[HOST]
-    # Detect OS      
-    when /darwin/      then :mac
-    when /mswin|mingw/ then :windows
-    else
-      :unix
+    OS = :unix
+    case RbConfig::CONFIG[HOST]
+    when /darwin/      then OS = :mac
+    when /mswin|mingw/ then OS = :windows
     end
     
     def initialize
       @chooser = JXChooser.new
     end
     
-    def look_feel lf = "Metal"
-      lafs = javax.swing.UIManager::getInstalledLookAndFeels.select{|info| info.getName.eql? lf}
+    def look_feel(lf = 'Metal')
+      lafs = javax.swing.UIManager::getInstalledLookAndFeels.select{ |info| 
+      info.getName.eql? lf }
       javax.swing.UIManager::setLookAndFeel(lafs[0].getClassName) if lafs.size > 0
     end
     
-    def set_filter description, extensions
+    def set_filter(description, extensions)
       filter = FileChooser::Filter.new
       filter.define(description, extensions)
       @chooser.setFileFilter(filter)

data/library/vecmath/vecmath.rb

@@ -1,37 +1,8 @@
-# vecmath.rb
-# The vecmath library provides Vec2D and Vec3D classes which can be
-# use in place of processing PVector, and provide a more rubylike interface.
-# Also included in the vecmath library is the ArcBall utility after:-
-# Ken Shoemake. Computer Graphics Laboratory. University of Pennsylvania. Philadelphia, PA
-# ==== Example Arcball usage see vecmath library in samples
-# def setup
-#   .....
-#   camera(width/2.0, height/2.0, (height/2.0) / tan(PI*30.0 / 180.0), 0, 0, 0, 0, 1, 0)
-#   @arcball = ArcBall.new(0, 0, min(width - 20, height - 20) * 0.8)
-#   .....
-# end
-#
-# def draw
-#   .....
-#   update
-#   some_render_code
-#   .....
-# end
-#
-# def update
-#   theta, x, y, z = arcball.update
-#   rotate(theta, x, y, z)
-# end
-#
-# def mouse_pressed
-#   arcball.mouse_pressed(mouse_x, mouse_y)
-# end
-#
-# def mouse_dragged
-#   arcball.mouse_dragged(mouse_x, mouse_y)
-# end
+require 'rpextras'
 
+Java::ProcessingVecmathArcball::ArcballLibrary.new.load(JRuby.runtime, false)
+Java::ProcessingVecmathVec2::Vec2Library.new.load(JRuby.runtime, false)
+Java::ProcessingVecmathVec3::Vec3Library.new.load(JRuby.runtime, false)
 
-require_relative 'lib/vec'
-require_relative 'lib/quaternion'
-require_relative 'lib/arcball'
+AppRender = Java::ProcessingVecmath::AppRender
+ShapeRender = Java::ProcessingVecmath::ShapeRender

data/samples/Rakefile

@@ -15,5 +15,7 @@ end
 
 desc 'vecmath'
 task :vecmath do
-  sh "cd processing_app/library/vecmath && rake"
+  sh "cd processing_app/library/vecmath/vec2d && rake"
+  # sh "cd processing_app/library/vecmath/vec3d && rake"
+  # sh "cd processing_app/library/vecmath/arc_ball && rake"
 end

data/samples/configRP5/configRP5.pde

@@ -0,0 +1,150 @@
+Button enter, nojruby;
+String processingRoot = "enter your processing root here"; // edit this line in the sketch
+String done = "Done";
+String OS = System.getProperty("os.name").toLowerCase();
+String home, suggestion, separator, root;
+PFont font;
+StringBuilder header = new StringBuilder(200);
+float rectX, rectX2, rectY;      // Position of buttons
+float rectHeight = 30;           // height of rect
+float rectWidth = 90;            // width of rect
+int rectColor, rectColor2;
+int rectHighlight, rectHighlight2;
+int currentColor;
+int selectedColor;
+boolean acceptOver = false;
+boolean noJruby = false;
+boolean selected = false;
+boolean no_jruby = false;
+
+
+void setup() {
+  size(600, 200);
+  home = System.getProperty("user.home");
+  File f = new File(home);
+  root = f.getParent();
+  separator = System.getProperty("file.separator");
+  header.append("# YAML configuration file for ruby-processing\n");
+  header.append("# RP5HOME: \"").append(root).append(separator).append("ruby193 ... ").append(separator);
+  header.append("ruby-processing\" #windows users may need to set this\n");
+  font = createFont("Helvetica", 18);
+  if (OS.contains("mac")) {
+    suggestion = "/Applications/Processing.app/Contents/Resources/Java";
+  } else {
+    suggestion = home + separator + "processing-2.2.1";
+  }
+  rectColor = color(140);
+  rectColor2 = color(140);
+  rectHighlight = color(100);
+  rectHighlight2 = color(100);
+  selectedColor = color(0);
+  rectX = rectWidth + 20;
+  rectX2 = rectWidth + 150;
+  rectY = height * 0.8f - rectHeight / 4;
+  enter = new Button(rectX2, rectY, rectWidth, rectHeight, "enter");
+  nojruby = new Button(rectX, rectY, rectWidth, rectHeight, "nojruby");
+}
+
+void draw() {
+  background(200);
+  fill(0, 0, 200);
+  text("Suggestion:", 35, 28);
+  text(suggestion, 35, 56);
+  textFont(font, 18);
+  fill(255, 0, 0);
+  // this adds a blinking cursor after your text, at the expense of redrawing everything every frame
+  text(processingRoot + (frameCount / 10 % 2 == 0 ? "_" : ""), 35, 100);
+  fill(0, 0, 200);
+  text("Select nojruby to use jruby-complete by default", 35, 140);
+  update(mouseX, mouseY);
+  //background(200);
+
+  if (acceptOver) {
+    enter.draw(rectHighlight);
+    nojruby.draw(rectHighlight2);
+  } else {
+    enter.draw(rectColor);
+    nojruby.draw(rectColor2);
+  }
+}
+
+void writeRoot() {
+  rectColor = selectedColor;
+  rectHighlight = selectedColor;
+  header.append("PROCESSING_ROOT: \"").append(processingRoot).append("\"\n");
+  if (no_jruby) {
+    header.append("JRUBY: \'false\'\n");
+  } else {
+    header.append("JRUBY: \'true\'\n");
+  }
+  PrintWriter pw = createWriter(home + separator + ".rp5rc");
+  pw.append(header);
+  pw.flush();
+  pw.close();
+  processingRoot = done;
+}
+
+void keyReleased() {
+  if (key != CODED) {
+    switch (key) {
+    case BACKSPACE:
+      processingRoot = processingRoot.substring(0, max(0, processingRoot.length() - 1));
+      break;
+    case ENTER: // save the processing root to the config file
+    case RETURN:
+      writeRoot();
+      break;
+    case ESC:
+    case DELETE:
+      break;
+    default:
+      processingRoot += key;
+    }
+  }
+}
+
+void update(float x, float y) {
+  acceptOver = enter.overRect();
+  noJruby = nojruby.overRect();
+}
+
+void mouseClicked() {
+  update(mouseX, mouseY);
+  if (acceptOver) {
+    rectColor = selectedColor;
+    rectHighlight = selectedColor;
+    writeRoot();
+  }
+  if (noJruby) {
+    rectColor2 = selectedColor;
+    rectHighlight2 = selectedColor;
+    no_jruby = true;
+  }
+}
+
+class Button {
+
+  float x, y, w, h;
+  String text;
+
+  Button(float x, float y, float w, float h, String text) {
+    this.x = x;
+    this.y = y;
+    this.w = w;
+    this.h = h;
+    this.text = text;
+  }
+
+  void draw(int col) {
+    fill(col);
+    rect(x, y, w, h, 20, 20, 20, 20);
+    fill(255);
+    text(text, x + 8, y + 20);
+  }
+
+  boolean overRect() {
+    return (mouseX >= x && mouseX <= x + w
+      && mouseY >= y && mouseY <= y + h);
+  }
+}
+

data/samples/contributed/Rakefile

@@ -1,20 +1,20 @@
 # Simple demo Rakefile to autorun samples in current directory
 # adjust path to rp5 executable, and or opts as required
 
-SAMPLES_DIR="./"
+SAMPLES_DIR = './'
 
 desc 'run demo'
-task :default => [:demo]
+task default: [:demo]
 
 desc 'demo'
 task :demo do
-  samples_list.shuffle.each{|sample| run_sample sample}
+  samples_list.shuffle.each{ |sample| run_sample sample }
 end
 
 def samples_list
   files = []
   Dir.chdir(SAMPLES_DIR)
-  Dir.glob("*.rb").each do |file|
+  Dir.glob('*.rb').each do |file|
     files << File.join(SAMPLES_DIR, file)
   end
   return files
@@ -22,9 +22,9 @@ end
 
 def run_sample(sample_name)
   puts "Running #{sample_name}...quit to run next sample"
-  open("|rp5 run #{sample_name}", "r") do |io|
+  open("|rp5 run #{sample_name}", 'r') do |io|
     while l = io.gets
-      puts(l.chop) 
+      puts(l.chop)
     end      
   end
 end

data/samples/contributed/animator.rb

@@ -11,15 +11,15 @@ def setup
   @last_time      = 0
   @current_frame  = 0
   @draw           = false
-  @back_color     = 204  
+  @back_color     = 204
   stroke_weight 4
   smooth
   background @back_color
-  FRAME_COUNT.times { @frames << get() }
+  FRAME_COUNT.times { @frames << get }
 end
 
 def draw
-  time = millis()
+  time = millis
   if time > @last_time + 100
     next_frame
     @last_time = time
@@ -37,12 +37,12 @@ end
 
 def key_pressed
   background @back_color
-  @frames.size.times {|i| @frames[i] = get()}
+  @frames.size.times { |i| @frames[i] = get }
 end
 
 def next_frame
-  @frames[@current_frame] = get()
+  @frames[@current_frame] = get
   @current_frame += 1
   @current_frame = 0 if @current_frame >= @frames.size
   image(@frames[@current_frame], 0, 0)
-end
+end

data/samples/contributed/bezier_playground.rb

@@ -3,62 +3,55 @@
 # You can print out the parametric equations for t = 0..1
 module Olap
   def self.overlaps(x, y, point_x, point_y)
-    (x-point_x)**2 + (y-point_y)**2 < RADIUS * RADIUS 
+    Math.hypot(x - point_x, y - point_y) < RADIUS
   end
 end
 
 class Curve
-  include Olap
-  include Processing::Proxy
+  include Olap, Processing::Proxy
   attr_accessor :x1, :y1, :c1x, :c1y, :c2x, :c2y, :x2, :y2
   
   def initialize
     @x1, @y1, @x2, @y2 = X1, Y1, X2, Y2
-    set_control_points(X1+30, Y1, X2-30, Y2)
+    set_control_points(X1 + 30, Y1, X2 - 30, Y2)
   end
   
   def contains(x, y)
-    return :one if Olap::overlaps(@x1, @y1, x, y)
-    return :two if Olap::overlaps(@x2, @y2, x, y)
+    return :one if Olap.overlaps(x1, y1, x, y)
+    return :two if Olap.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
-    bezier *all_points
-    oval @x1, @y1, 3, 3
-    oval @x2, @y2, 3, 3
+    bezier(*all_points)
+    oval x1, y1, 3, 3
+    oval x2, y2, 3, 3
   end
   
-  
-  def print_equation
-    p = all_points.map {|p| p.to_i }
+  def print_equation(id)
+    p = all_points.map { |pt| pt.to_i }
     puts ""
-    puts "*** line ##{$app.curves.index(self) + 1} ***"
+    puts "*** line ##{id} ***"
     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
 
 
 attr_accessor :curves, :c1x, :c1y, :c2x, :c2y
-attr_reader :panel
+attr_reader :panel, :hide
 
 X1, Y1, X2, Y2 = 50.0, 50.0, 250.0, 250.0
 REDDISH = [250, 100, 100]
@@ -67,14 +60,12 @@ RADIUS = 7
 load_library :control_panel
 include Olap
 
-attr_reader :hide
-
 def setup
   size 300, 300
   @curves = []
   @hide = false
   control_panel do |c|
-    c.look_feel "Nimbus"
+    c.look_feel 'Nimbus'
     c.button :new_curve
     c.button :print_equations
     @panel = c
@@ -82,68 +73,44 @@ def setup
   generate_curve
 end
 
-
-
 def print_equations
-  curves.each {|c| c.print_equation }
+  curves.each_with_index { |c, i| c.print_equation(i + 1) }
 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
+  curves << current_curve = Curve.new
   @current = curves.length - 1
   set_control_points(*current_curve.control_points)
 end
 
-
 def current_curve
-  @curves[@current]
+  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 Olap::overlaps(@c1x, @c1y, x, y)
-  return :two if Olap::overlaps(@c2x, @c2y, x, y)
+  return :one if Olap.overlaps(c1x, c1y, x, y)
+  return :two if Olap.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) }
+  curve = curves.detect { |c| c.contains(mouse_x, mouse_y) }
   @end_point = curve.contains(mouse_x, mouse_y) if curve
 end
 
@@ -153,22 +120,20 @@ def mouse_released
   @hide = false
 end
 
-
 def mouse_dragged
   offs = compute_offsets
-  return if offs.map {|o| o.abs }.max > 100
+  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) }
+  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)
+  @current = curves.index(become)
 end
 
 
@@ -203,32 +168,28 @@ 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 }
+  curves.each { |curve| curve.draw }
 end
 
-
 def draw_current_control_points
-  fill *REDDISH
+  fill color(*REDDISH)
   no_stroke
-  oval @c1x, @c1y, 5, 5
-  oval @c2x, @c2y, 5, 5
+  oval c1x, c1y, 5, 5
+  oval c2x, c2y, 5, 5
 end
 
-
 def draw_control_tangent_lines
   c = current_curve
-  stroke *REDDISH
+  stroke color(*REDDISH)
   stroke_width 1
-  line @c1x, @c1y, c.x1, c.y1
-  line @c2x, @c2y, c.x2, c.y2
+  line c1x, c1y, c.x1, c.y1
+  line c2x, c2y, c.x2, c.y2
 end
 
-
 def draw
   if (!hide)
     panel.visible = self.visible