ruby-processing 1.0.9 → 1.0.10.1

data/samples/processing_app/basics/math/noise_3_d.rb

@@ -0,0 +1,50 @@
+# Noise3D. 
+# 
+# Using 3D noise to create simple animated texture. 
+# Here, the third dimension ('z') is treated as time. 
+
+class Noise3D < Processing::App
+
+  def setup
+    
+    size 200, 200
+    frame_rate 30
+    
+    @increment = 0.01
+    @zoff = 0.0
+    @z_increment = 0.02
+    
+  end
+  
+  def draw
+  
+  	background 0
+  	
+  	load_pixels
+  	
+  	xoff = 0.0
+  	
+  	(0...width).each { |x|
+  	
+  		xoff += @increment
+  		yoff = 0.0
+  		
+  		(0...height).each { |y|
+  		
+  			yoff += @increment
+  		
+  			bright = noise( xoff, yoff, @zoff ) * 255
+  			
+  			pixels[x+y*width] = color bright
+  		}
+  	}
+  	
+  	update_pixels
+  	
+  	@zoff += @z_increment
+  
+  end
+  
+end
+
+Noise3D.new :title => "Noise 3 D"

data/samples/processing_app/basics/math/noise_wave.rb

@@ -0,0 +1,61 @@
+# Noise Wave
+
+class NoiseWave < Processing::App
+
+  def setup
+    
+    size 200, 200
+    frame_rate 30
+    
+    color_mode RGB, 255, 255, 255, 100
+    smooth
+    @w = width + 16
+    @y_values = []
+    @x_spacing = 8
+    @yoff = 0.0
+    
+  end
+  
+  def draw
+  
+  	background 0
+  	
+  	calc_wave
+  	draw_wave
+  
+  end
+  
+  def calc_wave
+  	
+  	dx = 0.05
+  	dy = 0.01
+  	amplitude = 100.0
+  	
+  	@yoff += dy
+  	
+  	xoff = @yoff
+  	
+  	(0...(@w/@x_spacing)).each { |i|
+  	
+  		@y_values[i] = (2 * noise(xoff) - 1) * amplitude
+  		xoff += dx
+  	}
+  	
+  end
+  
+  def draw_wave
+  	
+	no_stroke
+	fill 255, 50
+	ellipse_mode CENTER
+  
+  	@y_values.each_with_index { |v, x|
+  		
+  		ellipse x * @x_spacing, width/2 + v, 16, 16
+  	}
+  
+  end
+  
+end
+
+NoiseWave.new :title => "Noise Wave"

data/samples/processing_app/basics/math/operator_precedence.rb

@@ -0,0 +1,70 @@
+# Operator Precedence
+# 
+# If you don't explicitly state the order in which
+# an expression is evaluated, they are evaluated based
+# on the operator precedence. For example, in the statement
+# "4+2*8", the 2 will first be multiplied by 8 and then the result will
+# be added to 4. This is because the "*" has a higher precedence
+# than the "+". To avoid ambiguity in reading the program, 
+# it is recommended that is statement is written as "4+(2*8)".
+# The order of evaluation can be controlled through placement of
+# parenthesis in the code. A table of operator precedence follows below.
+ 
+# The highest precedence is at the top of the list and 
+# the lowest is at the bottom.
+# Multiplicative: * / %
+# Additive: + -
+# Relational: < > <= >=
+# Equality: == !=
+# Logical AND: &&
+# Logical OR: ||
+# Assignment: = += -= *= /= %=
+
+class OperatorPrecedence < Processing::App
+
+  def setup
+    
+    size 200, 200
+    
+    background 51
+    
+    no_fill
+    stroke 204
+    
+    (0...(width-20)).step( 4 ) { |i|
+    
+  		# The 30 is added to 70 and then evaluated
+		# if it is greater than the current value of "i"
+		# For clarity, write as "if i > (30 + 70))"
+		
+    	line i, 0, i, 50 if i > 30 + 70
+    }
+    
+    stroke 255
+    
+    # The 2 is multiplied by the 8 and the result is added to the 4
+	# For clarity, write as "rect 4 + (2 * 8), 52, 90, 48"
+	
+    rect( 4 + 2 * 8, 52, 90, 48 )
+    rect( (4 + 2) * 8, 100, 90, 49 )
+    
+    stroke 153
+    
+    (0...width).step( 2 ) { |i|
+    
+  		# The relational statements are evaluated 
+  		# first, and then the logical AND statements and 
+  		# finally the logical OR. For clarity, write as:
+  		# "if ((i > 20) && (i < 50)) || ((i > 100) && (i < 180))"
+    
+    	line i, 151, i, height-1 if i > 20 && i < 50 || i > 100 && i < width-20
+    }
+  end
+  
+  def draw
+  
+  end
+  
+end
+
+OperatorPrecedence.new :title => "Operator Precedence"

data/samples/processing_app/basics/math/polar_to_cartesian.rb

@@ -0,0 +1,44 @@
+# PolarToCartesian
+# by Daniel Shiffman.  
+# 
+# Convert a polar coordinate (r,theta) to cartesian (x,y):  
+# x = r * cos(theta)
+# y = r * sin(theta)
+ 
+class PolarToCartesian < Processing::App
+
+  def setup
+    
+    size 200, 200
+    
+    frame_rate 30
+    smooth
+    
+    @r = 50.0
+    @theta = 0.0
+    @theta_vel = 0.0
+    @theta_acc = 0.1e-3
+  end
+  
+  def draw
+  
+  	background 0
+  	
+  	translate width/2, height/2
+  	
+  	x = @r * cos( @theta )
+  	y = @r * sin( @theta )
+  	
+  	ellipse_mode CENTER
+  	no_stroke
+  	fill 200
+  	ellipse x, y, 16, 16
+  	
+  	@theta_vel += @theta_acc
+  	@theta += @theta_vel
+  
+  end
+  
+end
+
+PolarToCartesian.new :title => "Polar To Cartesian"

data/samples/processing_app/basics/math/random.rb

@@ -0,0 +1,35 @@
+# Random. 
+# 
+# Random numbers create the basis of this image. 
+# Each time the program is loaded the result is different. 
+
+class Random < Processing::App
+
+  def setup
+    
+    size 200, 200
+    
+    smooth
+    stroke_weight 10
+    
+    no_loop
+    
+  end
+  
+  def draw
+  	
+    background 0
+    
+    (0...width).each { |i|
+    
+    	r = random 255
+    	x = random 0, width
+    	stroke r, 100
+    	line i, 0, x, height
+    }
+    
+  end
+  
+end
+
+Random.new :title => "Random"

data/samples/processing_app/basics/math/sine.rb

@@ -0,0 +1,49 @@
+# Sine. 
+# 
+# Smoothly scaling size with the sin() function.
+
+class Sine < Processing::App
+
+  def setup
+    
+    size 200, 200
+    no_stroke
+    smooth
+    
+    @diameter = 84.0
+    @sin = 0.0
+    @angle = 0.0
+    @rad_points = 90
+    
+  end
+  
+  def draw
+  
+  	background 153
+  	
+  	translate 130, 65
+  	
+  	fill 255
+  	ellipse 0, 0, 16, 16
+  	
+  	angle_rot = 0.0
+  	fill 51
+  	
+  	(0...5).each { |i|
+  	
+  		push_matrix
+  			rotate angle_rot - 45
+  			ellipse -116, 0, @diameter, @diameter
+  		pop_matrix
+  		angle_rot += TWO_PI/5
+  	}
+  	
+  	@diameter = 34 * sin( @angle ) + 168
+  	@angle += 0.02
+  	#@angle = 0.0 if @angle > TWO_PI
+  
+  end
+  
+end
+
+Sine.new :title => "Sine"

data/samples/processing_app/basics/math/sine_cosine.rb

@@ -0,0 +1,60 @@
+# Sine Cosine. 
+# 
+# Linear movement with sin() and cos(). 
+# Numbers between 0 and PI*2 (TWO_PI which is roughly 6.28) 
+# are put into these functions and numbers between -1 and 1 are 
+# returned. These values are then scaled to produce larger movements. 
+
+class SineCosine < Processing::App
+
+  def setup
+    
+    size 200, 200
+    no_stroke
+    smooth
+    
+    @i = 45
+    @j = 225
+    @pos1 = 0.0
+    @pos2 = 0.0
+    @pos3 = 0.0
+    @pos4 = 0.0
+    @sc = 40
+    
+  end
+  
+  def draw
+  
+  	background 0
+  	
+  	fill 51
+  	rect 60, 60, 80, 80
+  	
+  	fill 255
+  	ellipse @pos1, 36, 32, 32
+  	
+  	fill 153
+  	ellipse 36, @pos2, 32, 32
+  	
+  	fill 255
+  	ellipse @pos3, 164, 32, 32
+  	
+  	fill 153
+  	ellipse 164, @pos4, 32, 32
+  	
+  	@i += 3
+  	@j -= 3
+  	
+  	ang1 = radians @i
+  	ang2 = radians @j
+  	
+  	@pos1 = width/2 + (@sc * cos( ang1 ))
+  	@pos2 = width/2 + (@sc * sin( ang1 ))
+  	@pos3 = width/2 + (@sc * cos( ang2 ))
+  	@pos4 = width/2 + (@sc * sin( ang2 ))
+  
+  end
+  
+end
+
+SineCosine.new :title => "Sine Cosine"

data/samples/processing_app/basics/math/sine_wave.rb

@@ -0,0 +1,62 @@
+# Sine Wave
+# by Daniel Shiffman.  
+# 
+# Render a simple sine wave. 
+
+class SineWave < Processing::App
+
+  def setup
+    
+    size 200, 200
+    
+    frame_rate 30
+    color_mode RGB, 255, 255, 255, 100
+    smooth
+    
+    @w = width + 16
+    @period = 500.0
+    @x_spacing = 8
+    @dx = (TWO_PI / @period) * @x_spacing
+    @y_values = []
+    @theta = 0.0
+    @amplitude = 75.0
+    
+  end
+  
+  def draw
+  
+  	background 0
+  	calc_wave
+  	draw_wave
+  
+  end
+  
+  def calc_wave
+  
+  	@theta += 0.02
+  	
+  	x = @theta
+  	(0...(@w/@x_spacing)).each { |i|
+  	
+  		@y_values[i] = sin(x) * @amplitude
+  		x += @dx
+  	}
+  
+  end
+  
+  def draw_wave
+  
+	no_stroke
+	fill 255, 50
+	ellipse_mode CENTER
+  		
+  	@y_values.each_with_index { |v, x|
+  	
+  		ellipse x*@x_spacing, width/2+v, 16, 16
+  	}
+  	
+  end
+  
+end
+
+SineWave.new :title => "Sine Wave"

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

@@ -0,0 +1,139 @@
+# Composite Objects
+# 
+# An object can include several other objects. Creating such composite objects 
+# is a good way to use the principles of modularity and build higher levels of 
+# abstraction within a program.
+
+class CompositeObjects < Processing::App
+
+  def setup
+    
+    	size 200, 200
+    	smooth
+    	@er1 = EggRing.new 66, 132, 0.1, 66
+    	@er2 = EggRing.new 132, 180, 0.05, 132
+  end
+  
+  def draw
+  
+  	background 0
+  	
+  	[@er1, @er2].each do |er| er.transmit end
+  end
+  
+  # vvv CLASS EGG RING
+  
+  class EggRing
+  
+  	def initialize ( x, y, t, sp )
+  		
+  		@ovoid = Egg.new x, y, t, sp
+  		@circle = Ring.new
+  		@circle.start x, y - sp/2
+  	end
+  	
+  	def transmit
+  	
+  		@ovoid.wobble
+  		@ovoid.display
+  		@circle.grow
+  		@circle.display
+  		@circle.on = true unless @circle.on
+  	end
+  
+  end 
+  
+  # ^^^ CLASS EGG RING
+  
+  # vvv CLASS EGG
+  
+  class Egg
+  
+  	attr_accessor :x, :y  # these are (or better generate) getters/setters
+			      # for these instance variables
+  	attr_accessor :tilt
+  	attr_accessor :angle
+  	attr_accessor :scalar
+  	
+  	def initialize ( x, y, t, s )
+  	
+  		@x, @y = x, y # the @-sign means that these are instance variables
+  		@tilt = t
+  		@scalar = s / 100.0
+  		@angle = 0.0
+  	end
+  	
+  	def wobble
+  		
+  		@tilt = Math.cos( @angle ) / 8
+  		@angle += 0.1
+  	end
+  	
+  	def display
+  	
+  		no_stroke	# in Ruby-Processing classes defined inside the main sketch
+				# class automatically inherit the Processing commands, just
+				# like "inner classes" in Java
+  		fill 255
+  		
+  		push_matrix
+  			
+  			translate @x, @y
+  			rotate @tilt
+  			scale @scalar
+  			
+  			begin_shape
+  				
+  				vertex 0, -100
+  				bezier_vertex 25, -100, 40, -65, 40, -40
+  				bezier_vertex 40, -15, 25, 0, 0, 0
+  				bezier_vertex -25, 0, -40, -15, -40, -40
+  				bezier_vertex -40, -65, -25, -100, 0, -100
+  				
+  			end_shape
+  			
+  		pop_matrix
+  	end
+  	
+  end
+  
+  # ^^^ CLASS EGG
+  
+  # vvv CLASS RING
+  
+  class Ring
+  
+  	attr_accessor :x, :y
+  	attr_accessor :diameter
+  	attr_accessor :on
+  	
+  	def start ( xpos, ypos )
+  		
+  		@x, @y = xpos, ypos
+  		@on = true
+  		@diameter = 1.0
+  	end
+  	
+  	def grow
+  	
+  		@diameter += 0.5 if @on
+  		@diameter = 0.0 if @diameter > width*2
+   	end
+   	
+   	def display
+   		
+   		if @on
+   			no_fill
+   			stroke_weight 4
+   			stroke 155, 153
+   			ellipse @x, @y, @diameter, @diameter
+   		end
+   	end
+  
+  end
+  
+  # ^^^ CLASS RING
+  
+end
+
+CompositeObjects.new :title => "Composite Objects"