ruby-processing 2.4.2 → 2.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9941a815cfe461f91e8276a38dc04b779e6a5433
-  data.tar.gz: 2f8a60fa95307af91dc82c5e7cc0a87cbf68f7d3
+  metadata.gz: af2855010f2d2de32e8e7dc8c1828f51c84f56af
+  data.tar.gz: dab785b90f956a8ef19af5bffe4e449577397fcb
 SHA512:
-  metadata.gz: cf0f7703d59a95ad938025098a3407b9f5a7b6d2640830e7750c9d3ddd3219912117d33de94c8cf474fd5c2978644307a8bb9370243020592ad13a3f662450b2
-  data.tar.gz: c60b0d6ebce9418fe2ced947505fa1f717a1fd44891ccb3a2cbd5f22655e97995e1be7a21fd7b249b7f3f52fda241e8c2a510cd9dd116927056d5e7c7e211582
+  metadata.gz: 50cf01b0dd1f3a1e327abbd76448dfacb202ba8f366337b12c80a6a2d7807b7b4b8a1020c2a4ecbee25ad1e0459c837791e6491bc0741f1c591f60ac0c47c141
+  data.tar.gz: 844bc75fbdaea88f0f2e83d282da9c5bbb467475c56021177f60a8e01caccdfd57c95deb3a022fc86e47535a978da780d1ec975444170bd1c3eb7d152b5517c9

data/CHANGELOG

@@ -1,3 +1,8 @@
+v2.4.3 Update to JRuby-1.7.11
+* Added an autorun demo Rakefile to some sample directories
+* Support utf-8 in sketches
+* Refactor and extend vecmath (updated drawolver to use Vec3D)
+
 v2.4.2 Update to JRuby-1.7.10
 * Revised suggestions for PROCESSING_ROOT on MacOSX
 

data/CONTRIBUTING.md

@@ -12,6 +12,7 @@ Here are some ways *you* can contribute:
 * by proselytizing ruby-processing, we need more champions
 * by supporting [Processing.org][], nothing to do with us but we rely on them
 * by figuring out if we could replace swing with javafx for control_panel etc
+* by testing / contributing to the [development branch][]
 
 ## Submitting an Issue
 We use the [GitHub issue tracker][issues] to track bugs and features. Before
@@ -31,3 +32,4 @@ the bug, including your gem version, Ruby version, and operating system.
 [fork]: http://help.github.com/fork-a-repo/
 [pr]: http://help.github.com/send-pull-requests/
 [processing.org]: http://processing.org/foundation/
+[development branch]: https://github.com/monkstone/JRubyArt

data/README.md

@@ -12,19 +12,19 @@ Is a ruby wrapper around the [Processing][] code art framework, built using [JRu
 
 ## Installation
 
-Ideally you should install [jruby](http://jruby.org/download), at the very least you will have at least ruby-1.9.3 installed.  You should [download][] and install vanilla [processing-2.0.3](https://processing.org/download/) (MacOSX) or [processing-2.1.0](https://processing.org/download/) (Windows, Linux) prior to installing this version of ruby-processing. You must also set the `PROCESSING_ROOT` in the .rp5rc yaml configuration file, the easiest way is by running the [SetProcessingRoot.pde](https://gist.github.com/monkstone/7438749) sketch in the processing ide. 
+Ideally you should install [jruby](http://jruby.org/download), at the very least you will have at least ruby-1.9.3 installed.  You should [download][] and install vanilla [processing-2.0.3](https://processing.org/download/) (MacOSX) or [processing-2.1.0](https://processing.org/download/) (Windows, Linux) prior to installing this version of ruby-processing. You must also set the `PROCESSING_ROOT` in the .rp5rc yaml configuration file, the easiest way to do this is by running the [SetProcessingRoot.pde](https://gist.github.com/monkstone/7438749) sketch in the processing ide. 
 
 Then install ruby-processing (from rubygems-org) in the usual way
 
 `gem install ruby-processing` some systems eg Ubuntu may require `sudo` access
 
-To install jruby-complete use our built in tool (relies on `wget` to download [jruby-complete-1.7.10](http://jruby.org/download))
+To install jruby-complete use our built in tool (relies on `wget` to download [jruby-complete-1.7.11](http://jruby.org/download))
 
 `install_jruby_complete`
 
-If you haven't got `wget` just download jruby-complete-1.7.10 to the vendors folder (then run above tool)
+If you haven't got `wget` just download jruby-complete-1.7.11 to the vendors folder (then run above tool)
 
-The vendored jruby-complete-1.7.10 is only required for application export, and running certain sketches (eg shader sketches see wiki).
+The vendored jruby-complete-1.7.11 is only required for application export, and running certain sketches (eg shader sketches see wiki).
 
 
 ## Documentation
@@ -111,7 +111,7 @@ This library has been tested with the following ruby implementations
 
 ## What's new
 
-New capabilities since processing-2.0 include ability to use OPENGL VBO (PShape) and GLSL shaders (PShader), to keep abreast of latest shader developments for processing check out the [codeanticode blog](http://codeanticode.wordpress.com/2013/06/04/processing-2-0-is-out-processing-2-0-is-in/). Some worked examples using new feature are included in the samples. The update to the latest jruby is also significant as the default is to run with ruby-1.9 support, and there have been many performance improvements. Some performance improvements will not be available on the Mac as they require at least java-7+, and there is even more to come with java-8+ (adventurous Mac users can read more about [Oracle java here](http://www.java.com/en/download/faq/java_mac.xml) ). More than 330 worked examples are included in the [Samples][], many of which are rubified version of the examples included with vanilla processing, and or the contributed libraries, additions are welcome.
+New capabilities since processing-2.0 include ability to use OPENGL VBO (PShape) and GLSL shaders (PShader), to keep abreast of latest shader developments for processing check out the [codeanticode blog](http://codeanticode.wordpress.com/2013/06/04/processing-2-0-is-out-processing-2-0-is-in/). Some worked examples using new feature are included in the samples. The update to the latest jruby is also significant as the default is to run with ruby-1.9 support (or even use ruby-2.0 syntax with `compat.version=2.0` in your `.jrubyrc` config), and there have been many performance improvements. Some performance improvements will not be available on the Mac as they require at least java-7+, and there is even more to come with java-8+ (adventurous Mac users can read more about [Oracle java here](http://www.java.com/en/download/faq/java_mac.xml) ). More than 330 worked examples are included in the [Samples][], many of which are rubified version of the examples included with vanilla processing, and or the contributed libraries, additions are welcome.
 
 
 

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

@@ -1,3 +1,5 @@
+# -*- encoding : utf-8 -*-
+
 $LOAD_PATH << File.expand_path(File.dirname(__FILE__) + "/../../")
 SKETCH_PATH = ARGV.shift unless defined? SKETCH_PATH
 SKETCH_ROOT = File.dirname(SKETCH_PATH) unless defined? SKETCH_ROOT

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

@@ -22,7 +22,7 @@ module Processing
         if @files.detect { |file| File.exist?(file) && File.stat(file).mtime > @time }
           puts "reloading sketch..."
           $app && $app.close
-          @time = Time.now
+          @time = Time.now                
           java.lang.System.gc
           start_runner
           reload_files_to_watch
@@ -36,9 +36,8 @@ module Processing
     def report_errors
       yield
     rescue Exception => e
-      puts "Exception occured while running sketch #{File.basename SKETCH_PATH}:"
-      puts e.to_s
-      puts e.backtrace.join("\n")
+      warn "Exception occured while running sketch #{File.basename SKETCH_PATH}..."
+      puts "Backtrace:\n\t#{e.backtrace.join("\n\t")}"
     end
 
     def start_runner 

data/lib/ruby-processing/version.rb

@@ -1,3 +1,3 @@
 module RubyProcessing
-  VERSION="2.4.2"
+  VERSION="2.4.3"
 end

data/library/vecmath/lib/arcball.rb

@@ -0,0 +1,64 @@
+require_relative 'vec'
+require_relative 'quaternion'
+
+class ArcBall
+  attr_reader :center_x, :center_y, :v_down, :v_drag, :q_now, :q_drag, :q_down, :axis, :axis_set, :radius
+
+  def initialize(cx, cy, radius)
+    @center_x = cx
+    @center_y = cy
+    @radius = radius
+    @v_down = Vec3D.new
+    @v_drag = Vec3D.new
+    @q_now = Quaternion.new
+    @q_down = Quaternion.new
+    @q_drag = Quaternion.new
+    @axis_set = [Vec3D.new(1.0, 0.0, 0.0), Vec3D.new(0.0, 1.0, 0.0), Vec3D.new(0.0, 0.0, 1.0)]
+    @axis = -1
+  end
+
+  def select_axis(axis)
+    @axis = axis
+  end
+
+  def mouse2sphere(x, y)
+    v = Vec3D.new((x - center_x) / radius, (y - center_y) / radius, 0)
+    mag = v.mag
+    if (mag > 1.0)
+      v.normalize!
+    else
+      v.z = Math.sqrt(1.0 - mag)
+    end
+    v = constrain(v, axis_set[axis]) unless (axis == -1)
+    return v
+  end
+
+  def mouse_pressed(x, y)
+    @v_down = mouse2sphere(x, y)
+    @q_down.copy(q_now)
+    @q_drag.reset
+  end
+
+  def mouse_dragged(x, y)
+    @v_drag = mouse2sphere(x, y)
+    @q_drag.set(v_down.dot(v_drag), v_down.cross(v_drag))
+  end
+
+
+  def constrain(vector, axis)
+    res = vector - (axis * axis.dot(vector))
+    res.normalize!
+  end
+
+  def update
+    @q_now = q_drag * q_down
+    quat2matrix(q_now)
+  end
+
+  def quat2matrix(q)
+    q.get_value
+  end
+end
+
+
+

data/library/vecmath/lib/quaternion.rb

@@ -0,0 +1,62 @@
+require_relative 'vec'
+
+class Quaternion
+  EPSILON = 9.999999747378752e-05     # a value used by processing.org  
+  attr_reader :w, :x, :y, :z
+
+  def initialize(w = 1.0,  x = 0,  y = 0,  z = 0)
+    @w, @x, @y, @z = w,  x,  y,  z
+  end
+
+  def ==(quat)
+    (w - quat.w).abs < EPSILON && (x - quat.x).abs < EPSILON && (y - quat.y).abs < EPSILON && (z - quat.z).abs < EPSILON
+  end
+
+
+  def reset
+    @w = 1.0
+    @x = 0.0
+    @y = 0.0
+    @z = 0.0
+  end
+
+  def set(w, v)
+    @w, @x, @y, @z = w, v.x, v.y, v.z 
+  end
+
+  def copy(q)
+     @w, @x, @y, @z = q.w, q.x, q.y, q.z
+  end
+
+  def self.mult(q1, q2)      # class method   
+    x0 = q1.w * q2.x + q1.x * q2.w + q1.y * q2.z - q1.z * q2.y
+    y0 = q1.w * q2.y + q1.y * q2.w + q1.z * q2.x - q1.x * q2.z
+    z0 = q1.w * q2.z + q1.z * q2.w + q1.x * q2.y - q1.y * q2.x
+    w0 = q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z
+    Quaternion.new(w0,  x0,  y0,  z0)
+  end
+  
+  def * (q1)                 # instance method   
+    x0 = w * q1.x + x * q1.w + y * q1.z - z * q1.y
+    y0 = w * q1.y + y * q1.w + z * q1.x - x * q1.z
+    z0 = w * q1.z + z * q1.w + x * q1.y - y * q1.x
+    w0 = w * q1.w - x * q1.x - y * q1.y - z * q1.z
+    Quaternion.new(w0,  x0,  y0,  z0)
+  end
+
+  def get_value
+    sa = Math.sqrt(1.0 - w * w)
+    sa = 1.0 unless (sa >= EPSILON)
+    [Math.acos(w) * 2, x / sa, y / sa, z / sa]
+  end
+  
+  def to_s
+    "#{self.class}(w=#{w}, x=#{x}, y=#{y}, z=#{z})"  
+  end
+
+  def inspect
+    self.to_s
+  end
+end
+
+

data/library/vecmath/lib/vec.rb

@@ -0,0 +1,216 @@
+class Vec2D
+  EPSILON = 9.999999747378752e-05     # a value used by processing.org
+  attr_accessor :x, :y, :z  
+  
+  def initialize(x = 0 ,y = 0, z = 0)
+    @x, @y, @z = x, y, z
+    post_initialize
+  end
+  
+  def post_initialize
+    nil
+  end  
+
+  def ==(vec)
+    (x - vec.x).abs < EPSILON && (y - vec.y).abs < EPSILON && (z - vec.z).abs < EPSILON
+  end
+ 
+  def self.dist_squared(vec_a, vec_b)
+    (vec_a.x - vec_b.x)**2 + (vec_a.y - vec_b.y)**2 + (vec_a.z - vec_b.z)**2
+  end
+ 
+  def self.dist(vec_a, vec_b)
+    Math.sqrt((vec_a.x - vec_b.x)**2 + (vec_a.y - vec_b.y)**2 + (vec_a.z - vec_b.z)**2)
+  end
+
+  def inspect
+    self.to_s
+  end
+
+   
+  def self.from_angle scalar
+    Vec2D.new(Math.cos(scalar), Math.sin(scalar))
+  end
+  
+  def modulus
+    Math.hypot(x, y)	  
+  end
+  
+  def mag_squared
+    x**2 + y**2	  
+  end
+
+  # vanilla processing PVector returns a Vector, rather than Scalar (defaults to 3D result with z = 0)
+  def cross(vec)
+    x * vec.y - y * vec.x
+  end
+  
+  # Scalar product, also known as inner product or dot product
+  def dot(vec)
+    x * vec.x + y * vec.y
+  end
+  
+  def collinear_with?(vec)
+    cross(vec).abs < EPSILON
+  end
+  
+  def +(vec)
+    Vec2D.new(x + vec.x, y + vec.y)
+  end
+  
+  def -(vec)
+    Vec2D.new(x - vec.x, y - vec.y)
+  end
+  
+  def *(scalar)      
+    Vec2D.new(x * scalar, y * scalar)
+  end
+
+  def / (scalar)      
+    Vec2D.new(x / scalar, y / scalar) unless scalar == 0
+  end
+
+  # @param [Vec2D] vec
+  #   The target vector
+  # @param [Float] scalar 
+  # @return [Vec2D]
+  #   A new Vec2D on the way to the target (all the way if scalar not in 0 .. 1.0)
+  
+  def lerp(vec, scalar)
+    if (0 .. 1.0).include? scalar
+      x0, y0 = x * scalar + vec.x * (1 - scalar), y * scalar + vec.y * (1 - scalar)
+    else
+      x0, y0 = vec.x, vec.y # you will get there rather quicker than you hoped
+    end
+    Vec2D.new(x0, y0)
+  end
+
+  # Change the values of current Vec2D toward a target
+  # @param [Vec2D] vec
+  #   The target vector
+  # @param [Float] scalar 
+  # @return [Vec2D]
+  #   self Vec2D on the way to the target (unchanged if scalar not in 0 .. 1.0)
+
+  
+  def lerp!(vec, scalar)     
+    @x, @y = x * scalar + vec.x * (1 - scalar), y * scalar + vec.y * (1 - scalar) if (0 .. 1.0).include? scalar
+    return self
+  end
+  
+  def heading
+    Math.atan2(-y, x) * -1.0
+  end
+  
+  def normalize
+    magnitude = Math.hypot(x, y)	  
+    Vec2D.new( x / magnitude, y / magnitude)
+  end
+  
+  def normalize!
+    magnitude = Math.hypot(x, y)	  
+    @x, @y = x / magnitude, y / magnitude
+    return self
+  end
+  
+  def set_mag(scalar)
+    magnitude = Math.hypot(x, y)	  
+    @x, @y = (x * scalar) / magnitude, (y * scalar) / magnitude
+    return self    
+  end
+
+  def to_a
+    [x, y]
+  end
+
+  def to_s
+    "#{self.class}(x=#{x}, y=#{y})"  
+  end
+  
+  alias :mag :modulus 
+
+end
+
+class Vec2DR < Vec2D
+  
+  def rotate(rot)
+    Vec2D.new((x * Math.cos(rot)) - y * Math.sin(rot),
+	    (x * Math.sin(rot)) + (y * Math.cos(rot)))
+  end
+
+  # this behaves like PVector rotate (ie changes self, except returns self rather than "void")
+  def rotate!(rot)
+    @x, @y = (x * Math.cos(rot) - y * Math.sin(rot)), (x * Math.sin(rot) + y * Math.cos(rot))
+    return self
+  end 
+end
+
+class Vec3D < Vec2D
+
+  def modulus
+    Math.sqrt(x**2 + y**2 + z**2)
+  end
+
+  def cross(vec)
+    xc = y * vec.z - z * vec.y
+    yc = z * vec.x - x * vec.z
+    zc = x * vec.y - y * vec.x
+    Vec3D.new(xc, yc, zc)
+  end
+  
+  # Scalar product, also known as inner product or dot product
+  def dot(vec)
+    x * vec.x + y * vec.y + z * vec.z
+  end
+  
+  def collinear_with?(vec)
+    cross(vec) == Vec3D.new
+  end
+
+  def to_a
+    [x, y, z]
+  end
+  
+  def +(vec)
+    Vec3D.new(x + vec.x, y + vec.y, z + vec.z)
+  end 
+  
+  def -(vec)
+    Vec3D.new(x - vec.x, y - vec.y, z - vec.z)
+  end
+  
+  def * (scalar)       
+    Vec3D.new(x * scalar, y * scalar, z * scalar)
+  end
+
+  def / (scalar)      
+    Vec3D.new(x / scalar, y / scalar, z / scalar) unless scalar.abs < EPSILON
+  end
+  
+  def normalize   	  
+    magnitude = Math.sqrt(x**2 + y**2 + z**2)
+    Vec3D.new( x / magnitude, y / magnitude, z / magnitude)
+  end
+  
+  def normalize!    	  
+    magnitude = Math.sqrt(x**2 + y**2 + z**2)
+    @x, @y, @z = x / magnitude, y / magnitude, z / magnitude
+    return self
+  end
+  
+  def set_mag(scalar)
+    magnitude = Math.sqrt(x**2 + y**2 + z**2)
+    @x, @y, @z = (x * scalar) / magnitude, (y * scalar) / magnitude, (z * scalar) / magnitude
+    return self    
+  end
+  
+  def to_s
+    "#{self.class}(x=#{x}, y=#{y}, z=#{z})"  
+  end
+
+end
+
+
+
+
+