ruby-processing 1.0.9 → 1.0.10.1

data/samples/processing_app/3D/textures/texture_cube.rb

@@ -0,0 +1,106 @@
+# TexturedCube
+# by Dave Bollinger.
+# 
+# Drag mouse to rotate cube. Demonstrates use of u/v coords in 
+# vertex ) and effect on texture(). The textures get distorted using
+# the P3D renderer as you can see, but they look great using OPENGL.
+
+class TextureCube < Processing::App
+
+  def setup
+    
+    size 649, 360, P3D
+    
+    @rotx = PI/4
+    @roty = PI/4
+    
+    @tex = load_image "berlin-1.jpg"
+    texture_mode NORMALIZED
+    fill 255
+    stroke 44, 48, 32
+    
+  end
+  
+  def draw
+  
+  	background 0
+  	
+  	no_stroke
+  	
+  	translate width/2, height/2, -100
+  	
+  	rotate_x @rotx
+  	rotate_y @roty
+  	
+  	scale 90
+  	
+  	texture_cube
+  
+  end
+  
+  def texture_cube
+  
+	# Given one texture and six faces, we can easily set up the uv coordinates
+	# such that four of the faces tile "perfectly" along either u or v, but the other
+	# two faces cannot be so aligned.  This code tiles "along" u, "around" the X/Z faces
+	# and fudges the Y faces - the Y faces are arbitrarily aligned such that a
+	# rotation along the X axis will put the "top" of either texture at the "top"
+	# of the screen, but is not otherwised aligned with the X/Z faces. (This
+	# just affects what type of symmetry is required if you need seamless
+	# tiling all the way around the cube)
+	
+	begin_shape QUADS
+	
+	texture @tex
+	
+	# +Z "front" face
+	vertex -1, -1,  1, 0, 0
+	vertex  1, -1,  1, 1, 0
+	vertex  1,  1,  1, 1, 1
+	vertex -1,  1,  1, 0, 1
+	
+	# -Z "back" face
+	vertex  1, -1, -1, 0, 0
+	vertex -1, -1, -1, 1, 0
+	vertex -1,  1, -1, 1, 1
+	vertex  1,  1, -1, 0, 1
+	
+	# +Y "bottom" face
+	vertex -1,  1,  1, 0, 0
+	vertex  1,  1,  1, 1, 0
+	vertex  1,  1, -1, 1, 1
+	vertex -1,  1, -1, 0, 1
+	
+	# -Y "top" face
+	vertex -1, -1, -1, 0, 0
+	vertex  1, -1, -1, 1, 0
+	vertex  1, -1,  1, 1, 1
+	vertex -1, -1,  1, 0, 1
+	
+	# +X "right" face
+	vertex  1, -1,  1, 0, 0
+	vertex  1, -1, -1, 1, 0
+	vertex  1,  1, -1, 1, 1
+	vertex  1,  1,  1, 0, 1
+	
+	# -X "left" face
+	vertex -1, -1, -1, 0, 0
+	vertex -1, -1,  1, 1, 0
+	vertex -1,  1,  1, 1, 1
+	vertex -1,  1, -1, 0, 1
+	
+	end_shape
+  
+  end
+  
+  def mouse_dragged
+  
+  	rate = 0.01
+  	@rotx += ( pmouse_y - mouse_y ) * rate
+  	@roty += ( mouse_x - pmouse_x ) * rate
+  
+  end
+  
+end
+
+TextureCube.new :title => "Texture Cube"

data/samples/processing_app/3D/transform/bird.rb

@@ -0,0 +1,61 @@
+# Simple 3D Bird 
+# by Ira Greenberg.  
+# 
+# Using a box and 2 rects to simulate a flying bird. 
+# Trig functions handle the flapping and sinuous movement.
+
+class Bird < Processing::App
+
+  def setup
+    
+    size 640, 360, P3D
+    
+    no_stroke
+    
+    @ang, @ang2, @ang3, @ang4 = 0.0, 0.0, 0.0, 0.0
+    @flap_speed = 0.2
+    
+  end
+  
+  def draw
+  
+  	background 0
+  	lights
+  	
+  	px = sin( radians @ang3 ) * 170
+  	py = cos( radians @ang3 ) * 300
+  	pz = sin( radians @ang4 ) * 500
+  	
+  	translate width/2 + px, height/2 + py, -700 + pz
+  	
+  	rotate_x sin( radians @ang2 ) * 120
+  	rotate_y sin( radians @ang2 ) * 50
+  	rotate_z sin( radians @ang2 ) * 65
+  	
+  	fill 153
+  	box 20, 100, 20
+  	
+  	fill 204
+  	push_matrix
+  		rotate_y sin( radians @ang ) * -20
+  		rect -75, -50, 75, 100
+  	pop_matrix
+  	
+  	push_matrix
+  		rotate_y sin( radians @ang ) * 20
+  		rect 0, -50, 75, 100
+  	pop_matrix
+  	
+  	@ang += @flap_speed
+  	
+  	@flap_speed *= -1 if @ang >  PI || @ang < -PI
+  	
+  	@ang2 += 0.01
+  	@ang3 += 2.0
+  	@ang4 += 0.75
+  	
+  end
+  
+end
+
+Bird.new :title => "Bird"

data/samples/processing_app/3D/transform/birds/bird.rb

@@ -0,0 +1,87 @@
+class Bird
+
+	include Processing::Proxy 	# mixin Processing commands
+
+	attr_accessor :offset_x, :offset_y, :offset_z
+	attr_accessor :w, :h
+	attr_accessor :body_fill, :wing_fill
+	attr_accessor :ang, :ang2, :ang3, :ang4
+	attr_accessor :radius_x, :radius_y, :radius_z
+	attr_accessor :rot_x, :rot_y, :rot_z
+	attr_accessor :flap_speed
+	attr_accessor :rot_speed
+
+	def initialize ( offset_x, offset_y, offset_z, w, h )
+
+		defaults
+		@offset_x, @offset_y, @offset_z = offset_x, offset_y, offset_z
+		@w, @h = w, h
+	end
+
+	def defaults
+
+		@ang, @ang2, @ang3, @ang4 = 0.0, 0.0, 0.0, 0.0
+		@body_fill, @wing_fill = color(153), color(204)
+		@flap_speed = 0.4
+		@rot_speed = 0.1
+		@radius_x, @radius_y, @radius_z = 120.0, 200.0, 700.0
+	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
+	end
+
+	def set_wing_speed ( flap_speed )
+
+		@flap_speed = flap_speed
+	end
+
+	def set_rot_speed ( rot_speed )
+
+		@rot_speed = rot_speed
+	end
+
+	def fly
+
+		push_matrix
+
+			px = sin( radians @ang3 ) * @radius_x
+			py = cos( radians @ang3 ) * @radius_y
+			pz = sin( radians @ang4 ) * @radius_z
+
+			translate @offset_x + px,
+					  @offset_y + py,
+					  @offset_z + pz
+
+			rotate_x sin( radians @ang2 ) * @rot_x
+			rotate_y sin( radians @ang2 ) * @rot_y
+			rotate_z sin( radians @ang2 ) * @rot_z
+
+			fill @body_fill
+			box @w/5, @h, @w/5
+
+			fill @wing_fill
+
+			push_matrix
+				rotate_y sin( radians @ang ) * 20
+				rect 0, -@h/2, @w, @h
+			pop_matrix
+
+			push_matrix
+				rotate_y sin( radians @ang ) * -20
+				rect -@w, -@h/2, @w, @h
+			pop_matrix
+
+			@ang += @flap_speed
+			@flap_speed *= -1 if @ang > PI || @ang < -PI
+
+			@ang2 += @rot_speed
+			@ang3 += 1.25
+			@ang4 += 0.55
+
+		pop_matrix
+	end
+
+end

data/samples/processing_app/3D/transform/birds/birds.rb

@@ -0,0 +1,48 @@
+# Crazy Flocking 3D Birds 
+# by Ira Greenberg. 
+# 
+# Simulates a flock of birds using a Bird class and nested
+# pushMatrix() / popMatrix() functions. 
+# Trigonometry functions handle the flapping and sinuous movement.
+
+require 'bird' # class Bird
+
+class Birds < Processing::App
+
+  def setup
+    
+    size 640, 360, P3D
+    no_stroke
+    lights
+    
+    @bird_count = 200
+    @birds = []
+    
+    0.upto( @bird_count ) { |i|
+    
+    	bird = Bird.new random(-300,300), random(-300,300), random(-500,-2500), random(5,30), random(5,30)
+    
+  		bird.set_flight random( 20, 340 ), random( 30, 350 ), random( 1000, 4800 ),
+    					random( -160, 160 ), random( -55, 55 ), random( -20, 20 )
+  		
+  		bird.set_wing_speed random( 0.1, 3.75 )
+  		bird.set_rot_speed random( 0.025, 0.15 )
+    	
+    	@birds.push bird
+    }
+    
+  end
+  
+  def draw
+  
+  	background 0
+  	
+  	translate width/2, height/2, -700
+  	
+  	@birds.each do |b| b.fly end
+  
+  end
+  
+end
+
+Birds.new :title => "Birds"

data/samples/processing_app/3D/transform/cubes_in_cube/cube.rb

@@ -0,0 +1,57 @@
+require 'ruby-processing/app' # require Processing::Proxi
+
+class Cube
+
+	include Processing::Proxy # mixin Processing::Proxi
+	
+	attr_accessor :vertices
+	attr_accessor :w, :h, :d
+	attr_accessor :position, :speed, :rotation # PVector
+	
+	def initialize ( w, h, d )
+	
+		@w, @h, @d = w, h, d
+		
+		w2 = @w/2
+		h2 = @h/2
+		d2 = @d/2
+		
+		tfl = PVector.new -w2, h2, d2	# four points making the top quad:
+		tfr = PVector.new  w2, h2, d2	# "tfl" is "top front left", etc
+		tbr = PVector.new  w2, h2,-d2
+		tbl = PVector.new -w2, h2,-d2
+		
+		bfl = PVector.new -w2,-h2, d2	# bottom quad points
+		bfr = PVector.new  w2,-h2, d2
+		bbr = PVector.new  w2,-h2,-d2
+		bbl = PVector.new -w2,-h2,-d2
+		
+		@vertices = [
+			[tfl, tfr, tbr, tbl],		# top
+			[tfl, tfr, bfr, bfl],		# front
+			[tfl, tbl, bbl, bfl],		# left
+			[tbl, tbr, bbr, bbl],		# back
+			[tbr, tfr, bfr, bbr],		# right
+			[bfl, bfr, bbr, bbl]
+		]
+	end
+	
+	def draw ( side_colors = nil )
+		
+		@vertices.each_with_index { |quad, i| # each face
+				
+			begin_shape QUADS
+			
+			fill side_colors[i] if side_colors && i < side_colors.length
+		
+			quad.each { |pvec|
+				
+				vertex pvec.x, pvec.y, pvec.z
+			}
+							
+			end_shape
+
+		}
+	end
+	
+end

data/samples/processing_app/3D/transform/cubes_in_cube/cubes_in_cube.rb

@@ -0,0 +1,102 @@
+# Cubes Contained Within a Cube 
+# by Ira Greenberg.  
+# 
+# Collision detection against all outer cube's surfaces. 
+# Uses the PVector and Cube classes.
+
+# fjenett, 2010-03-12: did some cleanups and rubyfication here
+
+require 'cube'
+
+class CubesInCube < Processing::App
+
+  def setup
+    
+    size 640, 360, P3D
+    
+    lights
+    
+    @cube_count = 20
+    @cubes = []
+    
+    0.upto( @cube_count ) { |i|
+    
+    	cube_size = random( 5, 15 )
+    	
+    	c = Cube.new cube_size, cube_size, cube_size
+    	
+    	c.position = PVector.new 0.0, 0.0, 0.0
+    	c.speed    = PVector.new random(-1,1), random(-1,1), random(-1,1)
+    	c.rotation = PVector.new random(40,100), random(40,100), random(40,100)
+    	
+    	@cubes.push c
+    }
+    
+    @cube_colors = [
+    	color( 0 ), color( 51 ), color( 102 ), color( 153 ), color( 204 ), color( 255 )
+    ]
+    @cube_colors.reverse
+    
+    @stage_size = 300
+    @stage = Cube.new @stage_size, @stage_size, @stage_size
+    
+  end
+  
+  def draw
+  
+  	background 50
+  
+  	translate width/2, height/2, -130
+  	
+  	rotate_x frame_count * 0.001
+  	rotate_y frame_count * 0.002
+  	rotate_z frame_count * 0.001
+  
+  	no_fill
+  	stroke 255
+  	
+  	@stage.draw
+  	
+  	@cubes.each_with_index { |c, i|
+  	
+  		# draw cube
+  		push_matrix
+  		
+  			translate c.position.x, c.position.y, c.position.z
+  			
+  			fcpi = frame_count * PI
+  			rotate_x fcpi / c.rotation.x
+  			rotate_y fcpi / c.rotation.y
+  			rotate_x fcpi / c.rotation.z
+  			
+  			no_stroke
+  			
+  			c.draw @cube_colors
+  		
+  		pop_matrix
+  		
+  		# move it
+		c.position.add c.speed
+		
+		# draw lines
+		if i > 0
+		
+			stroke 0
+			c2 = @cubes[i-1]
+			line c.position.x,  c.position.y,  c.position.z,
+			     c2.position.x, c2.position.y, c2.position.z
+		
+		end
+		
+		# collision
+		s2 = @stage_size / 2
+		c.speed.x *= -1 if ( c.position.x / s2 ).abs > 1  # note that in Ruby abs(-12) is -12.abs
+		c.speed.y *= -1 if ( c.position.y / s2 ).abs > 1
+		c.speed.z *= -1 if ( c.position.z / s2 ).abs > 1
+  	}
+  	
+  end
+  
+end
+
+CubesInCube.new :title => "Cubes In Cube"