ruby-processing 1.0.2 → 1.0.3

data/samples/processing_app/basics/form/shape_primitives.rb

@@ -0,0 +1,25 @@
+require 'ruby-processing'
+
+# The basic shape primitive functions are triangle, rect, 
+# quad, and ellipse. Squares are made with rect and circles 
+# are made with ellipse. Each of these functions requires a number
+# of parameters to determine the shape's position and size.
+
+
+class ShapePrimitives < Processing::App
+
+  def setup
+	smooth   
+	background 0 
+	no_stroke
+	fill 226 
+	triangle 10, 10, 10, 200, 45, 200 
+	rect 45, 45, 35, 35 
+	quad 105, 10, 120, 10, 120, 200, 80, 200 
+	ellipse 140, 80, 40, 40 
+	triangle 160, 10, 195, 200, 160, 200  
+  end
+  
+end
+
+ShapePrimitives.new :title => "Shape Primitives", :width => 200, :height => 200

data/samples/processing_app/basics/form/triangle_strip.rb

@@ -0,0 +1,43 @@
+require 'ruby-processing'
+
+# TRIANGLE_STRIP Mode
+# by Ira Greenberg. 
+# 
+# Generate a closed ring using vertex() 
+# function and beginShape(TRIANGLE_STRIP)
+# mode. outerRad and innerRad variables 
+# control ring's outer/inner radii respectively.
+# Trig functions generate ring.
+
+class TriangleStrip < Processing::App
+
+  def setup
+    background 204
+    smooth
+    
+    x = width/2
+    y = height/2
+    outer_radius = 80
+    inner_radius = 50
+    px, py, angle = 0.0, 0.0, 0.0
+    number_of_points = 36
+    rotation = 360.0/number_of_points
+    
+    begin_shape TRIANGLE_STRIP
+    number_of_points.times do |i|
+      px = x + cos(angle.radians)*outer_radius
+		  py = y + sin(angle.radians)*outer_radius
+		  angle += rotation
+		  vertex px, py
+		  
+		  px = x + cos(angle.radians)*inner_radius
+		  py = y + sin(angle.radians)*inner_radius
+		  angle += rotation
+		  vertex px, py
+    end
+    end_shape
+  end
+  
+end
+
+TriangleStrip.new :title => "Triangle Strip", :width => 200, :height => 200

data/samples/processing_app/basics/form/vertices.rb

@@ -0,0 +1,51 @@
+require 'ruby-processing'
+
+# The beginShape() function begins recording vertices 
+# for a shape and endShape() stops recording. 
+# A vertex is a location in space specified by X, Y, 
+# and sometimes Z coordinates. After calling the beginShape() function, 
+# a series of vertex() functions must follow.  
+# To stop drawing the shape, call the endShape() functions.
+
+class Vertices < Processing::App
+
+  def setup
+    background 0
+    no_fill
+    
+    stroke 102
+    begin_shape  
+		curve_vertex 168, 182 
+		curve_vertex 168, 182 
+		curve_vertex 136, 38 
+		curve_vertex 42, 34 
+		curve_vertex 64, 200 
+		curve_vertex 64, 200 
+	  end_shape  
+	
+	  stroke 51 
+	  begin_shape LINES 
+		vertex 60, 40 
+		vertex 160, 10 
+		vertex 170, 150 
+		vertex 60, 150 
+	  end_shape  
+	
+	  stroke 126 
+	  begin_shape  
+		vertex 60, 40 
+		bezier_vertex 160, 10, 170, 150, 60, 150 
+	  end_shape  
+	
+	  stroke 255 
+	  begin_shape POINTS 
+		vertex 60, 40 
+		vertex 160, 10 
+		vertex 170, 150 
+		vertex 60, 150 
+	  end_shape  
+  end
+  
+end
+
+Vertices.new :title => "Vertices", :width => 200, :height => 200

data/samples/processing_app/basics/image/alphamask.rb

@@ -0,0 +1,23 @@
+require 'ruby-processing'
+
+# Loads a "mask" for an image to specify the transparency 
+# in different parts of the image. The two images are blended
+# together using the mask() method of PImage. 
+
+class Alphamask < Processing::App
+
+  def setup
+    @image = load_image "test.jpg"
+    @image_mask = load_image "mask.jpg"
+    @image.mask @image_mask
+  end
+  
+  def draw
+  	background (mouse_x + mouse_y) / 1.5
+  	image @image, 50, 50
+  	image @image, mouse_x-50, mouse_y-50
+  end
+  
+end
+
+Alphamask.new :title => "Alphamask", :width => 200, :height => 200

data/samples/processing_app/basics/image/background_image.rb

@@ -0,0 +1,30 @@
+require 'ruby-processing'
+
+# This example presents the fastest way to load a background image
+# into Processing. To load an image as the background, it must be
+# the same width and height as the program.
+
+class BackgroundImage < Processing::App
+
+  def setup
+    frame_rate 30
+    @a = 0
+    
+    # The background image must be the same size as the parameters
+  	# into the size method. In this program, the size of "milan_rubbish.jpg"
+  	# is 200 x 200 pixels.
+    @background_image = load_image "milan_rubbish.jpg"
+  end
+  
+  def draw
+  	background @background_image
+  	
+  	@a = (@a + 1) % (width+32)
+  	stroke 266, 204, 0
+  	line 0, @a,   width, @a-26
+  	line 0, @a-6, width, @a-32
+  end
+  
+end
+
+BackgroundImage.new :title => "Background Image", :width => 200, :height => 200

data/samples/processing_app/basics/image/create_image.rb

@@ -0,0 +1,23 @@
+require 'ruby-processing'
+
+# The createImage() function provides a fresh buffer of pixels to play with.
+# This example creates an image gradient.
+
+class CreateImage < Processing::App
+
+  def setup
+    @image = create_image 120, 120, ARGB
+    @image.pixels.length.times do |i|
+    	@image.pixels[i] = color 0, 90, 102, (i % @image.width * 2) # red, green, blue, alpha
+    end
+  end
+  
+  def draw
+  	background 204
+  	image @image, 33, 33
+  	image @image, mouse_x-60, mouse_y-60
+  end
+  
+end
+
+CreateImage.new :title => "Create Image", :width => 200, :height => 200

data/samples/processing_app/basics/image/load_display_image.rb

@@ -0,0 +1,25 @@
+require 'ruby-processing'
+
+# Images can be loaded and displayed to the screen at their actual size
+# or any other size. 
+
+class LoadDisplayImage < Processing::App
+
+  def setup
+    # The file "jelly.jpg" must be in the data folder
+  	# of the current sketch to load successfully
+    @a = load_image "jelly.jpg"
+    
+    no_loop # Makes draw only run once
+  end
+  
+  def draw
+  	# Displays the image at its actual size at point (0,0)
+  	image @a, 0, 0
+	  # Displays the image at point (100, 0) at half of its size
+  	image @a, 100, 0, @a.width/2, @a.height/2
+  end
+  
+end
+
+LoadDisplayImage.new :title => "Load Display Image", :width => 200, :height => 200

data/samples/processing_app/basics/image/pointillism.rb

@@ -0,0 +1,30 @@
+require 'ruby-processing'
+
+# Pointillism
+# by Daniel Shiffman. 
+# 
+# Mouse horizontal location controls size of dots. 
+# Creates a simple pointillist effect using ellipses colored
+# according to pixels in an image. 
+
+class Pointillism < Processing::App
+
+  def setup
+    @a = load_image "eames.jpg"
+    
+    no_stroke
+    background 255
+    smooth
+  end
+  
+  def draw
+  	pointillize = map mouse_x, 0, width, 2, 18
+  	x, y = rand(@a.width), rand(@a.height)
+  	pixel = @a.get(x, y)
+  	fill pixel
+  	ellipse x, y, pointillize, pointillize
+  end
+  
+end
+
+Pointillism.new :title => "Pointillism", :width => 200, :height => 200

data/samples/processing_app/basics/image/request_image.rb

@@ -0,0 +1,71 @@
+require 'ruby-processing'
+
+# Request Image
+# by Ira Greenberg. 
+# From Processing for Flash Developers, Friends of ED, 2009. 
+# 
+# Shows how to use the request_image() function with preloader animation. 
+# The request_image() function loads images on a separate thread so that 
+# the sketch does not freeze while they load. It's very useful when you are
+# loading large images, as this example demonstrates. 
+# 
+# To work, this example requires 10 images named dublin0.jpg ... dublin9.jpg 
+# in the sketch data directory. To save space, these images are not included 
+# with the example.
+
+class RequestImage < Processing::App
+
+  def setup
+	  smooth
+	  
+	  @imgs = Array.new 10
+	  @load_states = Array.new( @imgs.length, false )
+	  @loader_x, @loader_y, @theta = 0.0, 0.0, 0.0
+	
+	  # Load images asynchronously
+	  @imgs.length.times do |i|
+		  @imgs[i] = request_image "dublin" + i.to_s + ".jpg"
+	  end
+  end
+  
+  def draw
+  	background 0
+  	
+  	run_loader_animation
+  	
+	  # Check if individual images are fully loaded
+	  @imgs.each_with_index do |img, i|
+	  	# As images are loaded set true in boolean array
+	  	@load_states[i] = (img.width != 0) && (img.width != -1)
+	  end
+	
+	  # When all images are loaded draw them to the screen
+	  if all_loaded?
+	  	@img.each_with_index do |img, i|
+	  		image( img, width/@imgs.length*i, 0, width/@imgs.length, height )
+	  	end
+	  end
+  end
+  
+  # Loading animation
+  def run_loader_animation
+  	# Only run when images are loading
+  	if all_loaded?
+  		ellipse loader_x, loader_y, 10, 10
+		loader_x += 2
+		loader_y = height/2 + sin(theta) * (height/2.5)
+		theta += PI/22
+		
+		# Reposition ellipse if it goes off the screen
+		loader_x = -5 if loader_x > (width + 5)
+  	end
+  end
+  
+  # Return true when all images are loaded - no false values left in array
+  def all_loaded?
+  	@load_states.each { |state| return false unless state }
+  	true
+  end
+end
+
+RequestImage.new :title => "Request Image", :width => 800, :height => 60

data/samples/processing_app/basics/image/sprite.rb

@@ -0,0 +1,38 @@
+require 'ruby-processing'
+
+# Sprite (Teddy)
+# by James Patterson. 
+# 
+# Demonstrates loading and displaying a transparent GIF image. 
+
+class Sprite < Processing::App
+
+  def setup
+    @teddy = load_image "teddy.gif"
+    @xpos, @ypos = width/2, height/2
+    @drag = 30.0
+    
+    frame_rate 60
+  end
+  
+  def draw
+  	background 102
+  	
+  	difx = mouse_x - @xpos - @teddy.width/2
+  	if difx.abs > 1.0
+  		@xpos += difx/@drag
+  		@xpos = constrain( @xpos, 0, width-@teddy.width/2 )
+  	end
+  	
+  	dify = mouse_y - @ypos - @teddy.height/2
+  	if dify.abs > 1.0
+  		@ypos += dify/@drag
+  		@ypos = constrain( @ypos, 0, height-@teddy.height/2 )
+  	end
+  	
+  	image @teddy, @xpos, @ypos
+  end
+  
+end
+
+Sprite.new :title => "Sprite", :width => 200, :height => 200

data/samples/processing_app/basics/image/transparency.rb

@@ -0,0 +1,27 @@
+require 'ruby-processing'
+
+#  Move the pointer left and right across the image to change
+#  its position. This program overlays one image over another 
+#  by modifying the alpha value of the image with the tint() function. 
+
+class Transparency < Processing::App
+
+  def setup
+    @a = load_image "construct.jpg"
+    @b = load_image "wash.jpg"
+    @offset = 0.0
+    
+    frame_rate 60
+  end
+  
+  def draw
+  	image @a, 0, 0
+  	offset_target = map( mouse_x, 0, width, -@b.width/2 - width/2, 0 )
+  	@offset += (offset_target - @offset) * 0.05
+  	tint 255, 153
+  	image @b, @offset, 20
+  end
+  
+end
+
+Transparency.new :title => "Transparency", :width => 200, :height => 200

data/samples/processing_app/basics/input/clock.rb

@@ -0,0 +1,46 @@
+require 'ruby-processing'
+
+# The current time can be read with the second(), minute(), 
+# and hour() functions. In this example, sin() and cos() values
+# are used to set the position of the hands.
+
+class Clock < Processing::App
+
+  def setup
+    stroke 255
+    smooth
+  end
+  
+  def draw
+  	background 0
+  	fill 80
+  	no_stroke
+  	
+  	# Angles for sin() and cos() start at 3 o'clock;
+  	# subtract HALF_PI to make them start at the top
+  	ellipse 100, 100, 160, 160
+  	
+  	s = map( second, 0, 60, 0, TWO_PI) - HALF_PI
+  	m = map( minute + norm( second, 0, 60 ), 0, 60, 0, TWO_PI ) - HALF_PI
+  	h = map( hour + norm( minute, 0, 60 ), 0, 24, 0, TWO_PI * 2 ) - HALF_PI
+  	
+  	stroke 255
+  	stroke_weight 1
+  	line( 100, 100, cos(s)*72 + 100, sin(s)*72 + 100 )
+  	stroke_weight 2
+  	line( 100, 100, cos(m)*60 + 100, sin(m)*60 + 100 )
+  	stroke_weight 4
+  	line( 100, 100, cos(h)*50 + 100, sin(h)*50 + 100 )
+  	
+  	# Draw the minute ticks
+  	stroke_weight 2
+  	(0..360).step(6) do |a|
+  		x = 100 + cos( a.radians ) * 72
+  		y = 100 + sin( a.radians ) * 72
+  		point x, y
+  	end
+  end
+  
+end
+
+Clock.new :title => "Clock", :width => 200, :height => 200