ruby-processing 1.0.9 → 1.0.10.1

data/samples/peasy_cam/library/hilbert/hilbert.rb

@@ -39,9 +39,9 @@ end
 ###########################
 class Hilbert
   include Processing::Proxy
-
+  ADJUSTMENT = [0,  0.5,  1.5,  3.5,  7.5, 15]
   attr_reader :grammar, :axiom, :production, :premis, :rule,
-  :theta, :scale_factor, :distance, :phi, :len
+  :theta, :distance, :phi, :gen
 
   def initialize(len)
     @axiom = "X"
@@ -49,16 +49,14 @@ class Hilbert
     @production = axiom
     @premis = "X"
     @rule = "^<XF^<XFX-F^>>XFX&F+>>XFX-F>X->"
-    @len = len
-    @distance = len/12      # distance value relative to screen height
+    @distance = len
     @theta = Math::PI/180 * 90
-    @phi = Math::PI/180 * 90
+    @phi = Math::PI/180 * 90  
     grammar.add_rule(premis, rule)
-    no_stroke()
   end
 
-  def render()
-    translate(-len/42, len/42, -len/42)  # use the "answer?" to center the Hilbert
+  def render()    
+    translate( -distance * ADJUSTMENT[gen], distance *  ADJUSTMENT[gen], -distance * ADJUSTMENT[gen])
     fill(0, 75, 152)
     light_specular(204, 204, 204)
     specular(255, 255, 255)
@@ -93,7 +91,10 @@ class Hilbert
   ##############################
 
   def create_grammar(gen)
-    @distance *= 0.5**gen
+    @gen = gen    # required for depth adjustment
+    @distance *= 1/(pow(2, gen) - 1)
     @production = @grammar.generate gen
   end
-end
+  
+
+end

data/samples/processing_app/3D/camera/move_eye.rb

@@ -0,0 +1,29 @@
+# Move Eye. 
+# by Simon Greenwold.
+# 
+# The camera lifts up (controlled by mouseY) while looking at the same point.
+
+class MoveEye < Processing::App
+
+  def setup
+    size 640, 360, P3D
+    fill 204
+  end
+  
+  def draw
+  	lights
+  	background 0
+  	
+  	camera 30, mouseY, 220, 0, 0, 0, 0, 1, 0
+  	
+  	noStroke
+  	box 90
+  	stroke 255
+  	line( -100, 0, 0, 100, 0, 0)
+  	line( 0, -100, 0, 0, 100, 0)
+  	line( 0, 0, -100, 0, 0, 100)
+  end
+  
+end
+
+MoveEye.new :title => "Move Eye"

data/samples/processing_app/3D/form/brick_tower.rb

@@ -2,7 +2,7 @@
 
 # 3D castle tower constructed out of individual bricks.
 # Uses the PVecor and Cube classes.
- 
+
 def setup
   @bricks_per_layer = 16
   @brick_layers = 18
@@ -27,7 +27,7 @@ end
 
 def draw_layer(layer_num)
   @layer_num = layer_num
-  @temp_y -= @brick_height                                # increment rows                 
+  @temp_y -= @brick_height                                # increment rows
   @angle = 360.0 / @bricks_per_layer * @layer_num / 2.0   # alternate brick seams
   @bricks_per_layer.times {|i| draw_bricks(i) }
 end
@@ -59,14 +59,14 @@ class Cubeish
            :back   => ['---', ' --', '  -', '- -'],
            :top    => ['-- ', '---', ' --', ' - '],
            :bottom => ['-  ', '- -', '  -', '   ']}
-           
-  SIGNS = {'-' => -1, 
+
+  SIGNS = {'-' => -1,
            ' ' =>  1}
-  
+
   def initialize(width, height, depth)
     @vertices = {}
     @w, @h, @d = width, height, depth
-    
+
     SIDES.each do |side, signs|
       @vertices[side] = signs.map do |s|
         s = s.split('').map {|el| SIGNS[el] }
@@ -74,13 +74,13 @@ class Cubeish
       end
     end
   end
-  
+
   def create
     @vertices.each do |name, vectors|
-      shape(App::QUADS) do
-        vectors.each {|v| vertex(v.x, v.y, v.z) }
-      end
+      begin_shape App::QUADS
+      vectors.each {|v| vertex(v.x, v.y, v.z) }
+      end_shape
     end
   end
-  
+
 end

data/samples/processing_app/3D/form/cubic_grid.rb

@@ -0,0 +1,51 @@
+# Cubic Grid 
+# by Ira Greenberg. 
+# 
+# 3D translucent colored grid uses nested pushMatrix()
+# and popMatrix() functions. 
+
+class CubicGrid < Processing::App
+
+  def setup
+    size 640, 360, P3D
+    no_stroke
+    
+    @box_size = 40
+    @margin = @box_size * 2
+    @depth = 400
+  end
+  
+  def draw
+  	background 255
+  	
+  	translate width/2, height/2, -@depth
+  	rotate_x frame_count * 0.01
+  	rotate_y frame_count * 0.01
+  	
+  	((-@depth/2 + @margin)..(@depth/2 - @margin)).step( @box_size ) { |i|
+  		push_matrix
+  		
+  		((-height + @margin)..(height - @margin)).step( @box_size ) { |j|
+  			push_matrix
+  			
+  			((-width + @margin)..(width - @margin)).step( @box_size ) { |k|
+  				box_fill = color i.abs, j.abs, k.abs, 50
+  				push_matrix
+  				
+  				translate k, j, i
+  				fill box_fill
+  				box @box_size
+  				
+  				pop_matrix
+  			}
+  			
+  			pop_matrix
+  		}
+  		
+  		pop_matrix
+  	}
+  end
+  
+end
+
+CubicGrid.new :title => "Cubic Grid"

data/samples/processing_app/3D/form/icosahedra/icosahedra.rb

@@ -0,0 +1,76 @@
+# I Like Icosahedra
+# by Ira Greenberg.
+# 
+# This example plots icosahedra. The Icosahdron is a regular
+# polyhedron composed of twenty equalateral triangles.
+
+# fjenett, 2010-03-11:
+# This is by far not an exact translation of Iras code. I removed
+# the unneeded Dimension3D class, simplyfied Shape3D and improved
+# the Icosahedron class. That and the rubyfication ...
+  
+
+class Icosahedra < Processing::App
+
+  def setup
+    
+    size 640, 360, P3D
+    
+    @ico1 = Icosahedron.new 75
+    @ico2 = Icosahedron.new 75
+    @ico3 = Icosahedron.new 75
+    
+  end
+  
+  def draw
+  
+  	background 0
+  	lights
+  	
+  	translate width/2, height/2
+  	
+  	push_matrix
+  	
+  		translate -width/3.5, 0
+  		rotate_x frame_count * PI / 185
+  		rotate_y frame_count * PI / -200
+  		
+  		stroke 170, 0, 0
+  		no_fill
+  		
+  		@ico1.draw
+  	
+  	pop_matrix
+  	
+  	push_matrix
+  	
+  		rotate_x frame_count * PI / 200
+  		rotate_y frame_count * PI / 300
+  		
+  		stroke 170, 0, 180
+  		fill 170, 170, 0
+  		
+  		@ico2.draw
+  	
+  	pop_matrix
+  	
+  	push_matrix
+  	
+  		translate width/3.5, 0
+  		rotate_x frame_count * PI / -200
+  		rotate_y frame_count * PI / 200
+  		
+  		no_stroke
+  		fill 0, 0, 185
+  		
+  		@ico3.draw
+  	
+  	pop_matrix
+  
+  end
+  
+  require 'icosahedron' # load icosahedron.rb
+  
+end
+
+Icosahedra.new :title => "Icosahedra"

data/samples/processing_app/3D/form/icosahedra/icosahedron.rb

@@ -0,0 +1,116 @@
+
+# fjenett, 2010-03-11:
+# Mixing in Processing::Proxy makes classes behave like inner classes(*) of
+# a Processing sketch (any class that's defined in a sketch and that is
+# inside a .pde file). This is needed for a class to be able to call any
+# drawing commands etc.
+# (*) Ruby does not know inner classes btw. ...
+
+
+require 'shape_3D' 			# load shape_3D.rb
+
+class Icosahedron < Shape3D 		# extends Shape3D
+
+	include Processing::Proxy 	# mixin Processing::Proxy
+
+	attr_accessor :top_point, :top_pent
+	attr_accessor :bottom_point, :bottom_pent
+	attr_accessor :angle, :radius
+	attr_accessor :tri_dist, :tri_ht
+	attr_accessor :a, :b, :c
+
+	def initialize ( *args )
+
+		super args 		# call Shape3D.new( args )
+
+		@radius = args.first
+		@top_pent = Array.new 5
+		@bottom_pent = Array.new 5
+		@angle = 0.0
+
+		init
+
+	end
+
+	def init
+
+		@c = dist( cos(0) * @radius,
+				   sin(0) * @radius,
+				   cos(radians( 72 )) * @radius,
+				   sin(radians( 72 )) * @radius )
+
+		@b = @radius
+
+		@a = sqrt(@c*@c - @b*@b)
+
+		@tri_ht = sqrt( @c*@c - (@c/2) * (@c/2) )
+
+		@top_pent.each_with_index { |v, i|
+
+			@top_pent[i] = PVector.new( cos(@angle) * @radius,
+						    sin(@angle) * @radius,
+						    @tri_ht / 2 )
+
+			@angle += radians 72
+		}
+
+		@top_point = PVector.new 0, 0, @tri_ht / 2 + @a
+
+		@angle = 72.0/2
+
+		@bottom_pent.each_with_index { |v, i|
+
+			@bottom_pent[i] = PVector.new( cos(@angle) * @radius,
+						       sin(@angle) * @radius,
+						       -@tri_ht / 2 )
+			@angle += radians 72
+		}
+
+		@bottom_point = PVector.new 0, 0, -(@tri_ht / 2 + @a)
+
+	end
+
+	def draw
+
+		[@top_pent, @bottom_pent].each { |pent| # top and bottom pentagram
+
+			(0...pent.length).each { |i|
+
+				begin_shape
+
+					# next or first
+					n = i+1
+					n = n % @top_pent.length # wrap around
+
+					# choose point depending on pentagram
+					pnt = @top_point
+					pnt = @bottom_point if pent == @bottom_pent
+
+					# draw triangle
+					vertex @x + pent[i].x,  @y + pent[i].y, 	@z + pent[i].z
+					vertex @x + pnt.x,	@y + pnt.y, 		@z + pnt.z
+					vertex @x + pent[n].x,  @y + pent[n].y, 	@z + pent[n].z
+
+				end_shape CLOSE
+			}
+		}
+
+		begin_shape TRIANGLE_STRIP
+
+		0.upto(6) { |i| # stitch pentagrams together with triangles
+
+			j = i
+			j = j % @top_pent.length
+
+			n = i+2
+			n = n % @bottom_pent.length
+
+			vertex @x + @top_pent[j].x,  	@y + @top_pent[j].y,	@z + @top_pent[j].z
+			vertex @x + @bottom_pent[n].x,  @y + @bottom_pent[n].y, @z + @bottom_pent[n].z
+		}
+
+		end_shape
+
+	end
+
+end

data/samples/processing_app/3D/form/icosahedra/shape_3D.rb

@@ -0,0 +1,25 @@
+
+# fjenett, 2010-03-11:
+# Left this in although it's not needed as an example for 
+# how to extend classes.
+
+class Shape3D
+
+	attr_accessor :x, :y, :z
+	attr_accessor :w, :h, :d
+	
+	def initialize (*args)
+		@x, @y, @z = 0.0, 0.0, 0.0
+		@w, @h, @d = 0.0, 0.0, 0.0
+	end
+	
+	def rotate_x ( theta )
+	end
+	
+	def rotate_y ( theta )
+	end
+	
+	def rotate_z ( theta )
+	end
+
+end

data/samples/processing_app/3D/form/primitives.rb

@@ -0,0 +1,42 @@
+# Primitives 3D. 
+# 
+# Placing mathematically 3D objects in synthetic space.
+# The lights() method reveals their imagined dimension.
+# The box() and sphere() functions each have one parameter
+# which is used to specify their size. These shapes are
+# positioned using the translate() function.
+
+class Primitives < Processing::App
+
+  def setup
+    
+    size 640, 360, P3D
+    
+    background 0
+    lights
+    
+    no_stroke
+    push_matrix
+    
+    translate 130, height/2, 0
+    rotate_y 1.25
+    rotate_x -0.4
+    
+    box 100
+    
+    pop_matrix
+    
+    no_fill
+    stroke 255
+    push_matrix
+    
+    translate 500, height*0.35, -200
+    sphere 280
+    
+    pop_matrix
+    
+  end
+  
+end
+
+Primitives.new :title => "Primitives"