ruby-processing 2.4.4 → 2.5.0

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

@@ -0,0 +1,3 @@
+require_relative 'lib/plane.rb'
+require_relative 'lib/mat4.rb'
+require_relative 'lib/cylinder.rb'

data/samples/processing_app/library/vecmath/vec3d/library/geometry/lib/cylinder.rb

@@ -0,0 +1,44 @@
+class Cylinder
+  include Processing::Proxy
+  attr_accessor :vecs
+  attr_reader :detail, :dim  
+  
+  def initialize(dim, detail)
+    @dim = dim
+    @detail = detail
+    init
+  end
+  
+  def init
+    #    created around x-axis
+    #    y = Math.cos
+    #    z = Math.sin
+    veca = []
+    vecb = []
+    (0 ... 360).step(360 / detail) do |theta|
+      cost = DegLut.cos(theta)
+      sint = DegLut.sin(theta)
+      veca << Vec3D.new(0, cost * dim.y, sint * dim.z)
+      vecb << Vec3D.new(dim.x, cost * dim.y, sint * dim.z)
+    end
+    @vecs = veca.concat(vecb)
+  end
+  
+  def display(renderer)
+    begin_shape(QUADS)
+    detail.times do |i|
+      if i < (detail - 1)
+        vecs[i].to_vertex(renderer)
+        vecs[i + 1].to_vertex(renderer)
+        vecs[detail + i + 1].to_vertex(renderer)
+        vecs[detail + i].to_vertex(renderer)
+      else
+        vecs[i].to_vertex(renderer)
+        vecs[0].to_vertex(renderer)
+        vecs[detail].to_vertex(renderer)
+        vecs[detail + i].to_vertex(renderer)
+      end
+    end
+    end_shape
+  end
+end

data/samples/processing_app/library/vecmath/vec3d/library/geometry/lib/mat4.rb

@@ -0,0 +1,28 @@
+# uber simple Homogeneous 4 x 4 matrix
+
+class Mat4
+  attr_reader :mat
+
+  def initialize(axisX, axisY, axisZ, trans)
+    @mat = [
+            [axisX.x, axisY.x, axisZ.x, trans.x],
+	    [axisX.y, axisY.y, axisZ.y, trans.y],
+	    [axisX.z, axisY.z, axisZ.z, trans.z],
+	    [0, 0, 0,  1]
+           ]
+  end 
+  
+  # The processing version changes the input 'array', here we return
+  # a new array with transformed values (which we then assign to the input)
+  # see line 89 Frame_of_Reference.rb
+
+  def mult(array)
+    array.map { |arr|
+      xt = mat[0][0] * arr.x + mat[0][1] * arr.y + mat[0][2] * arr.z + mat[0][3] * 1
+      yt = mat[1][0] * arr.x + mat[1][1] * arr.y + mat[1][2] * arr.z + mat[1][3] * 1
+      zt = mat[2][0] * arr.x + mat[2][1] * arr.y + mat[2][2] * arr.z + mat[2][3] * 1
+      Vec3D.new(xt, yt, zt)
+    }
+  end
+end
+

data/samples/processing_app/library/vecmath/vec3d/library/geometry/lib/plane.rb

@@ -0,0 +1,60 @@
+NORM_LEN = 225.0
+
+class Plane
+  include Processing::Proxy
+  
+  attr_reader :vecs, :c, :n
+
+
+  def initialize(vecs)
+    @vecs = vecs
+    init
+  end
+  
+  def init    
+    v1 = vecs[1] - vecs[0] 
+    v2 = vecs[2] - vecs[0]  
+    
+    @c = Vec3D.new(
+      (vecs[0].x + vecs[1].x + vecs[2].x) / 3, 
+      (vecs[0].y + vecs[1].y + vecs[2].y) / 3, 
+      (vecs[0].z + vecs[1].z + vecs[2].z) / 3
+      )
+    
+    @n = v1.cross(v2)
+    n.normalize!
+  end
+  
+  def display(renderer)
+    begin_shape(TRIANGLES)
+    vecs.map { |vec| vec.to_vertex(renderer) }
+    end_shape
+    
+    #normal
+    stroke(200, 160, 30)
+    begin_shape(LINES)
+    c.to_vertex(renderer)
+    (c + n * NORM_LEN).to_vertex(renderer)
+    end_shape
+    
+    #binormal
+    stroke(160, 200, 30)
+    begin_shape(LINES)
+    c.to_vertex(renderer)
+    # tangent
+    v = vecs[1].copy
+    #v.set(vecs[1])
+    v -= vecs[0]
+    v.normalize!
+    (c + v * NORM_LEN).to_vertex(renderer)
+    end_shape
+    
+    stroke(30, 200, 160)
+    begin_shape(LINES)
+    c.to_vertex(renderer)
+    b = v.cross(n)
+    (c + b * NORM_LEN).to_vertex(renderer)
+    end_shape
+    stroke(0, 75)
+  end
+end

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

@@ -39,20 +39,18 @@ class Hilbert
   :theta, :distance, :phi, :gen, :adj_array
 
   def initialize(size: 1.0, gen: 1)
-    @axiom = "X"                                           # AXIOM
-    @rule = {"X" => "^<XF^<XFX-F^>>XFX&F+>>XFX-F>X->"}     # RULE
+    @axiom = 'X'                                           # AXIOM
+    @rule = {'X' => '^<XF^<XFX-F^>>XFX&F+>>XFX-F>X->'}     # RULE
     @gen = gen
     @grammar = Grammar.new(axiom, rule) 
     @production = grammar.generate gen
     @distance = size / (gen**2 - 1)
     @theta = radians 90
     @phi = radians 90  
-    @adj_array = [0,  0.5,  1.5,  3.5,  7.5, 15].map{|x| Vec3D.new(x * -1, x, x * -1)}
-
+    @adj_array = [0, 0.5, 1.5, 3.5, 7.5, 15].map { |x| Vec3D.new(x * -1, x, x * -1) }
   end
 
-  def render()    
-    #translate( -distance * ADJUSTMENT[gen], distance *  ADJUSTMENT[gen], -distance * ADJUSTMENT[gen])
+  def draw    
     adj = adj_array[gen] * distance
     translate(adj.x, adj.y, adj.z)
     fill(0, 75, 152)
@@ -61,27 +59,26 @@ class Hilbert
     shininess(1.0)
     production.each do |ch|
       case(ch)
-      when "F"
-        translate(0, distance/-2, 0)
+      when 'F'
+        translate(0, distance / -2, 0)
         box(distance/9 , distance, distance/9)
-        translate(0, distance/-2, 0)
-      when "+"
+        translate(0, distance / -2, 0)
+      when '+'
         rotateX(-theta)
-      when "-"
+      when '-'
         rotateX(theta)
-      when ">"
+      when '>'
         rotateY(theta)
-      when "<"
+      when '<'
         rotateY(-theta)
-      when "&"
+      when '&'
         rotateZ(-phi)
-      when "^"
+      when '^'
         rotateZ(phi)
-      when "X"
+      when 'X'
       else
         puts("character '#{ch}' not in grammar")
       end
     end
   end
-
 end   

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

@@ -5,22 +5,16 @@
 ##########################
 
 load_library 'vecmath'
-import "vecmath"
 
 PTS = [-1, 0, 1]
 MIN_SIZE = 20
-X = 0
-Y = 1
-Z = 2
 
-attr_reader :arcball, :menger
+attr_reader :menger
 
 def setup
   size(640, 480, P3D)
   smooth(8)
-  camera
-  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)
+  ArcBall.init(self)
   @menger = create_shape(GROUP)
   create_menger(0, 0, 0, height * 0.8)
 end
@@ -29,28 +23,27 @@ def draw
   background(20, 20, 200)
   no_stroke
   lights
-  update
-  define_lights
+  define_light
   render
-end    
+end
 
 def render
   menger.set_fill(color(224, 223, 219))
-  menger.set_ambient(50)  
-  menger.set_specular(150) 
+  menger.set_ambient(50)
+  menger.set_specular(150)
   shape(menger)
 end
 
 def create_menger(xx, yy, zz, sz)
   u = sz / 3.0
-  if (sz < MIN_SIZE) # recursion limited by minimum cube size
+  if sz < MIN_SIZE # recursion limited by minimum cube size
     no_stroke
-    menger.add_child(create_cube(xx, yy, zz, sz)) # create and add a cube  
+    menger.add_child(create_cube(xx, yy, zz, sz)) # create and add a cube
   else
     PTS.each do |i|
       PTS.each do |j|
         PTS.each do |k|
-          if ((i.abs + j.abs + k.abs) > 1) 
+          if (i.abs + j.abs + k.abs) > 1
             create_menger(xx + (i * u), yy + (j * u), zz + (k * u), u)
           end
         end
@@ -70,41 +63,41 @@ def create_cube(xx, yy, zz, sz)
   cube.vertex(+dim + xx, -dim + yy, -dim + zz)
   cube.vertex(+dim + xx, +dim + yy, -dim + zz)
   cube.vertex(-dim + xx, +dim + yy, -dim + zz)
-  
+
   # Back face
-  
+
   cube.normal(0, 0, -1)
   cube.vertex(-dim + xx, -dim + yy, +dim + zz)
   cube.vertex(+dim + xx, -dim + yy, +dim + zz)
   cube.vertex(+dim + xx, +dim + yy, +dim + zz)
   cube.vertex(-dim + xx, +dim + yy, +dim + zz)
-  
+
   # Left face
-  
+
   cube.normal(1, 0, 0)
   cube.vertex(-dim + xx, -dim + yy, -dim + zz)
   cube.vertex(-dim + xx, -dim + yy, +dim + zz)
   cube.vertex(-dim + xx, +dim + yy, +dim + zz)
   cube.vertex(-dim + xx, +dim + yy, -dim + zz)
-  
+
   # Right face
-  
+
   cube.normal(-1, 0, 0)
   cube.vertex(+dim + xx, -dim + yy, -dim + zz)
   cube.vertex(+dim + xx, -dim + yy, +dim + zz)
   cube.vertex(+dim + xx, +dim + yy, +dim + zz)
   cube.vertex(+dim + xx, +dim + yy, -dim + zz)
-  
+
   # Top face
-  
+
   cube.normal(0, 1, 0)
   cube.vertex(-dim + xx, -dim + yy, -dim + zz)
   cube.vertex(+dim + xx, -dim + yy, -dim + zz)
   cube.vertex(+dim + xx, -dim + yy, +dim + zz)
   cube.vertex(-dim + xx, -dim + yy, +dim + zz)
-  
+
   # Bottom face
-  
+
   cube.normal(0, -1, 0)
   cube.vertex(-dim + xx, +dim + yy, -dim + zz)
   cube.vertex(+dim + xx, +dim + yy, -dim + zz)
@@ -112,19 +105,6 @@ def create_cube(xx, yy, zz, sz)
   cube.vertex(-dim + xx, +dim + yy, +dim + zz)
   cube.end_shape
   return cube
-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
 
 def define_lights
@@ -132,19 +112,4 @@ def define_lights
   point_light(30, 30, 30, 200, 240, 0)
   directional_light(50, 50, 50, 1, 0, 0)
   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
+end

data/samples/processing_app/topics/advanced_data/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 --nojruby run #{sample_name}", "r") do |io|
+  open("|rp5 --nojruby run #{sample_name}", 'r') do |io|
     while l = io.gets
-      puts(l.chop) 
+      puts(l.chop)
     end      
   end
 end

data/samples/processing_app/topics/advanced_data/counting_words.rb

@@ -15,8 +15,8 @@ end
 ################################
 # This sketch is translated from a vanilla processing sketch by Daniel Schiffman
 # that was designed to demonstrate the use IntHash class in vanilla processing.
-# Similar results can easily be obtained using more idiomatic ruby. Here IntHash 
-# has been replaced by a String => Word hash (as used in a Schiffman prototype). 
+# Similar results can easily be obtained using more idiomatic ruby. Here IntHash
+# has been replaced by a String => Word hash (as used in a Schiffman prototype).
 # Read about concordance here:-
 # http://en.wikipedia.org/wiki/Concordance_(publishing)
 ################################
@@ -28,15 +28,15 @@ def setup
   @counter = 0
   @concordance = {}
   # Open a file, read its contents, and 'scan' for words using a regex.
-  # Include words with apostrophe eg Harker's 
-  @tokens = File.read(data_path("dracula.txt")).scan(/[\w'-]+/)
-  text_font(create_font("Georgia", 24))
+  # Include words with apostrophe eg Harker's
+  @tokens = File.read(data_path('dracula.txt')).scan(/[\w'-]+/)
+  text_font(create_font('Georgia', 24))
 end
 
 def draw
   background 51
   fill 255
-  s = (tokens[counter] == "I")? tokens[counter] : tokens[counter].downcase
+  s = (tokens[counter] == 'I')? tokens[counter] : tokens[counter].downcase
   @counter = (counter + 1) % tokens.length
   if (concordance.has_key?(s))
     # Get the word object and increase the count
@@ -44,7 +44,7 @@ def draw
     w = concordance[s]
     w.increment    # increment word count
   else
-    # Otherwise make a new Word instance and add it to 
+    # Otherwise make a new Word instance and add it to
     # the Hash using the word String as the key
     concordance[s] = Word.new(s)
   end

data/samples/processing_app/topics/advanced_data/data/data.xml

@@ -20,19 +20,4 @@
     <diameter>44.758068</diameter>
     <label>Melancholy</label>
   </bubble>
-  <bubble>
-    <position x="556" y="224"/>
-    <diameter>46.89752406647077</diameter>
-    <label>New label</label>
-  </bubble>
-  <bubble>
-    <position x="433" y="239"/>
-    <diameter>47.570771727260535</diameter>
-    <label>New label</label>
-  </bubble>
-  <bubble>
-    <position x="479" y="91"/>
-    <diameter>65.08462326872998</diameter>
-    <label>New label</label>
-  </bubble>
 </bubbles>