ruby-processing 2.4.4 → 2.5.0

data/samples/processing_app/library/vecmath/{simple_particle_system.rb → vec2d/simple_particle_system.rb}

@@ -3,6 +3,8 @@
 # Particles are generated each cycle, fall with gravity and fade out over
 # time. A ParticleSystem (Array) object manages a variable size list of
 # particles.
+require 'forwardable'
+
 load_library :vecmath
 
 attr_reader :ps
@@ -26,30 +28,24 @@ module Runnable
 end
 
 class ParticleSystem 
-  extend Enumerable 
+  extend Forwardable
+  def_delegators(:@particle_system, :each, :<<, :reject!, :empty?)
+  include Enumerable 
   include Runnable
   
-  attr_reader :origin, :particle_system
+  attr_reader :origin
 
   def initialize(loc)
     @particle_system = []
     @origin = Vec2D.new(loc.x, loc.y)
   end
   
-  def each &block
-    particle_system.each &block    
-  end
-  
   def add_particle
-    particle_system << Particle.new(origin) 
-  end
-  
-  def reject! &block
-    particle_system.reject! &block
+    self << Particle.new(origin) 
   end
   
   def dead?
-    particle_systems.empty?
+    self.empty?
   end 
 
 end

data/samples/processing_app/library/vecmath/{smoke_particle_system.rb → vec2d/smoke_particle_system.rb}

@@ -3,7 +3,8 @@
 #
 # A ParticleSystem (Array) object manages a variable size list of
 # particles.
-
+require 'forwardable'
+ 
 load_library :vecmath
 
 attr_reader :ps, :img, :wind
@@ -26,7 +27,7 @@ def draw
   end
   
   # Draw a horizontal arrow representing the wind force
-  draw_vector(wind, Vec2D.new(width / 2, 50, 0), 500)
+  draw_vector(wind, Vec2D.new(width / 2, 50), 500)
   
 end
 
@@ -58,10 +59,12 @@ end
 
 
 class ParticleSystem 
-  extend Enumerable
+  extend Forwardable
+  def_delegators(:@particles, :reject!, :<<, :each)
+  include Enumerable
   include Runnable
   
-  attr_reader :particles, :origin, :image, :generator
+  attr_reader :origin, :image, :generator
   
   def initialize(num, location, image)
     @particles = []
@@ -72,16 +75,8 @@ class ParticleSystem
     end
   end
   
-  def each &block
-    particles.each &block    
-  end
-
-  def reject! &block
-    particles.reject! &block
-  end
-  
   def add_particle(p = Particle.new(origin, image))
-    particles << p
+    self << p
   end
   
   # Method to add a force vector to all particles currently in the system

data/samples/processing_app/library/vecmath/{library/wiggler/wiggler.rb → vec2d/wiggle_pshape.rb}

@@ -1,32 +1,55 @@
+#
+# WigglePShape. Demonstrates initialization and use of ShapeRender,
+# that allows us to send Vec2D to PShape vertex
+# 
+# How to move the individual vertices of a PShape
+#
+load_library :vecmath
+
+attr_reader :wiggler
+
+def setup
+  size(640, 360, P2D)
+  @wiggler = Wiggler.new width, height
+end
+
+def draw
+  background(255)
+  wiggler.display
+  wiggler.wiggle
+end
+
 # An object that wraps the PShape
 
 
 class Wiggler
   include Processing::Proxy
-  attr_reader :original, :x, :y, :s, :yoff, :xoff
+  attr_reader :original, :x, :y, :s, :yoff, :xoff, :renderer
 
   def initialize width, height
     @x = width/2
     @y = height/2 
     @yoff = 0
+    
     # The "original" locations of the vertices make up a circle
 
-    @original = (0 ... 5 * TAU).map{|a| Vec2D.from_angle(a * 0.2) * 100}
+    @original = (0 ... 16).map{|a| Vec2D.from_angle(PI * a / 8) * 100}
     
     # Now make the PShape with those vertices
     @s = create_shape
+    @renderer = ShapeRender.new(s)
     s.begin_shape
     s.fill(127)
     s.stroke(0)
     s.stroke_weight(2)
-    original.map{ |v| s.vertex(v.x, v.y)}
+    original.map{|v| v.to_vertex(renderer)}
     s.end_shape(CLOSE)
   end
 
   def wiggle
     @xoff = 0
     # Apply an offset to each vertex
-    rad = -> (pos){(Vec2D.from_angle(TAU * noise(xoff, yoff)) * 4) + pos}
+    rad = ->(pos){(Vec2D.from_angle(TAU * noise(xoff, yoff)) * 4) + pos}
     
     original.each_with_index do |pos, i| 
       # Calculate a new vertex location based on noise around "original" location
@@ -48,3 +71,4 @@ class Wiggler
   end
 end
 
+

data/samples/processing_app/library/vecmath/vec3d/Rakefile

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

data/samples/processing_app/library/vecmath/vec3d/drawolver.rb

@@ -0,0 +1,86 @@
+# Drawolver: draw 2D & revolve 3D
+
+# Example shows how to use the vecmath library, including AppRender utility.
+# On the ruby side features the use each_cons, a possibly a rare use for this
+# ruby Enumerable method?
+# 2010-03-22 - fjenett (somewhat revised by Martin Prout 2014-07-06)
+
+load_library :vecmath, :fastmath
+
+attr_reader :drawing_mode, :points, :rot_x, :rot_y, :vertices, :renderer
+
+def setup
+  size 1024, 768, P3D
+  @renderer = AppRender.new(self)
+  frame_rate 30
+  reset_scene
+end
+
+def draw
+  background 0
+  unless drawing_mode
+    translate(width / 2, height / 2)
+    rotate_x rot_x
+    rotate_y rot_y
+    @rot_x += 0.01
+    @rot_y += 0.02
+    translate(-width / 2, -height / 2)
+  end
+  no_fill
+  stroke 255
+  points.each_cons(2) { |ps, pe| line ps.x, ps.y, pe.x, pe.y }
+  unless drawing_mode
+    stroke 125
+    fill 120
+    lights
+    ambient_light 120, 120, 120
+    vertices.each_cons(2) do |r1, r2|
+      begin_shape(TRIANGLE_STRIP)
+      r1.zip(r2).each do |v1, v2|
+        v1.to_vertex(renderer)
+        v2.to_vertex(renderer)
+      end
+      end_shape
+    end
+  end
+end
+
+def reset_scene
+  @drawing_mode = true
+  @points = []
+  @rot_x = 0.0
+  @rot_y = 0.0
+end
+
+def mouse_pressed
+  reset_scene
+  points << Vec3D.new(mouse_x, mouse_y)
+end
+
+def mouse_dragged
+  points << Vec3D.new(mouse_x, mouse_y)
+end
+
+def mouse_released
+  points << Vec3D.new(mouse_x, mouse_y)
+  recalculate_shape
+end
+
+def recalculate_shape
+  @vertices = []
+  points.each_cons(2) do |ps, _pe_|
+    b = (points.last - points.first).normalize!
+    a = ps - points.first
+    dot_product = a.dot b
+    b *= dot_product
+    normal = points.first + b
+    c = ps - normal
+    vertices << []
+    (0..360).step(12) do |ang|
+      e = normal + c * DegLut.cos(ang)
+      e.z = c.mag * DegLut.sin(ang)
+      vertices.last << e
+    end
+  end
+  @drawing_mode = false
+end

data/samples/processing_app/library/vecmath/vec3d/frame_of_reference.rb

@@ -0,0 +1,103 @@
+###############
+# Frame of Reference example by Ira Greenberg
+# https://github.com/irajgreenberg/ProcessingTips
+# Translated to ruby-processing by Martin Prout January 2014
+###############
+
+load_libraries :fastmath, :vecmath
+load_library :geometry
+
+FACE_COUNT = 50
+
+attr_reader :c, :p, :renderer
+
+def setup
+  size(800, 800, P3D)
+  ArcBall.init(self, width / 2.0, height / 2.0) # user supplied center
+  @renderer = AppRender.new(self)
+  @c = []
+  @p = []
+  FACE_COUNT.times do |i|
+
+    # calc some random triangles in 3 space
+    val = Vec3D.new(rand(-width/2 .. width/2), rand(-width/2 .. width/2), rand(-width/2 .. width/2))
+    v0 = Vec3D.new(rand(-val.x .. -val.x + 100), rand(-val.y .. -val.y + 100), rand(-val.z .. -val.z + 100))
+    v1 = Vec3D.new(rand(-val.x .. -val.x + 100), rand(-val.y .. -val.y + 100), rand(-val.z .. -val.z + 100))
+    v2 = Vec3D.new(rand(-val.x .. -val.x + 100), rand(-val.y .. -val.y + 100), rand(-val.z .. -val.z + 100))
+    p << Plane.new([v0, v1, v2])
+
+    # build some cute little cylinders
+    c << Cylinder.new(Vec3D.new(150, 5, 5), 12)
+
+    # Using each Triangle normal (N),
+    # One of the Triangle's edges as a tangent (T)
+    # Calculate a bi-normal (B) using the cross-product between each N and T
+    # Note caps represent constants in ruby so we used N = nn, T = tt and B = bb in the ruby code below
+
+    #
+    # A picture helps
+    # nice, sweet orthogonal axes
+
+    # N   B
+    # |  /
+    # | /
+    # |/____T
+
+    #
+    # N, T, B together give you a Frame of Reference (cute little local coordinate system), based on each triangle.
+    # You can then take the cylinder (or any vertices) and transform them using a 3 x 3 matrix to this coordinate system.
+    # (In the matrix each column is based on N, T and B respecivley.)
+    # The transform will handle any rotations and scaling, but not the translation,
+    # but we can add another dimenson to the matrix to hold the translation values.
+    # Here's what all this confusing description looks like:
+
+    #
+    # Matrix :                               Vector :
+    # |  N.x  T.x  B.x  translation.x  |      |  x  |
+    # |  N.y  T.y  B.y  translation.y  |      |  y  |
+    # |  N.z  T.z  B.z  translation.z  |      |  z  |
+    # |  0    0    0    1              |      |  1  |
+
+    # We add the extra row in the matrix and the 1 to each vector
+    # so the math works. We describe the Matrix as 4 rows by 4 columns
+    # and the vector now as a Matrix with 4 rows and 1 column.
+    # When you multiply matrices the inner numbers MUST match, so:
+    # [4 x 4] [4 x 1] is OK, but [4 x 4] [1 x 4] is NOT COOL.
+
+    # (Please note there is also row vector approach that you can
+    # Google about; it simply puts the vector on left side of matrix and treats
+    # it as a 1 row and 4 column matrix. However, you'll also need to shift
+    # the translation terms to the bottom of the matrix for the math to grock.)
+
+    # The Matrix multiplication looks like this (sorry it's a little tedious looking.)
+    # n.x * x + t.x *y + B.x * z + translation.x * 1  =  new transformed x
+    # n.y * x + t.y *y + B.y * z + translation.y * 1  =  new transformed y
+    # n.z * x + t.z *y + B.z * z + translation.z * 1  =  new transformed z
+    # 0 * x + 0 *y + 0 * z + 1 * 1   =   disregard this crap.
+    #
+
+    nn = p[i].n
+    tt = Vec3D.new(p[i].vecs[1].x - p[i].vecs[0].x, p[i].vecs[1].y - p[i].vecs[0].y, p[i].vecs[1].z - p[i].vecs[0].z)
+    nn.normalize!
+    tt.normalize!
+    bb = nn.cross(tt)
+    bb.normalize! # not really needed
+
+    # build matrix with frame and translation (to centroid of each triangle)
+    m4 = Mat4.new(nn, tt, bb, p[i].c)
+
+    # transform each cylinder to align with each triangle
+    c[i].vecs = m4.mult(c[i].vecs)
+  end
+  fill(187)
+  stroke(50, 20)
+end
+
+def draw
+  background(0)
+  lights
+  FACE_COUNT.times do |i|
+    p[i].display(renderer)
+    c[i].display(renderer)
+  end
+end

data/samples/processing_app/library/vecmath/{hilbert_fractal.rb → vec3d/hilbert_fractal.rb}

@@ -3,42 +3,27 @@
 # Lindenmayer System in ruby-processing by Martin Prout
 # Demonstrates arcball rotation hold down z, y or z key
 # to constrain to that axis of rotation. Otherwise get
-# intuitive rotation with dragged mouse.
+# intuitive rotation using mouse drag.
 ########################################################
 
 load_libraries :hilbert, :vecmath
 
-attr_reader :hilbert, :arcball
+attr_reader :hilbert, :renderer
 
 def setup
   size 1024, 768, P3D
-  @arcball = ArcBall.new(width/2.0, height/2.0, min(width - 20, height - 20) * 0.5)
-  @hilbert = Hilbert.new(size: height/2, gen: 3)
+  ArcBall.init(self, width / 2.0, height / 2.0)
+  @hilbert = Hilbert.new(size: height / 2, gen: 3)
   no_stroke
 end
 
 def draw
   background 0
-  translate(width/2.0, height/2.0) 
-  update
   lights
   define_lights
   ambient(40)
   specular(15)
-  hilbert.render
-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)
+  hilbert.draw
 end
 
 def define_lights
@@ -49,17 +34,4 @@ def define_lights
   spot_light(30, 30, 30, 0, 40, 200, 0, -0.5, 0.5, PI / 2, 2)
 end
 
-def key_pressed                
-  case(key)
-when 'x'
-  arcball.select_axis(X)
-when 'y'
-  arcball.select_axis(Y)
-when 'z'
-  arcball.select_axis(Z)
-end
-end
 
-def key_released
-  arcball.select_axis(-1)
-end