ruby-processing 2.4.4 → 2.5.0

data/samples/external_library/java_processing/toxiclibs/library/vbo/vbo.rb

@@ -0,0 +1,52 @@
+############################################
+# mesh_to_vbo.rb
+# a ruby library to convert toxi.mesh object
+# to vbo (PShape) written by Martin Prout
+# make use of Processing::Proxy mixin
+############################################
+class MeshToVBO
+  include Processing::Proxy
+  
+  attr_reader :parent
+  
+  def initialize(parent)
+    @parent = parent   
+  end
+  
+  def meshToVBO(mesh: nil, smooth: false)
+    retained = parent.createShape()
+    retained.begin_shape(PShape::TRIANGLES)
+    if (smooth)
+      mesh.computeVertexNormals()
+      mesh.getFaces.each do |f|
+        retained.normal(f.a.normal.x, f.a.normal.y, f.a.normal.z)
+        retained.vertex(f.a.x, f.a.y, f.a.z)
+        retained.normal(f.b.normal.x, f.b.normal.y, f.b.normal.z)
+        retained.vertex(f.b.x, f.b.y, f.b.z)
+        retained.normal(f.c.normal.x, f.c.normal.y, f.c.normal.z)
+        retained.vertex(f.c.x, f.c.y, f.c.z)
+      end
+    else
+      mesh.getFaces.each do |f|
+        retained.normal(f.normal.x, f.normal.y, f.normal.z)
+        retained.vertex(f.a.x, f.a.y, f.a.z)
+        retained.vertex(f.b.x, f.b.y, f.b.z)
+        retained.vertex(f.c.x, f.c.y, f.c.z)
+      end
+    end
+    retained.end_shape()
+    return retained
+  end
+  
+  # variant
+  # input array of meshes, output an array of shapes
+  def meshToRetained(mesh_array: [], smooth: false)
+    rshapes = []
+    (0 ... mesh.length).each do |i|
+      rshapes.push(meshToVBO(mesh: mesh[i], smooth: smth))
+    end
+    return rshapes
+  end
+end
+
+

data/samples/external_library/java_processing/toxiclibs/model_align.rb

@@ -5,7 +5,7 @@
 #
 # (c) 2012 Karsten Schmidt / LGPL2 licensed
 #
-load_libraries 'toxiclibscore', 'toxiclibs_p5', 'colorutils'
+load_libraries :toxiclibscore, :toxiclibs_p5, :colorutils, :vecmath
 
 module Toxi
   include_package 'toxi.geom'
@@ -19,20 +19,16 @@ attr_reader :gfx, :positions
 
 def setup
   size(640,480,P3D)
+  ArcBall.init(self)
   @gfx = Toxi::ToxiclibsSupport.new(self)
-  @positions = []
   # compute mesh positions on circle in XZ plane
-  (Toxi::Circle.new(200).toPolygon2D(8)).each do |p|
-    positions << p.to3DXZ
-  end
+  @positions = (Toxi::Circle.new(200).toPolygon2D(8)).map{ |p| p.to3DXZ}
 end
 
 def draw
   background(51)
   lights
   no_stroke
-  translate(width/2,height/2,0)
-  rotate_x(-PI/6)
   # create manual focal point in XY plane
   focus = Toxi::Vec3D.new((mouse_x - width/2), (mouse_y - height/2), 0)
   # create mesh prototype to draw at all generated positions
@@ -40,16 +36,13 @@ def draw
   m = Toxi::AABB.new(25).to_mesh
   # draw focus
   gfx.box(Toxi::AABB.new(focus, 5))
-  positions.each do |p|
-    # align the positive z-axis of mesh to point at focus
-    # mesh needs to be located at world origin for it to work correctly
-    # only once rotated, move it to actual position
-    gfx.mesh(m.copy.pointTowards(focus.sub(p), Toxi::Vec3D::Z_AXIS).translate(p))
-  end
+  # align the positive z-axis of mesh to point at focus
+  # mesh needs to be located at world origin for it to work correctly
+  # only once rotated, move it to actual position
+  positions.map {|p| gfx.mesh(m.copy.pointTowards(focus.sub(p), Toxi::Vec3D::Z_AXIS).translate(p))}
+  
   # draw connections from mesh centers to focal point
   stroke(0,255,255)
-  positions.each do |p|
-    gfx.line(p, focus)
-  end
+  positions.map {|p| gfx.line(p, focus)}
 end
 

data/samples/processing_app/basics/color/color_wheel.rb

@@ -29,7 +29,7 @@ def create_wheel( x, y, value_shift )
   rot_adjust  = (360.0 / segs / 2.0) * PI / 180
   radius      = 170.0
   seg_width   = radius / steps
-  interval    = TWO_PI / segs
+  interval    = TAU / segs
   
   case value_shift
   when :shade

data/samples/processing_app/basics/form/regular_polygon.rb

@@ -35,9 +35,9 @@ def draw
 end
 
 def polygon(x, y, radius, npoints)
-  angle = TWO_PI / npoints
+  angle = TAU / npoints
   begin_shape
-  (0 .. TWO_PI).step(angle) do |a|
+  (0 .. TAU).step(angle) do |a|
     sx = x + cos(a) * radius
     sy = y + sin(a) * radius
     vertex(sx, sy)

data/samples/processing_app/basics/form/rgb_cube.rb

@@ -39,8 +39,8 @@ def draw
   background 1    
   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    
+  @new_xmag = mouse_x.to_f / width * TAU
+  @new_ymag = mouse_y.to_f / height * TAU    
   diff = @xmag - @new_xmag
   @xmag -= diff / 4 if diff.abs > 0.01    
   diff = @ymag - @new_ymag

data/samples/processing_app/basics/form/shape_primitives.rb

@@ -18,6 +18,6 @@ ellipse 252, 144, 72, 72
 fill 204
 triangle 288, 18, 351, 360, 288, 360 
 fill(255)
-arc(479, 300, 280, 280, PI, TWO_PI)
+arc(479, 300, 280, 280, PI, TAU)
 
 

data/samples/processing_app/basics/form/star.rb

@@ -33,10 +33,10 @@ def draw
 end
 
 def star(x, y, radius1, radius2, npoints)
-  angle = TWO_PI / npoints
+  angle = TAU / npoints
   half_angle = angle/2.0
   begin_shape
-  (0 .. TWO_PI).step(angle) do |a|
+  (0 .. TAU).step(angle) do |a|
     sx = x + cos(a) * radius2
     sy = y + sin(a) * radius2
     vertex(sx, sy)

data/samples/processing_app/basics/input/clock.rb

@@ -1,40 +1,45 @@
 # The current time can be read with the second(), minute(), 
 # and hour() functions. In this example, sin() and cos() values
 # are used to set the position of the hands.
-
+load_library :fastmath
 
 def setup
   size 200, 200
   stroke 255
-  smooth
+  smooth 4
 end
 
 def draw
   background 0
   fill 80
-  no_stroke
-  
-  # Angles for sin() and cos() start at 3 o'clock;
-  # subtract HALF_PI to make them start at the top
-  ellipse 100, 100, 160, 160
-  
-  s = map( second, 0, 60, 0, TWO_PI) - HALF_PI
-  m = map( minute + norm( second, 0, 60 ), 0, 60, 0, TWO_PI ) - HALF_PI
-  h = map( hour + norm( minute, 0, 60 ), 0, 24, 0, TWO_PI * 2 ) - HALF_PI
+  no_stroke 
+
+  ellipse 100, 100, 160, 160 
   
   stroke 255
   stroke_weight 1
-  line( 100, 100, cos(s)*72 + 100, sin(s)*72 + 100 )
+  line( 100, 100, calc_hand_x(second, 0, 72, 100), calc_hand_y(second, 0, 72, 100) )
   stroke_weight 2
-  line( 100, 100, cos(m)*60 + 100, sin(m)*60 + 100 )
+  line( 100, 100, calc_hand_x(minute, second, 60, 100), calc_hand_y(minute, second, 60, 100) )
   stroke_weight 4
-  line( 100, 100, cos(h)*50 + 100, sin(h)*50 + 100 )
+  line( 100, 100, calc_hand_x(hour, minute, 50, 100), calc_hand_y(hour, minute, 50, 100) )
   
   # Draw the minute ticks
   stroke_weight 2
   (0..360).step(6) do |a|
-    x = 100 + cos( a.radians ) * 72
-    y = 100 + sin( a.radians ) * 72
+    x = 100 + DegLut.cos(a) * 72
+    y = 100 + DegLut.sin(a) * 72
     point x, y
   end
 end
+
+# Angles for sin() and cos() start at 3 o'clock;
+# subtract 90 degrees to make them start at the top
+
+def calc_hand_x(time, time_bit, length, origin)
+  DegLut.cos(time * 6  + time_bit / 10 - 90) * length + origin
+end
+
+def calc_hand_y(time, time_bit, length, origin)
+  DegLut.sin(time * 6  + time_bit / 10 - 90) * length + origin
+end

data/samples/processing_app/basics/input/storing_input.rb

@@ -9,14 +9,14 @@
 #
  
 NUM = 60
-X = 0
-Y = 1
-
+ 
 attr_reader :pos
 
+Vec = Struct.new(:x, :y)
+
 def setup  
   size(640, 360)
-  @pos = Array.new(NUM, Array.new(2, 0))  # initialize a nested array
+  @pos = Array.new(NUM, Vec.new(0, 0))  # initialize a array of Vec Struct
   smooth(4)
   noStroke()
   fill(255, 153) 
@@ -28,11 +28,11 @@ def draw
   # Cycle through the array, using a different entry on each frame. 
   # Using modulo (%) like this is faster than moving all the values over.
   which = frame_count % NUM
-  pos[which] = [mouse_x, mouse_y]
+  pos[which] = Vec.new(mouse_x, mouse_y)
   
   (1 .. NUM).each do |i|
     # which + 1 is the smallest (the oldest in the array)
     idx = (which + i) % NUM
-    ellipse(pos[idx][X], pos[idx][Y], i, i)
+    ellipse(pos[idx].x, pos[idx].y, i, i)
   end
 end

data/samples/processing_app/basics/math/additive_wave.rb

@@ -18,7 +18,7 @@ def setup
   @max_waves.times do |i|
     amplitude << rand(10 .. 30)
     period = rand(100 .. 300) # How many pixels before the wave repeats
-    dx << (TWO_PI / period) * @x_spacing
+    dx << (TAU / period) * @x_spacing
   end
   
   frame_rate 30

data/samples/processing_app/basics/math/sine.rb

@@ -26,10 +26,10 @@ def draw
     rotate angle_rot - 45
     ellipse(-116, 0, @diameter, @diameter)
     pop_matrix
-    angle_rot += TWO_PI/5
+    angle_rot += TAU/5
   }  	
   @diameter = 34 * sin( @angle ) + 168
   @angle += 0.02
-  #@angle = 0.0 if @angle > TWO_PI  
+  #@angle = 0.0 if @angle > TAU  
 end
 

data/samples/processing_app/basics/math/sine_cosine.rb

@@ -2,7 +2,7 @@
 # Sine Cosine. 
 # 
 # Linear movement with sin() and cos(). 
-# Numbers between 0 and PI*2 (TWO_PI which angles roughly 6.28) 
+# Numbers between 0 and PI*2 (TAU which angles roughly 6.28) 
 # are put into these functions and numbers between -1 and 1 are 
 # returned. These values are then scaled to produce larger movements.
 # note only angle1 angle2 need scope outside draw loop

data/samples/processing_app/basics/math/sine_wave.rb

@@ -11,7 +11,7 @@ def setup
   @w = width + 16
   @period = 500.0
   @x_spacing = 8
-  @dx = (TWO_PI / @period) * @x_spacing
+  @dx = (TAU / @period) * @x_spacing
   @y_values = []
   @theta = 0.0
   @amplitude = 75.0

data/samples/processing_app/basics/objects/inheritance.rb

@@ -4,6 +4,8 @@
 # programming terminology, one class can inherit fields and methods from another. 
 # An object that inherits from another is called a subclass, and the object it 
 # inherits from is called a superclass. A subclass extends the superclass.
+# see also inheritance_two for the use of hash args and inheritance that 
+# avoids the inherited class call to super 
 
 
 def setup    

data/samples/processing_app/basics/objects/inheritance_two.rb

@@ -0,0 +1,88 @@
+# Inheritance
+# 
+# A class can be defined using another class as a foundation. In object-oriented
+# programming terminology, one class can inherit fields and methods from another. 
+# An object that inherits from another is called a subclass, and the object it 
+# inherits from is called a superclass. A subclass extends the superclass.
+# NB: note the use of hook means inheriting class does not need to call super
+
+
+def setup    
+  size 640, 360
+  @arm = SpinArm.new({ x: width/2, y: height/2, s: 0.01 })
+  @spots = SpinSpots.new({ x: width/2, y: height/2, s: -0.02, d: 90.0 })
+end
+
+def draw
+  background 204  	
+  @arm.display
+  @spots.display
+end
+
+# vvv CLASS SPIN
+
+class Spin
+  
+  attr_accessor :x, :y, :speed
+  attr_accessor :angle
+  
+  def initialize(args = {})  	    
+    @x, @y = args[:x], args[:y]
+    @speed = args[:s]
+    @angle = args[:angle] || 0.0
+    post_initialize(args)  # this is the hook
+  end
+  
+  def update  	    
+    @angle += speed
+  end
+  
+  def post_initialize args
+    nil
+  end
+  
+end
+
+# ^^^ CLASS SPIN
+
+# vvv CLASS SPINARM
+
+class SpinArm < Spin # inherit from (or "extend") class Spin
+  # NB: initialize inherited from Spin class
+  
+  def display  		
+    stroke_weight 1
+    stroke 0  		
+    push_matrix  		
+    translate x, y
+    update
+    rotate angle
+    line 0, 0, 165, 0
+    pop_matrix
+  end  	
+end
+
+# ^^^ CLASS SPINARM
+
+# vvv CLASS SPINSPOTS
+
+class SpinSpots < Spin    
+  attr_accessor :dim
+  
+  def post_initialize args
+    @dim = args[:d]
+  end
+  
+  def display  	    
+    no_stroke  		
+    push_matrix  		
+    translate x, y
+    update
+    rotate angle
+    ellipse(-dim/2, 0, dim, dim) 
+    ellipse(dim/2, 0, dim, dim)  
+    pop_matrix
+  end  	
+end
+
+# ^^^ CLASS SPINSPOTS

data/samples/processing_app/basics/objects/module.rb

@@ -0,0 +1,89 @@
+# Ruby modules, are another way of extending a classes behaviour, the class 
+# ParticleSystem includes Enumerable (from ruby core) and our custom Runnable 
+# module. Here we use the module Runnable to capture behaviour that can be 
+# shared between different classes. Modules are also very useful for wrapping 
+# imported classes (wrapped packages can then be called using convenient names).
+
+# This example is bit complicated, because Enumerable and Forwardable are used
+# to make the ParticleSystem behave as though it were an Array. This is very
+# convenient and is preferred to ParticleSystem subclassing Array.
+
+# Ported from http://processing.org/learning/topics/simpleparticlesystem.html
+
+
+require 'forwardable'
+
+load_library :vecmath
+
+attr_reader :ps
+
+def setup
+  size(640,360)
+  @ps = ParticleSystem.new(Vec2D.new(width/2, 50))
+end
+
+def draw
+  background(0)
+  ps.add_particle
+  ps.run
+end
+
+module Runnable
+  def run
+    self.reject! { |item| item.lifespan <= 0 }
+    self.each    { |item| item.run   }
+  end
+end
+
+class ParticleSystem 
+  extend Forwardable
+  def_delegators(:@particle_system, :each, :<<, :reject!)  
+  include Enumerable 
+  include Runnable
+  
+  attr_reader :origin
+ 
+  def initialize(loc)
+    @particle_system = []
+    @origin = Vec2D.new(loc.x, loc.y)
+  end
+  
+  def add_particle
+    self << Particle.new(origin) 
+  end
+  
+end
+
+# A simple Particle class
+
+class Particle 
+  include Processing::Proxy 
+  
+  attr_reader :loc, :vel, :acc, :lifespan
+  def initialize(loc) 
+    @acc = Vec2D.new(0, 0.05)
+    @vel = Vec2D.new(rand(-1.0 .. 1), rand(-2.0 .. 0))
+    @loc = loc    # loc.clone is unecessary in ruby
+    @lifespan = 255.0
+  end
+
+  def run
+    update
+    display
+  end
+
+  # Method to update loc
+  def update
+    @vel += acc
+    @loc += vel
+    @lifespan -= 1.0
+  end
+
+  # Method to display
+  def display
+    stroke(255,lifespan)
+    fill(255,lifespan)
+    ellipse(loc.x, loc.y, 8, 8)
+  end
+  
+end