ruby-processing 2.4.4 → 2.5.0

data/CONTRIBUTING.md

@@ -1,35 +0,0 @@
-## Contributing
-In the spirit of [free software][free-sw], **everyone** is encouraged to help improve this project.
-
-Here are some ways *you* can contribute:
-
-* by reporting bugs
-* by suggesting/implementing new features ( _export to ruboto would be cool_ )
-* by writing or editing documentation ( _expert Windows users could help write install instructions_ )
-* by contributing examples ( _show your creativity, or translate someone elses masterpiece_ )
-* by refactoring examples to be more rubyfied
-* by closing [issues][]
-* 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
-submitting a bug report or feature request, check to make sure it hasn't
-already been submitted. When submitting a bug report, ideally include a [Gist][]
-that includes a stack trace and any details that may be necessary to reproduce
-the bug, including your gem version, Ruby version, and operating system.
-
-
-## Submitting a Pull Request
-1. [Fork the repository.][fork]
-2. [Submit a pull request.][pr]
-
-[free-sw]: http://www.fsf.org/licensing/essays/free-sw.html
-[issues]: https://github.com/rubygems/gems/issues
-[gist]: https://gist.github.com/
-[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/Gemfile

@@ -1,6 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in ruby-processing.gemspec
-gemspec
-
-

data/LICENSE.md

@@ -1,39 +0,0 @@
-Ruby-Processing is released under the MIT License. 
-You can do pretty much whatever you'd like with it.
-
-___
-
-Copyright (c) 2008-2014 omygawshkenas
-
-Permission is hereby granted, free of charge, 
-to any person obtaining a copy of this software 
-and associated documentation files (the "Software"), 
-to deal in the Software without restriction, 
-including without limitation the rights to use, 
-copy, modify, merge, publish, distribute, sublicense, 
-and/or sell copies of the Software, and to permit 
-persons to whom the Software is furnished to do so, 
-subject to the following conditions:
-
-The above copyright notice and this permission 
-notice shall be included in all copies or substantial 
-portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY 
-OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT 
-LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 
-BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-___
-
-Ruby-Processing also distributes core components 
-of both [JRuby][] and [Processing][] both of which are 
-licensed under the GNU lesser public license
-
-[jruby]: http://www.jruby.org/
-[processing]: http://www.processing.org/

data/README.md

@@ -1,119 +0,0 @@
-# Ruby-Processing
-[![Gem Version](https://badge.fury.io/rb/ruby-processing.svg)](http://badge.fury.io/rb/ruby-processing)
-
-Is a ruby wrapper around the [Processing][] code art framework, built using [JRuby][].
-
-[Processing][] provides a tidy API, with a bunch of handy methods you can call 
-  from Ruby-Processing. Here's a smattering:
-  
-  alpha, arc, background, blend, blue, ellipse, frame_rate, hue, lerp, 
-  load_image, load_pixels, mouse_pressed, noise, rect, saturation, shape, 
-  smooth, text_align, translate, triangle...
-
-## Installation
-MacOSX users please try out this new  [method](https://github.com/jashkenas/ruby-processing/wiki/Installing-ruby-processing-on-the-mac)
-
-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.11](http://jruby.org/download))
-
-`install_jruby_complete`
-
-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.11 is only required for application export, and running certain sketches (eg shader sketches see wiki).
-
-
-## Documentation
-
-See [Wiki][]
-
-See also [FAQs][], [Contributing][] and [Samples][]
-
-# Usage Example
-
-```bash
-rp5 run my_sketch.rb 
-```
-
-or if not using system jruby
-
-```bash
-rp5 --nojruby run my_sketch.rb
-```
-
-where a simple ``my_sketch.rb`` could look like this
-
-```ruby
-def setup
-  size 400, 400  
-  fill 255
-end
-
-def draw
-  background 0
-  ellipse mouse_x, mouse_y, 100, 100
-end
-```
-
-or a simple 3D sketch ``cube.rb``
-
-```ruby
-def setup
-  size 640, 360, P3D 
-  @xmag = 0
-  @ymag = 0
-  @new_xmag = 0
-  @new_ymag = 0 
-  fill 200, 50, 50
-end
-
-def draw    
-  background 100    
-  push_matrix    
-  translate width/2, height/2, -30    
-  @new_xmag = mouse_x.to_f / width * TWO_PI
-  @new_ymag = mouse_y.to_f / height * TWO_PI    
-  diff = @xmag - @new_xmag
-  @xmag -= diff / 4 if diff.abs > 0.01    
-  diff = @ymag - @new_ymag
-  @ymag -= diff / 4 if diff.abs > 0.01    
-  rotate_x(-@ymag) 
-  rotate_y(-@xmag)    
-  box 150, 150, 150        
-  pop_matrix        
-end
-
-```
-
-## Supported Ruby Version
-
-This library has been tested with the following ruby implementations
-
-* Ruby 1.9.3
-* Ruby 2.0.0
-* Ruby 2.1.0
-* [JRuby][] preferred (required to use rubygems in sketches)
-
-[License][]
-
-[license]:LICENSE.md
-[contributing]:CONTRIBUTING.md
-[jruby]:http://www.jruby.org/
-[processing]: http://www.processing.org/
-[download]:https://processing.org/download/
-[samples]:https://github.com/jashkenas/ruby-processing/tree/master/samples/
-[wiki]:http://github.com/jashkenas/ruby-processing/wikis/
-[FAQs]:http://github.com/jashkenas/ruby-processing/wikis/FAQs/
-[release]:https://github.com/jashkenas/ruby-processing/releases/
-
-## 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 (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. In my experience ruby-processing works even better with the recently released jdk-8 (try `-XX:+TieredCompilation` option in java_args.txt). But please note you will not be able to use jdk-8 with vanilla-processing, at least for the forseeable future. 
-
-
-

data/Rakefile

@@ -1,37 +0,0 @@
-
-desc 'build and test'    
-task :default => [:build_and_test]
-
-task :build_and_test do
-  Rake::Task["build"].execute
-  Rake::Task["test"].execute
-end
-
-desc 'Build and install gem'
-task :install => :build do
-  sh "gem install #{Dir.glob('*.gem').join(' ')} --no-ri --no-rdoc"
-end
-
-desc 'Uninstall gem'
-task :uninstall do
-  sh "gem uninstall -x ruby-processing"	
-end
-
-desc 'Install jruby-complete'
-task :install_jruby_complete do
-  begin
-    sh "cd vendors && rake"
-  rescue
-    warn("WARNING: you may not have wget installed")	    
-  end
-end
-
-desc 'Build gem'
-task :build do
-  sh "gem build ruby-processing.gemspec"
-end
-
-desc 'Test'
-task :test do
-  ruby "test/rp5_test.rb"	
-end

data/bin/install_jruby_complete

@@ -1,13 +0,0 @@
-#!/usr/bin/env ruby
-
-file = __FILE__
-if test(?l,file)
-  require "pathname"
-  file = Pathname.new(file).realpath
-end
-
-begin
-  system "cd #{File.expand_path(File.dirname(file) +"/../vendors")} && rake"
-rescue
-  warn("WARNING: you may not have wget installed, you could just copy jruby complete to vendors folder instead of installing wget")	
-end

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

@@ -1,7 +0,0 @@
-def setup
-  
-end
-
-def draw
-  
-end

data/library/vecmath/lib/arcball.rb

@@ -1,64 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,232 +0,0 @@
-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
-
-  # The &block option means we can conditionally set_mag to
-  # a limit value for example, when given &block returns true.
-
-  def set_mag(scalar, &block)
-    if block_given? && yield == false
-      return self
-    end      
-    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 mag_squared
-    x**2 + y**2 + z**2
-  end
-
-  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
-
-  # The optional &block should evaluate to a boolean
-  # if given, the set_mag becomes conditional (eg set max/min)
-
-  def set_mag(scalar, &block)
-    if block_given? && yield == false
-      return self
-    end
-    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
-
-
-
-
-