ruby-processing 1.0.11 → 2.4.1

data/library/vecmath/vecmath.rb

@@ -0,0 +1,323 @@
+EPSILON = 9.999999747378752e-05     # a value used by processing.org
+
+class Vec 
+  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 to_a
+    [x, y, z]
+  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 to_s
+    "#{self.class}(Use Vec2D, Vec3D or make your own subclass)"  
+  end
+
+  def inspect
+    self.to_s
+  end
+end
+
+
+class Vec2D < Vec
+
+  def to_a
+    [x, y]
+  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)	  
+    @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_s
+    "#{self.class}(x=#{x}, y=#{y})"  
+  end
+  
+  alias :mag :modulus 
+
+end
+
+class Vec3D < Vec
+
+  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)
+    @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
+
+  alias :mag :modulus 
+
+end
+
+
+class Quaternion
+    
+  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
+
+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/ruby-processing.gemspec

@@ -0,0 +1,54 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ruby-processing/version'
+
+Gem::Specification.new do |spec|
+  spec.name = "ruby-processing"
+  spec.version = RubyProcessing::VERSION
+  spec.authors = ["Jeremy Ashkenas", "Peter Gassner", "Martin Stannard", "Andrew Nanton",
+               "Marc Chung", "Peter Krenn", "Florian Jenett", "Andreas Haller",
+               "Juris Galang", "Guillaume Pierronnet", "Martin Prout"]
+  spec.email = "jeremy@ashkenas.com"
+  spec.description = <<-EOS
+
+  Ruby-Processing is a Ruby wrapper for the Processing code art framework. It's
+  this thin little shim that squeezes between Processing and JRuby, passing
+  along some neat goodies like:
+
+  * Application exporting of your sketches. Hand them out to your party guests, 
+    ready-to-run.
+
+  * Live Coding via JRuby's IRB. Loads in your sketch so you can futz with
+    variables and remake methods on the fly.
+
+  * Bare sketches. Write your Ruby-Processing sketches without having to define
+    a class. Without defining methods, even.
+
+  * A "Control Panel" library, so that you can easily create sliders, buttons,
+    checkboxes and drop-down menus, and hook them into your sketch's instance
+    variables.
+
+  * "Watch" mode, where Ruby-Processing keeps an eye on your sketch and reloads
+    it from scratch every time you make a change. A pretty nice REPL-ish way
+    to work on your Processing sketches.
+
+  EOS
+  spec.summary = %q{Code as Art, Art as Code. Processing and Ruby are meant for each other.}
+  spec.homepage = "http://wiki.github.com/jashkenas/ruby-processing"
+  spec.executables = ["rp5", "install_jruby_complete"]
+  spec.license = 'MIT'
+  
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'minitest'
+  spec.requirements << 'A decent graphics card'
+  spec.requirements << 'java runtime >= 1.6+'
+  spec.requirements << 'processing = 2.0.3+'
+ 
+end
+

data/samples/contributed/animator.rb

@@ -6,12 +6,12 @@
 FRAME_COUNT = 12
 
 def setup
+  size 350, 350
   @frames         = []
   @last_time      = 0
   @current_frame  = 0
   @draw           = false
-  @back_color     = 204
-  size 350, 350
+  @back_color     = 204  
   stroke_weight 4
   smooth
   background @back_color
@@ -27,8 +27,13 @@ def draw
   line(pmouse_x, pmouse_y, mouse_x, mouse_y) if @draw
 end
 
-def mouse_pressed; @draw = true; end
-def mouse_released; @draw = false; end
+def mouse_pressed
+  @draw = true
+end
+
+def mouse_released
+  @draw = false
+end
 
 def key_pressed
   background @back_color

data/samples/contributed/bezier_playground.rb

@@ -1,29 +1,24 @@
 # 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
-  
+module Olap
   def self.overlaps(x, y, point_x, point_y)
-    Math.sqrt((x-point_x)**2 + (y-point_y)**2) < Bezier::RADIUS 
+    Math.sqrt((x-point_x)**2 + (y-point_y)**2) < RADIUS 
   end
-  
 end
 
-
 class Curve
-  
+  include Olap
   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)
+    @x1, @y1, @x2, @y2 = X1, Y1, X2, Y2
+    set_control_points(X1+30, Y1, X2-30, Y2)
   end
   
-  
   def contains(x, y)
-    return :one if Math.overlaps(@x1, @y1, x, y)
-    return :two if Math.overlaps(@x2, @y2, x, y)
+    return :one if Olap::overlaps(@x1, @y1, x, y)
+    return :two if Olap::overlaps(@x2, @y2, x, y)
   end
   
   
@@ -61,181 +56,180 @@ class Curve
 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
-    size 700, 700
-    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
+attr_accessor :curves, :c1x, :c1y, :c2x, :c2y
+attr_reader :panel
+
+X1, Y1, X2, Y2 = 50.0, 50.0, 250.0, 250.0
+REDDISH = [250, 100, 100]
+RADIUS = 7
+
+load_library :control_panel
+include Olap
+
+def setup
+  size 300, 300
+  @curves = []    
+  control_panel do |c|
+    c.look_feel "Nimbus"
+    c.button :new_curve
+    c.button :print_equations
+    @panel = c
+  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 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
-    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
+  when LEFT # Flip forward
+    @current = (@current + 1) % @curves.length
+  when RIGHT # Flip back
+    @current = (@current - 1) % @curves.length
   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
+  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 then @c1x += x_off and @c1y += y_off
+  when :two then @c2x += x_off and @c2y += y_off
   end
-    
-  
-  def draw
-    background 50
-    draw_control_tangent_lines
-    draw_curves
-    draw_current_control_points
+  current_curve.set_control_points(*control_points)
+end
+
+
+def move_end_point(x_off, y_off)
+  c = current_curve
+  case @end_point
+  when :one then c.x1 += x_off and c.y1 += y_off
+  when :two then c.x2 += x_off and c.y2 += y_off
   end
-  
 end
 
-Bezier.new
+
+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
+  panel.visible = self.visible
+  background 50
+  draw_control_tangent_lines
+  draw_curves
+  draw_current_control_points
+end
+
+