ruby-processing 1.0.2 → 1.0.3

data/samples/flight_patterns.rb

@@ -5,7 +5,7 @@ require 'ruby-processing'
 
 class FlightPatterns < Processing::App
   load_libraries 'boids', 'opengl'
-  include_package "processing.opengl" if library_loaded? "opengl"
+  import "processing.opengl" if library_loaded? "opengl"
   
   def setup
     library_loaded?(:opengl) ? setup_opengl : render_mode(P3D)

data/samples/learning_processing/chapter_16/01_display_video.rb

@@ -5,7 +5,7 @@ class CaptureVideoSketch < Processing::App
   # Step 1. Import the video library
   load_library "video"
   # We need the video classes to be included here.
-  include_package "processing.video" 
+  import "processing.video" 
 
   def setup
     # Step 2. Declare a Capture object

data/samples/learning_processing/chapter_16/02_manipulate_video_image.rb

@@ -3,7 +3,7 @@ require 'ruby-processing'
 class ManipulateVideoImageSketch < Processing::App
 
   load_library "video"
-  include_package "processing.video" 
+  import "processing.video" 
 
   def setup
     @video = Capture.new(self, width, height, 30)

data/samples/processing_app/basics/arrays/array.rb

@@ -0,0 +1,41 @@
+require 'ruby-processing'
+
+#  * An array is a list of data. Each piece of data in an array 
+#  * is identified by an index number representing its position in 
+#  * the array. Arrays are zero based, which means that the first 
+#  * element in the array is [0], the second element is [1], and so on. 
+#  * In this example, an array named "coswav" is created and
+#  * filled with the cosine values. This data is displayed three 
+#  * separate ways on the screen.  
+
+class ArrayExample < Processing::App
+
+  def setup
+    
+    coswave = []
+    
+    0.upto( width ) do |i|
+    	amount = map i, 0, width, 0, PI
+    	coswave[i] = cos( amount ).abs
+    end
+    
+    0.upto( width ) do |i|
+    	stroke( coswave[i] * 255 )
+    	line i, 0, i, height/3
+    end
+    
+    0.upto( width ) do |i|
+    	stroke( coswave[i] * 255 / 4 )
+    	line i, height/3, i, height/3*2
+    end
+    
+    0.upto( width ) do |i|
+    	stroke( 255 - coswave[i] * 255 )
+    	line i, height/3*2, i, height
+    end
+    
+  end
+  
+end
+
+ArrayExample.new :title => "Array Example", :width => 200, :height => 200

data/samples/processing_app/basics/arrays/array_2d.rb

@@ -0,0 +1,38 @@
+require 'ruby-processing'
+
+#  * Demonstrates the syntax for creating a two-dimensional (2D) array.
+#  * Values in a 2D array are accessed through two index values.  
+#  * 2D arrays are useful for storing images. In this example, each dot 
+#  * is colored in relation to its distance from the center of the image.
+
+class Array2d < Processing::App
+
+  def setup
+    
+    distances = Array.new( width ) { Array.new( height ) } # [width][height]
+	
+    max_distance = dist( width/2, height/2, width, height )
+    
+    width.times do |x|
+    	height.times do |y|
+    		distance = dist( width/2, height/2, x, y )
+    		distances[x][y] = distance / max_distance * 255
+    	end
+    end
+    
+    background 0
+    
+    x = 0; while x < distances.length
+		y = 0; while y < distances[x].length
+			stroke distances[x][y]
+    		point x, y
+    		y += 2
+    	end
+    	x += 2
+    end
+    
+  end
+  
+end
+
+Array2d.new :title => "Array 2d", :width => 200, :height => 200

data/samples/processing_app/basics/arrays/array_objects.rb

@@ -0,0 +1,67 @@
+require 'ruby-processing'
+
+# * Demonstrates the syntax for creating an array of custom objects. 
+
+class ArrayObjects < Processing::App
+
+	UNIT = 40
+
+  def setup
+    
+    @num = width/UNIT ** 2
+    @mods = []
+    
+    basis = (height/UNIT).to_i
+    
+    basis.times do |i|
+      basis.times do |j|
+    		@mods << CustomObject.new( j*UNIT, i*UNIT, UNIT/2, UNIT/2, random( 0.05, 0.8 ) )
+    	end
+    end
+    
+    background 176
+    no_stroke
+  end
+  
+  def draw
+  	stroke(second * 4)
+  	
+  	@mods.each do |mod|
+  		mod.update; mod.draw
+  	end
+  end
+
+	# the custom object
+	
+	class CustomObject
+	
+		def initialize( mx, my, x, y, speed )
+			@mx, @my      = my, mx                # This is backwards because the Processing example is backwards.
+			@x, @y        = x.to_i, y.to_i
+			@xdir, @ydir  = 1, 1
+		  @speed        = speed
+			@size         = UNIT
+		end
+		
+		def update
+			@x += @speed * @xdir
+			if @x >= @size || @x <= 0
+				@xdir *= -1
+				@x += @xdir
+				@y += @ydir
+			end
+			if @y >= @size || @x <= 0
+				@ydir *= -1
+				@y += @ydir
+			end
+		end
+		
+		def draw
+			$app.point( @mx + @x - 1, @my + @y - 1 )
+		end
+	
+	end
+  
+end
+
+ArrayObjects.new :title => "Array Objects", :width => 200, :height => 200

data/samples/processing_app/basics/color/brightness.rb

@@ -0,0 +1,30 @@
+require 'ruby-processing'
+
+# Brightness 
+# by Rusty Robison. 
+# 
+# Brightness is the relative lightness or darkness of a color.
+# Move the cursor vertically over each bar to alter its brightness. 
+
+class Brightness < Processing::App
+
+  def setup
+    no_stroke
+    color_mode HSB, 360, height, height
+    @bar_width = 5
+    @brightness = Array.new(width/@bar_width, 0)
+  end
+  
+  def draw
+  	(width/@bar_width).times do |i|
+  	  n = i * @bar_width
+  	  range = (n..n+@bar_width)
+  		@brightness[i] = mouse_y if range.include? mouse_x
+  		fill n, height, @brightness[i]
+  		rect n, 0, @bar_width, height
+		end
+  end
+  
+end
+
+Brightness.new :title => "Brightness", :width => 200, :height => 200

data/samples/processing_app/basics/color/color_wheel.rb

@@ -0,0 +1,97 @@
+require 'ruby-processing'
+
+# Subtractive Color Wheel 
+# by Ira Greenberg. 
+# 
+# The primaries are red, yellow, and blue. The
+# secondaries are green, purple, and orange. The 
+# tertiaries are  yellow-orange, red-orange, red-purple, 
+# blue-purple, blue-green, and yellow-green.
+# 
+# Create a shade or tint of the 
+# subtractive color wheel using
+# SHADE or TINT parameters.
+
+class ColorWheel < Processing::App
+
+  def setup
+    background 127
+    smooth
+    ellipse_mode RADIUS
+    no_stroke
+    
+    @style = :tint # use :shade or :tint
+    create_wheel width/2, height/2, @style
+  end
+  
+  
+  def create_wheel( x, y, value_shift )
+  
+  	segs        = 12
+  	steps       = 6
+  	rot_adjust  = (360.0 / segs / 2.0) * PI / 180
+  	radius      = 95.0
+  	seg_width   = radius / steps
+  	interval    = TWO_PI / segs
+  
+  	case value_shift
+  	when :shade
+  		steps.times do |j|
+  			cols = [
+  			  color(255-(255/steps)*j, 255-(255/steps)*j, 0), 
+				  color(255-(255/steps)*j, (255/1.5)-((255/1.5)/steps)*j, 0), 
+				  color(255-(255/steps)*j, (255/2)-((255/2)/steps)*j, 0), 
+				  color(255-(255/steps)*j, (255/2.5)-((255/2.5)/steps)*j, 0), 
+				  color(255-(255/steps)*j, 0, 0), 
+				  color(255-(255/steps)*j, 0, (255/2)-((255/2)/steps)*j), 
+				  color(255-(255/steps)*j, 0, 255-(255/steps)*j), 
+				  color((255/2)-((255/2)/steps)*j, 0, 255-(255/steps)*j), 
+				  color(0, 0, 255-(255/steps)*j),
+				  color(0, 255-(255/steps)*j, (255/2.5)-((255/2.5)/steps)*j), 
+				  color(0, 255-(255/steps)*j, 0), 
+				  color((255/2)-((255/2)/steps)*j, 255-(255/steps)*j, 0)
+  			]
+  			segs.times do |i|
+  				fill cols[i]
+  				arc x, y, radius, radius, interval*i+rot_adjust, interval*(i+1)+rot_adjust
+  			end
+  			radius -= seg_width
+  		end
+  		
+  	when :tint
+  		steps.times do |j|
+  			cols = [
+  				color((255/steps)*j, (255/steps)*j, 0), 
+				  color((255/steps)*j, ((255/1.5)/steps)*j, 0), 
+				  color((255/steps)*j, ((255/2)/steps)*j, 0), 
+				  color((255/steps)*j, ((255/2.5)/steps)*j, 0), 
+				  color((255/steps)*j, 0, 0), 
+				  color((255/steps)*j, 0, ((255/2)/steps)*j), 
+				  color((255/steps)*j, 0, (255/steps)*j), 
+				  color(((255/2)/steps)*j, 0, (255/steps)*j), 
+				  color(0, 0, (255/steps)*j),
+				  color(0, (255/steps)*j, ((255/2.5)/steps)*j), 
+				  color(0, (255/steps)*j, 0), 
+				  color(((255/2)/steps)*j, (255/steps)*j, 0)
+  			]
+  			segs.times do |i|
+  				fill cols[i]
+  				arc x, y, radius, radius, interval*i+rot_adjust, interval*(i+1)+rot_adjust
+  			end
+  			radius -= seg_width
+  		end
+  	end
+  end
+  
+  def draw
+    # Empty draw method. Things only change when you click.
+  end
+  
+  def mouse_pressed
+    @style = @style == :tint ? :shade : :tint
+    create_wheel width/2, height/2, @style
+  end
+  
+end
+
+ColorWheel.new :title => "Color Wheel", :width => 200, :height => 200

data/samples/processing_app/basics/color/creating.rb

@@ -0,0 +1,37 @@
+require 'ruby-processing'
+
+# Creating Colors (Homage to Albers). 
+# 
+# Creating variables for colors that may be referred to 
+# in the program by their name, rather than a number. 
+
+class Creating < Processing::App
+
+  def setup
+    
+    redder = color 204, 102, 0
+    yellower = color 204, 153, 0
+    orangish = color 153, 51, 0
+    
+	# These statements are equivalent to the statements above.
+	# Programmers may use the format they prefer.
+	
+	# redder = 0xFFCC6600
+	# yellower = 0xFFCC9900
+	# orangish = 0xFF993300
+    
+    no_stroke
+	
+	  fill orangish
+	  rect 0, 0, 200, 200
+	  
+	  fill yellower
+	  rect 40, 60, 120, 120
+	  
+	  fill redder
+	  rect 60, 90, 80, 80
+  end
+  
+end
+
+Creating.new :title => "Creating", :width => 200, :height => 200

data/samples/processing_app/basics/color/hue.rb

@@ -0,0 +1,29 @@
+require 'ruby-processing'
+
+# Hue is the color reflected from or transmitted through an object 
+# and is typically referred to as the name of the color (red, blue, yellow, etc.) 
+# Move the cursor vertically over each bar to alter its hue. 
+
+class Hue < Processing::App
+
+  def setup
+    @bar_width = 5
+    @hue = Array.new( (width/@bar_width), 0 )
+    
+    color_mode HSB, 360, height, height
+    no_stroke
+  end
+  
+  def draw
+  	(width/@bar_width).times do |i|
+  	  n = i * @bar_width
+  	  range = (n..n+@bar_width)
+  	  @hue[i] = mouse_y if range.include?(mouse_x)
+  		fill @hue[i], height/1.2, height/1.2
+  		rect n, 0, @bar_width, height
+		end
+  end
+  
+end
+
+Hue.new :title => "Hue", :width => 200, :height => 200

data/samples/processing_app/basics/color/linear_gradient.rb

@@ -0,0 +1,47 @@
+require 'ruby-processing'
+
+# Simple Linear Gradient 
+# by Ira Greenberg. 
+# 
+# Using the convenient red(), green() 
+# and blue() component functions,
+# generate some linear gradients.
+
+class LinearGradient < Processing::App
+
+  def setup
+    b1 = color 190
+    b2 = color 20
+    set_gradient 0, 0, width.to_f, height.to_f, b1, b2, :y_axis
+    
+    c1 = color 255, 120, 0 
+  	c2 = color 10, 45, 255 
+  	c3 = color 10, 255, 15 
+  	c4 = color 125, 2, 140 
+  	c5 = color 255, 255, 0 
+  	c6 = color 25, 255, 200 
+  	set_gradient 25, 25, 75, 75, c1, c2, true
+  	set_gradient 100, 25, 75, 75, c3, c4, false
+  	set_gradient 25, 100, 75, 75, c2, c5, false
+  	set_gradient 100, 100, 75, 75, c4, c6, true
+  end
+  
+  def set_gradient( x, y, w, h, c1, c2, vertical )
+  	delta_r = red(c2) - red(c1)
+  	delta_g = green(c2) - green(c1)
+  	delta_b = blue(c2) - blue(c1)
+  	
+	  x.upto( x+w ) do |i|
+	  	y.upto( y+w ) do |j|
+	  		c = color(red(c1)+(j-y)*(delta_r/h),
+	  				      green(c1)+(j-y)*(delta_g/h),
+	  				      blue(c1)+(j-y)*(delta_b/h) )
+	  				      
+	  		vertical ? set(i, j, c) : set(j, i, c)
+	  	end
+	  end
+  end
+  
+end
+
+LinearGradient.new :title => "Linear Gradient", :width => 200, :height => 200

data/samples/processing_app/basics/color/radial_gradient.rb

@@ -0,0 +1,52 @@
+require 'ruby-processing'
+
+# Simple Radial Gradient 
+# by Ira Greenberg. 
+# 
+# Using the convenient red(), green() 
+# and blue() component functions,
+# generate an array of radial gradients.
+
+class RadialGradient < Processing::App
+
+  def setup
+    background 0
+    smooth
+    no_fill
+    stroke_width 1.8
+    
+    columns = 4
+    radius = (width / columns) / 2
+    diameter = radius * 2
+    
+    (width / diameter).times do |left|
+    	(height / diameter).times do |top|
+    		create_gradient( 
+    		  radius+left*diameter, radius+top*diameter, radius, random_color, random_color 
+    		)
+    	end
+    end
+  end
+  
+  def random_color
+    color(rand(255), rand(255), rand(255))
+  end
+  
+  def create_gradient( x, y, radius, c1, c2 )
+  	
+  	delta_r = red(c2)   - red(c1)
+  	delta_g = green(c2) - green(c1)
+  	delta_b = blue(c2)  - blue(c1)
+  	  	
+  	radius.times do |r|
+  	  c = color(red(c1)   + r * (delta_r / radius),
+      				  green(c1) + r * (delta_g / radius),
+      				  blue(c1)  + r * (delta_b / radius))
+      stroke c
+      ellipse x, y, r*2, r*2
+  	end
+  end
+  
+end
+
+RadialGradient.new :title => "Radial Gradient", :width => 200, :height => 200