ruby-processing 2.4.4 → 2.5.0

data/samples/processing_app/{library/vecmath/drawolver.rb → basics/objects/module_two.rb}

@@ -1,7 +1,7 @@
 # Drawolver: draw 2D & revolve 3D
 
 # Example to show how to use the VecMath library.
-# Also the Array is extended to yield one_of_each 
+# Also the Array is extended to yield one_of_each using a module
 # pair of pts. See the drawolver library. Also features the use each_cons, 
 # possibly a rare use for this ruby Enumerable method?
 # 2010-03-22 - fjenett (last revised by monkstone 2013-09-13)

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

@@ -14,6 +14,7 @@
 # But there are two ways to define methods with variable parameters. One is to give the 
 # parameters a default value, the second is to use the catch-all asterix:
 
+
 # def my_method1 ( a, b = "2" ) # can be called with one or two arguments
 # end
 
@@ -21,6 +22,10 @@
 # end
 
 
+# Martin Prout, 2014-06-23:
+# even more flexibility can be had by passing a hash see inheritance_two @todo update for ruby-2.1+
+
+
 def setup    
   size 640, 360    
   background 204

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

@@ -0,0 +1,38 @@
+#
+# Storing Data as a Struct 
+# 
+# Move the mouse across the screen to change the position
+# of the circles. The positions of the mouse are recorded
+# into an array and played back every frame. Between each
+# frame, the newest value are added to the end of each array
+# and the oldest value is deleted. 
+#
+ 
+NUM = 60
+ 
+attr_reader :pos
+
+Vec = Struct.new(:x, :y) # create named Struct Type with getters and setters
+
+def setup  
+  size(640, 360)
+  @pos = Array.new(NUM, Vec.new(0, 0))  # initialize a array of Struct
+  smooth(4)
+  no_stroke()
+  fill(255, 153) 
+end
+
+def draw
+  background(51) 
+  
+  # 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] = 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)
+  end
+end

data/samples/processing_app/basics/structure/recursion2.rb

@@ -14,7 +14,7 @@ def draw_circle (x, y, radius, level)
     level = level - 1
     num = rand(2 .. 6)  		
     0.upto(num-1) do |i|  			
-      a = rand(0 .. TWO_PI)
+      a = rand(0 .. TAU)
       nx = x + cos(a) * 8.0 * level
       ny = y + sin(a) * 6.0 * level
       draw_circle nx, ny, radius / 2, level

data/samples/processing_app/basics/transform/birds.rb

@@ -13,20 +13,17 @@ def setup
   size 640, 360, P3D
   no_stroke
   lights
-  @birds = []  
-  0.upto(BIRD_COUNT) do |i|    
-    bird = Bird.new rand(-300 .. 300), rand(-300 .. 300), rand(-2500 .. -500), rand(5 .. 30), rand(5 .. 30)    
-    bird.set_flight rand(20 .. 340), rand(30 .. 350), rand( 1000 .. 4800 ),
-    rand(-160 .. 160), rand(-55 .. 55), rand(-20 .. 20)    
-    bird.set_wing_speed rand(0.1 .. 3.75)
-    bird.set_rot_speed rand(0.025 .. 0.15)    
-    @birds << bird
-  end  
+  @birds = (0 .. BIRD_COUNT).map {     
+    Bird.new(rand(-300 .. 300), rand(-300 .. 300), rand(-2500 .. -500), rand(5 .. 30), rand(5 .. 30))   
+    .set_flight(rand(20 .. 340), rand(30 .. 350), rand( 1000 .. 4800 ), rand(-160 .. 160), rand(-55 .. 55), rand(-20 .. 20))    
+    .set_wing_speed(rand(0.1 .. 3.75))
+    .set_rot_speed(rand(0.025 .. 0.15))    
+  } 
 end
 
 def draw  
   background 0  
   translate width/2, height/2, -700  
-  @birds.each {|b| b.fly} 
+  @birds.map {|b| b.fly} 
 end
 

data/samples/processing_app/basics/transform/library/bird/bird.rb

@@ -28,19 +28,19 @@ class Bird
 	end
 
 	def set_flight ( radius_x, radius_y, radius_z, rot_x, rot_y, rot_z )
-
 		@radius_x, @radius_y, @radius_z = radius_x, radius_y, radius_z
 		@rot_x, @rot_y, @rot_z = rot_x, rot_y, rot_z
+		return self  # return self means we can chain methods
 	end
 
 	def set_wing_speed ( flap_speed )
-
 		@flap_speed = flap_speed
+		return self  # return self means we can chain methods
 	end
 
 	def set_rot_speed ( rot_speed )
-
 		@rot_speed = rot_speed
+		return self  # return self means we can chain methods
 	end
 
 	def fly

data/samples/processing_app/basics/transform/rotate.rb

@@ -2,7 +2,7 @@
 # 
 # Rotating a square around the Z axis. To get the results
 # you expect, send the rotate function angle parameters that are
-# values between 0 and PI*2 (TWO_PI which is roughly 6.28). If you prefer to 
+# values between 0 and PI*2 (TAU which is roughly 6.28). If you prefer to 
 # think about angles as degrees (0-360), you can use the radians() 
 # method to convert your values. For example: scale(radians(90))
 # is identical to the statement scale(PI/2). 

data/samples/processing_app/basics/transform/rotate1.rb

@@ -16,7 +16,7 @@ end
 def draw    
   	background 0  	
   	@a += 0.005
-  	@a = 0.0 if @a > TWO_PI  	
+  	@a = 0.0 if @a > TAU  	
   	translate width/2, height/2  	
   	rotate_x @a
   	rotate_y @a * 2

data/samples/processing_app/basics/transform/rotate_x_y.rb

@@ -20,7 +20,7 @@ end
 def draw  
   background(126)  
   @a += 0.005
-  @a = 0.0 if (a > TWO_PI) 
+  @a = 0.0 if (a > TAU) 
   translate(width/2, height/2)
   
   rotate_x(a)

data/samples/processing_app/demos/graphics/bezier_patch.rb

@@ -19,7 +19,7 @@ attr_accessor :outp, :inp, :normp, :auto_normals, :arcball, :bez_patch
  
 def setup
   size(1024, 768, P3D)
-  @arcball = ArcBall.new(width/2.0, height/2.0, min(width - 20, height - 20) * 0.5)
+  ArcBall.init(self, width/2.0, height/2.0)
   @auto_normals = false
   build_geometry
   @bez_patch = build_shape
@@ -27,12 +27,10 @@ end
  
 def draw
   background(255)
-  translate(width/2,height/2)
   smooth(8)
   lights
   define_lights
   scale(0.9)
-  update
   no_stroke 
   shape(bez_patch)
 end
@@ -169,24 +167,6 @@ def d_bezier_blend( k, mu,  n)
   return(dblendf) 
 end
 
-######################
-# ArcBall control
-# and lighting + re-run
-######################
-
-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    
   ambient_light(40, 40, 40)
   point_light(30, 30, 30, 0, 0, 0)
@@ -194,21 +174,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 ' '
-    save_frame("bezPatch.png")
-    build_geometry
-    @bez_patch = build_shape
-  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

data/samples/processing_app/demos/graphics/trefoil.rb

@@ -1,6 +1,10 @@
 # Trefoil, by Andres Colubri
 # A parametric surface is textured procedurally
 # by drawing on an offscreen PGraphics surface.
+#
+# Features (Vec3D).to_normal(renderer) and (Vec3D).to_vertex_uv(renderer, u, v)
+# see line 62 for inititialization of renderer where obj is an instance of PShape
+# renderer = ShapeRender.new(obj)
 
 load_library :vecmath
 
@@ -10,7 +14,7 @@ def setup
   size(1024, 768, P3D)
   
   texture_mode(NORMAL)
-  noStroke
+  no_stroke
 
   # Creating offscreen surface for 3D rendering.
   @pg = create_graphics(32, 512, P3D)
@@ -28,7 +32,7 @@ def draw
   background(0)
   
   pg.begin_draw    
-  pg.ellipse(rand * pg.width, rand * pg.height, 4, 4)
+  pg.ellipse(rand(0.0 .. pg.width), rand(0.0 .. pg.height), 4, 4)
   pg.end_draw 
 
   ambient(250, 250, 250)
@@ -43,7 +47,7 @@ def draw
 end
 
 # Code to draw a trefoil knot surface, with normals and texture 
-# coordinates.
+# coordinates. Makes of the Vec3D Render interface (uses ShapeRender here).
 # Adapted from the parametric equations example by Philip Rideout:
 # http://iphone-3d-programming.labs.oreilly.com/ch03.html
 
@@ -52,12 +56,13 @@ end
 def create_trefoil(s, ny, nx, tex)
  
   obj = create_shape()
+  
   obj.begin_shape(TRIANGLES)
   obj.texture(tex)
-    
+  renderer = ShapeRender.new(obj)
   (0 ... nx).each do |j|
     u0 = j.to_f / nx
-    u1 = (j + 1).to_f / nx
+    u1 = (j + 1).to_f / nx 
     (0 ... ny).each do |i|
       v0 = i.to_f / ny
       v1 = (i + 1).to_f / ny
@@ -72,23 +77,23 @@ def create_trefoil(s, ny, nx, tex)
       n2 = eval_normal(u1, v1)
 
       # Triangle p0-p1-p2      
-      obj.normal(n0.x, n0.y, n0.z)
-      obj.vertex(s * p0.x, s * p0.y, s * p0.z, u0, v0)      
-      obj.normal(n1.x, n1.y, n1.z)
-      obj.vertex(s * p1.x, s * p1.y, s * p1.z, u0, v1)
-      obj.normal(n2.x, n2.y, n2.z)
-      obj.vertex(s * p2.x, s * p2.y, s * p2.z, u1, v1)
+      n0.to_normal(renderer)
+      (p0 * s).to_vertex_uv(renderer, u0, v0)     
+      n1.to_normal(renderer)
+      (p1 * s).to_vertex_uv(renderer, u0, v1)
+      n2.to_normal(renderer)
+      (p2 * s).to_vertex_uv(renderer, u1, v1)
 
       p1 = eval_point(u1, v0)
       n1 = eval_normal(u1, v0)
 
       # Triangle p0-p2-p1      
-      obj.normal(n0.x, n0.y, n0.z)
-      obj.vertex(s * p0.x, s * p0.y, s * p0.z, u0, v0)      
-      obj.normal(n2.x, n2.y, n2.z)
-      obj.vertex(s * p2.x, s * p2.y, s * p2.z, u1, v1)
-      obj.normal(n1.x, n1.y, n1.z)
-      obj.vertex(s * p1.x, s * p1.y, s * p1.z, u1, v0)      
+      n0.to_normal(renderer)
+      (p0 * s).to_vertex_uv(renderer, u0, v0) 
+      n2.to_normal(renderer)
+      (p2 * s).to_vertex_uv(renderer, u1, v1) 
+      n1.to_normal(renderer)
+      (p1 * s).to_vertex_uv(renderer, u1, v0)       
     end
   end
   obj.end_shape
@@ -104,9 +109,7 @@ def eval_normal(u, v)
   tangV = eval_point(u, v + 0.01)
   tangU -= p
   tangV -= p
-  
-  normUV = tangV.cross(tangU)  
-  return normUV.normalize!
+  tangV.cross(tangU).normalize! # it is easy to chain Vec3D operations
 end
 
 # Evaluates the surface point corresponding to normalized 
@@ -119,24 +122,31 @@ def eval_point(u, v)
   s = TAU * u
   t = (TAU * (1 - v)) * 2  
         
-  r = a + b * cos(1.5 * t)
-  x = r * cos(t)
-  y = r * sin(t)
-  z = c * sin(1.5 * t)
-        
-  dv = Vec3D.new
-  dv.x = -1.5 * b * sin(1.5 * t) * cos(t) - (a + b * cos(1.5 * t)) * sin(t)
-  dv.y = -1.5 * b * sin(1.5 * t) * sin(t) + (a + b * cos(1.5 * t)) * cos(t)
-  dv.z = 1.5 * c * cos(1.5 * t)
-        
-  dv.normalize!                  
-  qvn = Vec3D.new(dv.y, -dv.x, 0)
-  qvn.normalize!           
-  ww = dv.cross(qvn)
-        
-  pt = Vec3D.new
-  pt.x = x + d * (qvn.x * cos(s) + ww.x * sin(s))
-  pt.y = y + d * (qvn.y * cos(s) + ww.y * sin(s))
-  pt.z = z + d * ww.z * sin(s)
-  return pt
+  sint = sin(t)
+  cost = cos(t)
+  sint15 = sin(1.5 * t)
+  cost15 = cos(1.5 * t)
+
+  r = a + b * cost15
+  x = r * cost
+  y = r * sint
+  z = c * sint15
+
+  dv = Vec3D.new(
+  -1.5 * b * sint15 * cost - y,
+  -1.5 * b * sint15 * sint + x,
+  1.5 * c * cost15)
+
+  q = dv.normalize     # regular normalize creates a new Vec3D for us
+  qvn = Vec3D.new(q.y, -q.x, 0).normalize!  # chained Vec3D operations
+
+  ww = q.cross(qvn)
+
+  coss = cos(s)
+  sins = sin(s)
+
+  Vec3D.new(
+  x + d * (qvn.x * coss + ww.x * sins),
+  y + d * (qvn.y * coss + ww.y * sins),
+  z + d * ww.z * sins)
 end

data/samples/processing_app/demos/graphics/wiggling.rb

@@ -10,10 +10,20 @@ NOISE_MAG = 1.0
 # signature-specific alias for overloaded method 
 java_alias :background_int, :background, [Java::int]
 
+attr_reader :sine, :cosine
  
 def setup
-  size(1024, 768, P3D);    
-  wiggling = false
+  size(1024, 768, P3D);
+  @sine = []
+  @cosine = []
+  wiggling = false 
+  # Dry up that processing code a tiny bit
+  (0 .. TAU).step(TAU / CIRCLE_RES) do |i|
+    sine << CIRCLE_RAD * sin(i)
+  end
+  (0 .. TAU).step(TAU / CIRCLE_RES) do |i|
+    cosine << CIRCLE_RAD * cos(i)
+  end
   @cube = create_cube
 end
 
@@ -72,9 +82,8 @@ def create_cube
   face.end_contour
   face.begin_contour
   CIRCLE_RES.times do |i|
-    angle = TAU * i / CIRCLE_RES
-    x = CIRCLE_RAD * sin(angle)
-    y = CIRCLE_RAD * cos(angle)
+    x = sine[i]
+    y = cosine[i]
     z = CUBE_SIZE / 2
     face.vertex(x, y, z)
   end
@@ -95,9 +104,8 @@ def create_cube
   face.end_contour
   face.begin_contour
   CIRCLE_RES.times do |i|
-    angle = TAU * i / CIRCLE_RES
-    x = CIRCLE_RAD * sin(angle)
-    y = CIRCLE_RAD * cos(angle)
+    x = sine[i]
+    y = cosine[i]
     z = -CUBE_SIZE / 2
     face.vertex(x, y, z)
   end
@@ -118,10 +126,9 @@ def create_cube
   face.end_contour
   face.begin_contour
   CIRCLE_RES.times do |i|
-    angle = TAU * i / CIRCLE_RES
     x = CUBE_SIZE / 2
-    y = CIRCLE_RAD * sin(angle)
-    z = CIRCLE_RAD * cos(angle)
+    y = sine[i]
+    z = cosine[i]
     face.vertex(x, y, z)
   end
   face.end_contour
@@ -141,10 +148,9 @@ def create_cube
   face.end_contour
   face.begin_contour
   CIRCLE_RES.times do |i|
-    angle = TAU * i / CIRCLE_RES
     x = -CUBE_SIZE / 2
-    y = CIRCLE_RAD * sin(angle)
-    z = CIRCLE_RAD * cos(angle)
+    y = sine[i]
+    z = cosine[i]
     face.vertex(x, y, z)
   end
   face.end_contour
@@ -164,10 +170,9 @@ def create_cube
   face.end_contour
   face.begin_contour
   CIRCLE_RES.times do |i|
-    angle = TAU * i / CIRCLE_RES
-    x = CIRCLE_RAD * sin(angle)
+    x = sine[i]
     y = CUBE_SIZE / 2
-    z = CIRCLE_RAD * cos(angle)
+    z = cosine[i]
     face.vertex(x, y, z)
   end
   face.end_contour
@@ -187,10 +192,9 @@ def create_cube
   face.end_contour
   face.begin_contour
   CIRCLE_RES.times do |i|
-    angle = TAU * i / CIRCLE_RES
-    x = CIRCLE_RAD * sin(angle)
+    x = sine[i]
     y = -CUBE_SIZE / 2
-    z = CIRCLE_RAD * cos(angle)
+    z = cosine[i]
     face.vertex(x, y, z)
   end
   face.end_contour
@@ -209,9 +213,8 @@ def restore_cube
   face.set_vertex(2, CUBE_SIZE / 2, CUBE_SIZE / 2, CUBE_SIZE / 2)
   face.set_vertex(3, -CUBE_SIZE / 2, CUBE_SIZE / 2, CUBE_SIZE / 2)
   CIRCLE_RES.times do |i|
-    angle = TAU * i / CIRCLE_RES
-    x = CIRCLE_RAD * sin(angle)
-    y = CIRCLE_RAD * cos(angle)
+    x = sine[i]
+    y = cosine[i]
     z = CUBE_SIZE / 2
     face.set_vertex(4 + i, x, y, z)
   end
@@ -223,9 +226,8 @@ def restore_cube
   face.set_vertex(2, -CUBE_SIZE / 2, CUBE_SIZE / 2, -CUBE_SIZE / 2)
   face.set_vertex(3, CUBE_SIZE / 2, CUBE_SIZE / 2, -CUBE_SIZE / 2)
   CIRCLE_RES.times do |i|
-    angle = TAU * i / CIRCLE_RES
-    x = CIRCLE_RAD * sin(angle)
-    y = CIRCLE_RAD * cos(angle)
+    x = sine[i]
+    y = cosine[i]
     z = -CUBE_SIZE / 2
     face.set_vertex(4 + i, x, y, z)
   end
@@ -237,10 +239,9 @@ def restore_cube
   face.set_vertex(2, CUBE_SIZE / 2, CUBE_SIZE / 2, -CUBE_SIZE / 2)
   face.set_vertex(3, CUBE_SIZE / 2, CUBE_SIZE / 2, CUBE_SIZE / 2)
   CIRCLE_RES.times do |i|
-    angle = TAU * i / CIRCLE_RES
     x = CUBE_SIZE / 2
-    y = CIRCLE_RAD * sin(angle)
-    z = CIRCLE_RAD * cos(angle)
+    y = sine[i]
+    z = cosine[i]
     face.set_vertex(4 + i, x, y, z)
   end
   
@@ -251,10 +252,9 @@ def restore_cube
   face.set_vertex(2, -CUBE_SIZE / 2, CUBE_SIZE / 2, CUBE_SIZE / 2)
   face.set_vertex(3, -CUBE_SIZE / 2, CUBE_SIZE / 2, -CUBE_SIZE / 2)
   CIRCLE_RES.times do |i|
-    angle = TAU * i / CIRCLE_RES
     x = -CUBE_SIZE / 2
-    y = CIRCLE_RAD * sin(angle)
-    z = CIRCLE_RAD * cos(angle)
+    y = sine[i]
+    z = cosine[i]
     face.set_vertex(4 + i, x, y, z)
   end    
   
@@ -265,10 +265,9 @@ def restore_cube
   face.set_vertex(2, CUBE_SIZE / 2, CUBE_SIZE / 2, -CUBE_SIZE / 2)
   face.set_vertex(3, -CUBE_SIZE / 2, CUBE_SIZE / 2, -CUBE_SIZE / 2)
   CIRCLE_RES.times do |i|
-    angle = TAU * i / CIRCLE_RES
-    x = CIRCLE_RAD * sin(angle)
+    x = sine[i]
     y = CUBE_SIZE / 2
-    z = CIRCLE_RAD * cos(angle)
+    z = cosine[i]
     face.set_vertex(4 + i, x, y, z)
   end    
   
@@ -279,10 +278,9 @@ def restore_cube
   face.set_vertex(2, -CUBE_SIZE / 2, -CUBE_SIZE / 2, -CUBE_SIZE / 2)
   face.set_vertex(3, CUBE_SIZE / 2, -CUBE_SIZE / 2, -CUBE_SIZE / 2)
   CIRCLE_RES.times do |i|
-    angle = TAU * i / CIRCLE_RES
-    x = CIRCLE_RAD * sin(angle)
+    x = sine[i]
     y = -CUBE_SIZE / 2
-    z = CIRCLE_RAD * cos(angle)
+    z = cosine[i]
     face.set_vertex(4 + i, x, y, z)
   end
 end