ruby-processing 1.0.11 → 2.4.1

data/samples/processing_app/basics/textures/texture_cube.rb

@@ -0,0 +1,86 @@
+# TexturedCube
+# by Dave Bollinger.
+# 
+# Drag mouse to rotate cube. Demonstrates use of u/v coords in 
+# vertex ) and effect on texture().
+
+
+def setup  
+  size 640, 360, P3D  
+  @rotx = PI/4
+  @roty = PI/4  
+  @tex = load_image "berlin-1.jpg"
+  texture_mode NORMAL  # Changed for processing 2.0
+  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

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

@@ -5,43 +5,28 @@
 # are also applied to the second segment because they are inside
 # the same push_matrix and pop_matrix group.
 
-class Arm < Processing::App
+def setup    
+  size 640, 360    
+  @x, @y = width * 0.3, height * 0.5
+  @angle1, @angle2 = 0.0, 0.0
+  @seg_length = 100
+  stroke_weight 30
+  stroke 255, 160
+end
+
+def draw    
+  background 0  	
+  @angle1 = (mouse_x / width.to_f - 0.5) * -PI
+  @angle2 = (mouse_y / height.to_f - 0.5) * PI  	
+  push_matrix  	
+  segment @x, @y, @angle1
+  segment @seg_length, 0, @angle2
+  pop_matrix
+end
 
-  def setup
-    
-    size 200, 200
-    
-    @x, @y = 50, 100
-    @angle1, @angle2 = 0.0, 0.0
-    @seg_length = 50
-    
-    smooth
-    stroke_weight 20
-    stroke 0, 100
-  end
-  
-  def draw
-  
-  	background 226
-  	
-  	@angle1 = (mouse_x / width.to_f - 0.5) * -PI
-  	@angle2 = (mouse_y / height.to_f - 0.5) * PI
-  	
-  	push_matrix
-  	
-  		segment @x, @y, @angle1
-  		segment @seg_length, 0, @angle2
-  	pop_matrix
-  end
-  
-  def segment ( x, y, a )
-  	
-  	translate x, y
-  	rotate a
-  	
-  	line 0, 0, @seg_length, 0 
-  end
-  
+def segment ( x, y, a )  	
+  translate x, y
+  rotate a  	
+  line 0, 0, @seg_length, 0 
 end
 
-Arm.new :title => "Arm"

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

@@ -0,0 +1,57 @@
+# 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.
+attr_reader :ang, :ang2, :ang3, :ang4, :flap_speed
+
+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( ang3.radians ) * 170
+  py = cos( ang3.radians ) * 300
+  pz = sin( ang4.radians ) * 500
+  
+  translate width/2 + px, height/2 + py, -700 + pz
+  
+  rotate_x sin( ang2.radians ) * 120
+  rotate_y sin( ang2.radians ) * 50
+  rotate_z sin( ang2.radians ) * 65
+  
+  fill 153
+  box 20, 100, 20
+  
+  fill 204
+  push_matrix
+  rotate_y sin( ang.radians ) * -20
+  rect -75, -50, 75, 100
+  pop_matrix
+  
+  push_matrix
+  rotate_y sin( ang.radians ) * 20
+  rect 0, -50, 75, 100
+  pop_matrix
+  
+  @ang += flap_speed
+  
+  @flap_speed *= -1 if abs(ang) > PI
+  
+  @ang2 += 0.01
+  @ang3 += 2.0
+  @ang4 += 0.75
+  
+end
+

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

@@ -0,0 +1,38 @@
+# 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.
+
+load_library 'bird' 
+
+BIRD_COUNT = 200
+
+def setup
+  
+  size 640, 360, P3D
+  no_stroke
+  lights
+  @birds = []
+  
+  0.upto(BIRD_COUNT) { |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
+
+def draw  
+  background 0  
+  translate width/2, height/2, -700  
+  @birds.each do |b| 
+    b.fly 
+  end  
+end
+

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

@@ -0,0 +1,99 @@
+# 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
+
+load_library 'cube'
+
+
+def setup
+  
+  size 640, 360, P3D
+  
+  lights
+  smooth 4
+  @cube_count = 20
+  @cubes = []
+  
+  0.upto( @cube_count ) { |i|
+    
+    cube_size = rand(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(rand(-1 .. 1), rand(-1 .. 1), rand(-1 .. 1)) 
+    c.rotation = PVector.new(rand(40 .. 100), rand(40 .. 100), rand(40 .. 100)) 
+    
+    @cubes << 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
+
+

data/samples/processing_app/{3D/transform/cubes_in_cube → basics/transform/library/cube}/cube.rb

@@ -1,5 +1,3 @@
-require 'ruby-processing/app' # require Processing::Proxi
-
 class Cube
 
 	include Processing::Proxy # mixin Processing::Proxi
@@ -8,7 +6,7 @@ class Cube
 	attr_accessor :w, :h, :d
 	attr_accessor :position, :speed, :rotation # PVector
 	
-	def initialize ( w, h, d )
+	def initialize (w, h, d)
 	
 		@w, @h, @d = w, h, d
 		
@@ -16,15 +14,15 @@ class Cube
 		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
+		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
+		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
@@ -36,7 +34,7 @@ class Cube
 		]
 	end
 	
-	def draw ( side_colors = nil )
+	def draw (side_colors = nil)
 		
 		@vertices.each_with_index { |quad, i| # each face
 				

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

@@ -7,37 +7,23 @@
 # method to convert your values. For example: scale(radians(90))
 # is identical to the statement scale(PI/2). 
 
-class Rotate < Processing::App
 
-  def setup
-    
-    size 200, 200
-    
-    no_stroke
-    fill 255
-    frame_rate 30
-    rect_mode CENTER
-    
-    @angle = 0.0
-    @cosine = 0.0
-    @jitter = 0.0
-  end
-  
-  def draw
-  
-  	background 102
-  	
-  	@jitter = random -0.1, 0.1 if second % 2 == 0
-  	
-  	@angle += @jitter
-  	@cosine = cos( @angle )
-  	
-  	translate width/2, height/2
-  	rotate @cosine
-  	
-  	rect 0, 0, 115, 115
-  end
-  
+def setup    
+  size 640, 360  
+  no_stroke
+  fill 255
+  frame_rate 30
+  rect_mode CENTER    
+  @angle = 0.0
+  @cosine = 0.0
+  @jitter = 0.0
 end
 
-Rotate.new :title => "Rotate"
+def draw    
+  background 51  	
+  @jitter = rand(-0.1 .. 0.1) if second % 2 == 0  	
+  @angle += @jitter
+  translate width/2, height/2
+  rotate cos(@angle)   	
+  rect 0, 0, 180, 180
+end