ruby-processing 1.0.11 → 2.4.1

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

@@ -1,25 +1,23 @@
-require 'ruby-processing'
-
 # The basic shape primitive functions are triangle, rect, 
 # quad, and ellipse. Squares are made with rect and circles 
 # are made with ellipse. Each of these functions requires a number
 # of parameters to determine the shape's position and size.
 
 
-class ShapePrimitives < Processing::App
+size 640, 360
+background 0 
+no_stroke
+fill 204 
+triangle 18, 18, 18, 360, 81, 360 
+fill 102
+rect 81, 81, 63, 63 
+fill 204
+quad 189, 18, 216, 18, 216, 360, 144, 360 
+fill 255
+ellipse 252, 144, 72, 72
+fill 204
+triangle 288, 18, 351, 360, 288, 360 
+fill(255)
+arc(479, 300, 280, 280, PI, TWO_PI)
 
-  def setup
-	smooth   
-	background 0 
-	no_stroke
-	fill 226 
-	triangle 10, 10, 10, 200, 45, 200 
-	rect 45, 45, 35, 35 
-	quad 105, 10, 120, 10, 120, 200, 80, 200 
-	ellipse 140, 80, 40, 40 
-	triangle 160, 10, 195, 200, 160, 200  
-  end
-  
-end
 
-ShapePrimitives.new :title => "Shape Primitives", :width => 200, :height => 200

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

@@ -0,0 +1,88 @@
+# Shape Transform
+# by Ira Greenberg.  
+# 
+# Illustrates the geometric relationship 
+# between Cube, Pyramid, Cone and 
+# Cylinder 3D primitives.
+# 
+# Instructions:
+# Up Arrow - increases points
+# Down Arrow - decreases points
+# 'p' key toggles between cube/pyramid
+
+
+
+def setup
+  
+  size 640, 360, P3D
+  
+  no_stroke
+  
+  @angle_inc = PI/300
+  
+  @pts = 4
+  @angle = 0
+  @radius = 99
+  @cylinder_length = 95
+  
+  @is_pyramid = false
+  
+end
+
+def draw
+  
+  background 170, 95, 95
+  lights
+  fill 255, 200, 200
+  
+  translate width/2, height/2
+  rotate_x frame_count * @angle_inc
+  rotate_y frame_count * @angle_inc
+  rotate_z frame_count * @angle_inc
+  
+  vertices = []
+  
+  (0...2).each { |i|
+    @angle = 0
+    vertices[i] = []
+    0.upto(@pts) { |j|
+      pvec = PVector.new 0, 0
+      (
+        pvec.x = cos(radians( @angle )) * @radius
+        pvec.y = sin(radians( @angle )) * @radius
+        
+        ) unless ( @is_pyramid && i == 1 )
+        
+        pvec.z = @cylinder_length
+        vertices[i][j] = pvec
+        
+        @angle += 360.0/@pts
+    }
+    @cylinder_length *= -1
+  }
+  
+  begin_shape QUAD_STRIP
+    0.upto(@pts) { |j|
+      vertex vertices[0][j].x, vertices[0][j].y, vertices[0][j].z
+      vertex vertices[1][j].x, vertices[1][j].y, vertices[1][j].z
+    }
+    end_shape
+    
+    [0,1].each { |i|
+      begin_shape
+        0.upto(@pts) { |j|
+          vertex vertices[i][j].x, vertices[i][j].y, vertices[i][j].z
+        }
+        end_shape CLOSE
+    }
+    
+  end
+  
+  def key_pressed    
+    if key == CODED
+      @pts += 1 if keyCode == UP && @pts < 90
+      @pts -= 1 if keyCode == DOWN && @pts > 4
+    end    
+    @is_pyramid = !@is_pyramid if key.eql? "p"    
+  end
+  

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

@@ -0,0 +1,48 @@
+#
+# Star
+# 
+# The star function created for this example is capable of drawing a
+# wide range of different forms. Try placing different numbers into the 
+# star function calls within draw to explore. 
+#
+
+def setup
+  size(640, 360)
+end
+
+def draw
+  background(102)
+  
+  push_matrix
+  translate(width*0.2, height*0.5)
+  rotate(frame_count / 200.0)
+  star(0, 0, 5, 70, 3) 
+  pop_matrix
+  
+  push_matrix
+  translate(width*0.5, height*0.5)
+  rotate(frame_count / 50.0)
+  star(0, 0, 80, 100, 40) 
+  pop_matrix
+  
+  push_matrix
+  translate(width*0.8, height*0.5)
+  rotate(frame_count / -100.0)
+  star(0, 0, 30, 70, 5) 
+  pop_matrix
+end
+
+def star(x, y, radius1, radius2, npoints)
+  angle = TWO_PI / npoints
+  half_angle = angle/2.0
+  begin_shape
+  (0 .. TWO_PI).step(angle) do |a|
+    sx = x + cos(a) * radius2
+    sy = y + sin(a) * radius2
+    vertex(sx, sy)
+    sx = x + cos(a + half_angle) * radius1
+    sy = y + sin(a + half_angle) * radius1
+    vertex(sx, sy)
+  end
+  end_shape(CLOSE)
+end

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

@@ -0,0 +1,127 @@
+# Interactive Toroid
+# by Ira Greenberg. 
+# 
+# Illustrates the geometric relationship between Toroid, Sphere, and Helix
+# 3D primitives, as well as lathing principal.
+# 
+# Instructions: 
+# 	UP arrow key ____ pts++ 
+# 	DOWN arrow key __ pts-- 
+# 	LEFT arrow key __ segments-- 
+# 	RIGHT arrow key _ segments++ 
+# 	'a' key _________ toroid radius-- 
+# 	's' key _________ toroid radius++ 
+# 	'z' key _________ initial polygon radius-- 
+# 	'x' key _________ initial polygon radius++ 
+# 	'w' key _________ toggle wireframe/solid shading 
+# 	'h' key _________ toggle sphere/helix 
+
+
+
+
+def setup
+    
+    size 640, 360, P3D
+    
+    @pts = 40
+    @angle = 0.0
+    @radius = 60.0
+    @segments = 60.0
+    @lathe_angle = 0.0
+    @lathe_radius = 100.0
+    @is_wireframe = false
+    @is_helix = false
+    @helix_offset = 5.0
+    
+end
+
+def draw
+    
+    background 50, 64, 42
+    
+    lights
+    
+    if @is_wireframe
+        stroke 255, 255, 150
+        no_fill
+    else
+        no_stroke
+        fill 150, 195, 125
+    end
+    
+    translate width/2, height/2, -100
+    
+    rotate_x frame_count * PI / 150
+    rotate_y frame_count * PI / 170
+    rotate_z frame_count * PI / 90
+    
+    vertices = []
+    vertices2 = []
+    
+    0.upto(@pts) { |i|
+        
+        vertices2[i] = PVector.new
+        vertices[i] = PVector.new
+        
+        vertices[i].x = @lathe_radius + sin( radians( @angle ) ) * @radius
+        
+        if @is_helix
+            vertices[i].z = cos( radians( @angle ) ) * @radius - (@helix_offset * @segments) / 2
+        else
+            vertices[i].z = cos( radians( @angle ) ) * @radius
+        end
+        
+        @angle += 360.0 / @pts
+    }
+    
+    @lathe_angle = 0
+    
+    0.upto(@segments) { |i|
+        begin_shape QUAD_STRIP
+            (0..@pts).each { |j|
+                vertex_for_pvector vertices2[j] if i > 0
+                
+                vertices2[j].x = cos( radians( @lathe_angle ) ) * vertices[j].x
+                vertices2[j].y = sin( radians( @lathe_angle )
+                    ) * vertices[j].x
+                vertices2[j].z = vertices[j].z
+                
+                vertices[j].z += @helix_offset if @is_helix
+                
+                vertex_for_pvector vertices2[j]
+            }
+            
+            @lathe_angle += (@is_helix ? 720 : 360) / @segments
+            end_shape
+    }
+    
+end
+
+def vertex_for_pvector ( pvec )
+    vertex( pvec.x, pvec.y, pvec.z )
+end
+
+def key_pressed
+    
+    if key == CODED
+        
+        @pts += 1 if keyCode == UP && @pts < 40
+        @pts -= 1 if keyCode == DOWN && @pts > 3
+        
+        @segments += 1 if keyCode == RIGHT && @segments < 80
+        @segments -= 1 if keyCode == LEFT && @segments > 3
+        
+    end
+    
+    @lathe_radius += 1 if key.eql? "s"
+    @lathe_radius -= 1 if key.eql? "a" #&& @lathe_radius > 0
+    
+    @radius += 1 if key.eql? "x"
+    @radius -= 1 if key.eql? "z" && @radius > 10
+    
+    @is_wireframe = !@is_wireframe if key.eql? "w"
+    
+    @is_helix = !@is_helix if key.eql? "h"
+    
+end
+  

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

@@ -1,43 +1,39 @@
-require 'ruby-processing'
 
 # TRIANGLE_STRIP Mode
 # by Ira Greenberg.
 #
 # Generate a closed ring using vertex()
-# function and beginShape(TRIANGLE_STRIP)
-# mode. outerRad and innerRad variables
+# function and begin_shape(TRIANGLE_STRIP) mode
+# using outer_radius and inner_radius variables to
 # control ring's outer/inner radii respectively.
 # Trig functions generate ring.
+attr_reader :x, :y, :outer_radius, :inner_radius
+
+def setup
+  size 640, 360  
+  @x = width/2
+  @y = height/2
+  @outer_radius = min(width, height) * 0.4
+  @inner_radius = outer_radius * 0.6
+end
 
-class TriangleStrip < Processing::App
-
-  def setup
-    background 204
-    smooth
-
-    x = width/2
-    y = height/2
-    outer_radius = 80
-    inner_radius = 50
-    px, py, angle = 0.0, 0.0, 0.0
-    number_of_points = 36
-    rotation = 360.0/number_of_points
-
-    begin_shape TRIANGLE_STRIP
-    number_of_points.times do |i|
-      px = x + cos(angle.radians)*outer_radius
-  	  py = y + sin(angle.radians)*outer_radius
-  	  angle += rotation
-  	  vertex px, py
-
-  	  px = x + cos(angle.radians)*inner_radius
-  	  py = y + sin(angle.radians)*inner_radius
-  	  angle += rotation
-  	  vertex px, py
-    end
-    end_shape
+def draw
+  background 204
+  pts = map(mouse_x, 0, width, 6, 60).to_i
+  angle = 0.0      # degrees
+  step = 180.0/pts # degrees
+  
+  begin_shape TRIANGLE_STRIP
+  (0 .. pts).each do 
+    px = x + cos(angle.radians)*outer_radius
+    py = y + sin(angle.radians)*outer_radius
+    angle += step
+    vertex px, py
+    
+    px = x + cos(angle.radians)*inner_radius
+    py = y + sin(angle.radians)*inner_radius
+    angle += step
+    vertex px, py
   end
-
+  end_shape
 end
-
-TriangleStrip.new :title => "Triangle Strip", :width => 200, :height => 200

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

@@ -1,4 +1,4 @@
-require 'ruby-processing'
+
 
 # The beginShape() function begins recording vertices 
 # for a shape and endShape() stops recording. 
@@ -7,45 +7,41 @@ require 'ruby-processing'
 # a series of vertex() functions must follow.  
 # To stop drawing the shape, call the endShape() functions.
 
-class Vertices < Processing::App
 
-  def setup
-    background 0
-    no_fill
-    
-    stroke 102
-    begin_shape  
-		curve_vertex 168, 182 
-		curve_vertex 168, 182 
-		curve_vertex 136, 38 
-		curve_vertex 42, 34 
-		curve_vertex 64, 200 
-		curve_vertex 64, 200 
-	  end_shape  
-	
-	  stroke 51 
-	  begin_shape LINES 
-		vertex 60, 40 
-		vertex 160, 10 
-		vertex 170, 150 
-		vertex 60, 150 
-	  end_shape  
-	
-	  stroke 126 
-	  begin_shape  
-		vertex 60, 40 
-		bezier_vertex 160, 10, 170, 150, 60, 150 
-	  end_shape  
-	
-	  stroke 255 
-	  begin_shape POINTS 
-		vertex 60, 40 
-		vertex 160, 10 
-		vertex 170, 150 
-		vertex 60, 150 
-	  end_shape  
-  end
+def setup
+  size 200, 200
+  background 10, 10, 50
+  no_fill
+  stroke_weight 3
+  stroke 102
+  begin_shape  
+  curve_vertex 168, 182 
+  curve_vertex 168, 182 
+  curve_vertex 136, 38 
+  curve_vertex 42, 34 
+  curve_vertex 64, 200 
+  curve_vertex 64, 200 
+  end_shape  
+  
+  stroke 51 
+  begin_shape LINES 
+  vertex 60, 40 
+  vertex 160, 10 
+  vertex 170, 150 
+  vertex 60, 150 
+  end_shape  
   
+  stroke 126 
+  begin_shape  
+  vertex 60, 40 
+  bezier_vertex 160, 10, 170, 150, 60, 150 
+  end_shape  
+  
+  stroke 255 
+  begin_shape POINTS 
+  vertex 60, 40 
+  vertex 160, 10 
+  vertex 170, 150 
+  vertex 60, 150 
+  end_shape  
 end
-
-Vertices.new :title => "Vertices", :width => 200, :height => 200