ruby-processing 1.0.11 → 2.4.1

data/samples/processing_app/basics/data/datatype_conversion.rb

@@ -1,4 +1,3 @@
-require 'ruby-processing'
 
 # Processings datatype conversion functions make no sense for Ruby as it does
 # not have primitive datatypes. Try these instead:
@@ -7,39 +6,36 @@ require 'ruby-processing'
 # "to_f" (to Float, which would be "double" in Processing, not "float")
 # "to_a" (to Array, i.e. from a Range or Hash)
 
-class DatatypeConversion < Processing::App
 
-  def setup
-  	
-  	# Ruby has no primitive datatypes, everything is an object!
-  	# See:
-  	[1, 2.0, 'a', "B", nil, false].each do |element|
-  		puts
-  		puts "#{element.inspect} ... is a #{element.class.name} object"
-  	end
-  	
-  	c = 'A' # String (!) as there is no char datatype in Ruby.
-  			    # Single quotes are parsed without substitutions (i.e. "It is #{Time.now}.")
-  	
-  	f = c[0].to_f # Sets f = 65.0
-  	              # will become "c.ord.to_f" in Ruby 1.9+
-  	
-  	i = (f * 1.4).to_i # Sets i to 91
-  	
-  	b = (c[0] / 2) # Integer or FixNum as there is no byte in Ruby
-  	
-  	background 51
-  	no_stroke
-  	
-  	rect f, 0, 40, 66
-  	
-  	fill 204
-  	rect i, 67, 40, 66
-  	
-  	fill 255
-  	rect b, 134, 40, 66
+def setup
+  size 200, 200
+  # Ruby has no primitive datatypes, everything is an object!
+  # See:
+  [1, 2.0, 'a', "B", nil, false].each do |element|
+    puts
+    puts "#{element.inspect} ... is a #{element.class.name} object"
   end
   
+  c = 'A' # String (!) as there is no char datatype in Ruby.
+  # Single quotes are parsed without substitutions (i.e. "It is #{Time.now}.")
+  
+  f = c.ord.to_f # Sets f = 65.0
+  # was "[c].to_f" in Ruby 1.8
+  
+  i = (f * 1.4).to_i # Sets i to 91
+  
+  b = (c.ord.to_i / 2) # Integer or FixNum as there is no byte in Ruby
+  
+  background 51
+  no_stroke
+  
+  rect f, 0, 40, 66
+  
+  fill 204
+  rect i, 67, 40, 66
+  
+  fill 255
+  rect b, 134, 40, 66
 end
 
-DatatypeConversion.new :title => "Datatype Conversion", :width => 200, :height => 200
+

data/samples/processing_app/basics/data/integers_floats.rb

@@ -1,34 +1,28 @@
-require 'ruby-processing'
-
 # Integers and floats are two different kinds of numerical data. 
 # An integer (more commonly called an int) is a number without 
 # a decimal point. A float is a floating-point number, which means 
 # it is a number that has a decimal place. Floats are used when
 # more precision is needed. 
 
-class IntegersFloats < Processing::App
 
-  def setup
-    stroke 255
-    frame_rate 30
-    
-    @a = 0		# Create an instance variable "a" of class Integer
-    @b = 0.0	# Create an instance variable "b" of class Float (because of "0.0")
-  end
-  
-  def draw
-  	background 51
-  	
-  	@a += 1
-  	@b += 0.2
-  	
-  	line @a, 0,        @a, height/2
-  	line @b, height/2, @b, height
-  	
-  	@a = 0 if @a > width
-  	@b = 0 if @b > width
-  end
+def setup
+  size 200, 200  
+  stroke 255
+  frame_rate 30
   
+  @a = 0		# Create an instance variable "a" of class Integer
+  @b = 0.0	# Create an instance variable "b" of class Float (because of "0.0")
 end
 
-IntegersFloats.new :title => "Integers Floats", :width => 200, :height => 200
+def draw
+  background 51
+  
+  @a += 1
+  @b += 0.2
+  
+  line @a, 0,        @a, height/2
+  line @b, height/2, @b, height
+  
+  @a = 0 if @a > width
+  @b = 0 if @b > width
+end

data/samples/processing_app/basics/data/true_false.rb

@@ -1,5 +1,3 @@
-require 'ruby-processing'
-
 # Boolean data is one bit of information. True or false. 
 # It is common to use Booleans with control statements to 
 # determine the flow of a program. In this example, when the
@@ -9,29 +7,25 @@ require 'ruby-processing'
 # In Ruby, false and nil are "falsy" ... they are the only things
 # that will fail an "if" test. Absolutely everything else passes "if".
 
-class TrueFalse < Processing::App
-
-  def setup
-  	  background 0
-  	  stroke 0
-  	  
-  	  (1..width).step(2) do |i|
-  	    
-  	    x = i < (width/2) # Evaluates to true or false, depending on i
-  	    
-  	    if x
-  	    	stroke 255
-  	    	line i, 1, i, height-1
-  	    end
-  	    
-  	    if !x
-  	    	stroke 126
-  	    	line width/2, i, width-2, i
-  	    end
-  	      
-  	  end
-  end
+def setup
+  size 200, 200
+  background 0
+  stroke 0
   
+  (1..width).step(2) do |i|
+    
+    x = i < (width/2) # Evaluates to true or false, depending on i
+    
+    if x
+      stroke 255
+      line i, 1, i, height-1
+    end
+    
+    if !x
+      stroke 126
+      line width/2, i, width-2, i
+    end
+    
+  end
 end
 
-TrueFalse.new :title => "True False", :width => 200, :height => 200

data/samples/processing_app/basics/data/variable_scope.rb

@@ -1,5 +1,3 @@
-require 'ruby-processing'
-
 # Variables may either have a global or local "scope". 
 # For example, variables declared within either the
 # setup or draw functions may be only used in these
@@ -13,68 +11,64 @@ require 'ruby-processing'
 # Please note that there are some changes on variable scope inside blocks
 # between Ruby versions 1.8 and 1.9.
 
-class VariableScope < Processing::App
 
-  def setup
-  		background 51
-  		stroke 255
-  		no_loop
-  		
-  		@a = 20 # Use "@" before the name to create an instance variable ("@a"), 
-  				    # which will be available anywhere inside this instance of "VariableScope".
-  end
+def setup
+  background 51
+  stroke 255
+  no_loop
   
-  def draw
-  		# Draw a line using the instance variable "a", 
-  		# as returned by its getter function below
-  		line a, 0, a, height
-  		
-  		# Create a new variable "a" local to the block (do-end)
-  		(50..80).step(2) do |a|
-  			line a, 0, a, height
-  		end
-  		
-  		# Create a new variable "a" local to the draw method
-  		a = 100
-  		line a, 0, a, height
-  		
-  		# Make a call to the custom function draw_another_line
-  		draw_another_line
-  		
-  		# Make a call to the custom function draw_yet_another_line
-  		draw_yet_another_line
-  end
-  
-  def draw_another_line
-  		# Create a new variable "a" local to this method
-  		a = 185
-  		
-  		# Draw a line using the local variable "a"
-  		line a, 0, a, height
-  end
-  
-  def draw_yet_another_line
-  		# Because no new local variable "a" is set, this line draws using the 
-  		# instance variable "a" (returned by its getter function) which was 
-  		# set to the value 20 in setup.
-  		line a+2, 0, a+2, height
-  end
+  @a = 20 # Use "@" before the name to create an instance variable ("@a"), 
+  # which will be available anywhere inside this instance of "VariableScope".
+end
+
+def draw
+  # Draw a line using the instance variable "a", 
+  # as returned by its getter function below
+  line a, 0, a, height
   
-  # This is a "getter" function, it returns the value of the instance variable "a"
-  def a
-  	@a
+  # Create a new variable "a" local to the block (do-end)
+  (50..80).step(2) do |a|
+    line a, 0, a, height
   end
   
-  # Ruby can add that getter function for you automatically:
-  # attr_reader :a
+  # Create a new variable "a" local to the draw method
+  a = 100
+  line a, 0, a, height
   
-  # And this would create a setter which will allow you to set "a" to a value ( "a = 123" )
-  # without using that "@" sign all the time:
-  # attr_writer :a
+  # Make a call to the custom function draw_another_line
+  draw_another_line
   
-  # Or you could just have Ruby add both at once with:
-  # attr_accessor :a
+  # Make a call to the custom function draw_yet_another_line
+  draw_yet_another_line
+end
+
+def draw_another_line
+  # Create a new variable "a" local to this method
+  a = 185
   
+  # Draw a line using the local variable "a"
+  line a, 0, a, height
 end
 
-VariableScope.new :title => "Variable Scope", :width => 200, :height => 200
+def draw_yet_another_line
+  # Because no new local variable "a" is set, this line draws using the 
+  # instance variable "a" (returned by its getter function) which was 
+  # set to the value 20 in setup.
+  line a+2, 0, a+2, height
+end
+
+# This is a "getter" function, it returns the value of the instance variable "a"
+def a
+  @a
+end
+
+# Ruby can add that getter function for you automatically:
+# attr_reader :a
+
+# And this would create a setter which will allow you to set "a" to a value ( "a = 123" )
+# without using that "@" sign all the time:
+# attr_writer :a
+
+# Or you could just have Ruby add both at once with:
+# attr_accessor :a
+

data/samples/processing_app/basics/data/variables.rb

@@ -1,40 +1,35 @@
-require 'ruby-processing'
-
 # Variables are used for storing values. In this example, changing 
 # the values of variables @one and @two significantly changes the composition. 
 
-class Variables < Processing::App
-  
-  load_library :control_panel
-  
-  def setup
-    stroke 153
-    
-    @one = 20 # Change these with the sliders
-    @two = 50
-    
-    control_panel do |c|
-      c.slider :one, -20..100
-      c.slider :two, -20..100
-    end
-  end
+load_library :control_panel
+attr_reader :panel
+def setup
+  size 200, 200  
+  stroke 153    
+  @one = 20 # Change these with the sliders
+  @two = 50    
+  control_panel do |c|
+    c.slider :one, -20..100
+    c.slider :two, -20..100
+    @panel = c
+  end  
+end
 
 
-  def draw
-    background 0
-    
-    c = @one * 8
-    d = @one * 9
-    e = @two - @one
-    f = @two * 2
-    g = f  + e
-    
-    line @one, f, @two,  g
-    line @two, e, @two,  g
-    line @two, e, d,     c
-    line @one, e, d-e,   c
-  end
+def draw
+  panel.set_visible(true)
+  background 0    
+  c = @one * 8
+  d = @one * 9
+  e = @two - @one
+  f = @two * 2
+  g = f  + e
   
+  line @one, f, @two,  g
+  line @two, e, @two,  g
+  line @two, e, d,     c
+  line @one, e, d-e,   c
 end
 
-Variables.new :title => "Variables", :width => 200, :height => 200
+
+

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

@@ -1,23 +1,20 @@
-require 'ruby-processing'
-
 # The first two parameters for the bezier function specify the 
 # first point in the curve and the last two parameters specify 
 # the last point. The middle parameters set the control points
 # that define the shape of the curve. 
 
-class Bezier < Processing::App
 
-  def setup
-    background 0
-    stroke 255
-    no_fill
-    smooth
-    
-    (0..100).step(20) do |i|
-    	bezier 90-(i/2.0), 20+i, 210, 10, 220, 150, 120-(i/8.0), 150+(i/4.0)
-    end
-  end
+def setup
+  size 640, 360  
   
+  stroke 255
+  no_fill
+end
+
+def draw
+  background 0
+  (0..200).step(20) do |i|
+    bezier(mouse_x - (i/2.0), 40+i, 410, 20, 440, 300, 240-(i/16.0), 300+(i/8.0))
+  end
 end
 
-Bezier.new :title => "Bezier", :width => 200, :height => 200

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

@@ -1,5 +1,3 @@
-require 'ruby-processing'
-
 # Bezier Ellipse  
 # By Ira Greenberg 
 # 
@@ -8,103 +6,94 @@ require 'ruby-processing'
 # second a new ellipse is plotted using 
 # random values for control/anchor points.
 
-class BezierEllipse < Processing::App
 
-  # have Ruby add getter/setter functions for these,
-	# so we don't have to write "@var" all the time
-	attr_accessor :px, :py, :cx, :cy, :cx2, :cy2 
+# have Ruby add getter/setter functions for these,
+# so we don't have to write "@var" all the time
+attr_accessor :px, :py, :cx, :cy, :cx2, :cy2, :color_controls, :color_anchors 
 
-  def setup
-  	@color_controls = 0xFF222222
-  	@color_anchors  = 0xFFBBBBBB
-  	
-  	smooth
-  	rect_mode CENTER
-    set_ellipse 4, 65, 65
-    frame_rate 1
-  end
-  
-  def draw
-  	background 145
-  	draw_ellipse
-  	set_ellipse random(3, 12).to_i, random(-100, 150), random(-100, 150)
+def setup
+  size 640, 360  
+  # wrap as color else complain too big for int
+  @color_controls = color(0xFF222222)
+  @color_anchors  = color(0xFFBBBBBB) 	
+  rect_mode CENTER
+  set_ellipse 4, 65, 65
+  frame_rate 1
+end
+
+def draw
+  background 145
+  draw_ellipse
+  set_ellipse rand(3 .. 12), rand(-100 .. 150), rand(-100 .. 150)
+end
+
+def draw_ellipse    
+  number_of_points = px.length # all our arrays have same length  	
+  # draw shape  	
+  stroke_weight 1.125
+  stroke 255
+  no_fill  	
+  number_of_points.times do |i|
+    i2 = (i+1) % number_of_points  # wrap around to make a loop
+    bezier px[i], py[i], 
+    cx[i], cy[i], 
+    cx2[i], cy2[i], 
+    px[i2], py[i2]
   end
   
-  def draw_ellipse
-  
-  	number_of_points = px.length # all our arrays have same length
+  # draw lines and handles
   
-  	# draw shape
+  stroke_weight 0.75
+  stroke 0
   
-  	stroke_weight 1.125
-  	stroke 255
-  	no_fill
-  	
-  	number_of_points.times do |i|
-  		i2 = (i+1) % number_of_points  # wrap around to make a loop
-		  bezier px[i], py[i], 
-			       cx[i], cy[i], 
-			       cx2[i], cy2[i], 
-			       px[i2], py[i2]
-  	end
-  	  	
-  	# draw lines and handles
-  	
-  	stroke_weight 0.75
-  	stroke 0
-  	
-  	number_of_points.times do |i|
-  		i2 = (i+1) % number_of_points
-  		line px[i], py[i], cx[i], cy[i]      # anchor to control 1
-  		line cx2[i], cy2[i], px[i2], py[i2]  # control 2 to next anchor
-  	end
-  	
-  	number_of_points.times do |i|
-  		fill @color_controls
-  		no_stroke
-  		
-  		ellipse cx[i], cy[i], 4, 4
-  		ellipse cx2[i], cy2[i], 4, 4
-  		
-  		fill @color_anchors
-  		stroke 0
-  		
-  		rect px[i], py[i], 5, 5
-  	end
+  number_of_points.times do |i|
+    i2 = (i+1) % number_of_points
+    line px[i], py[i], cx[i], cy[i]      # anchor to control 1
+    line cx2[i], cy2[i], px[i2], py[i2]  # control 2 to next anchor
   end
   
-  def set_ellipse( points, radius, control_radius )
+  number_of_points.times do |i|
+    fill color_controls
+    no_stroke
+    
+    ellipse cx[i], cy[i], 4, 4
+    ellipse cx2[i], cy2[i], 4, 4
+    
+    fill color_anchors 
+    stroke 0
+    
+    rect px[i], py[i], 5, 5
+  end
+end
+
+def set_ellipse(points, radius, control_radius)
   
 	# first time we come here the instance variables are created
 	# therefore we need to use "@" or "self.". the former will access the variable
-	# directly the later will use the setter function created by "attr_accessor".
-  	@px , self.py , @cx , @cy , @cx2 , @cy2 = [], [], [], [], [], [] 
-
-  	angle = 360.0/points
-  	control_angle_1 = angle/3.0
-  	control_angle_2 = control_angle_1*2.0
-  	points.times do |i|
-  		px[i] = width/2+cos(angle.radians)*radius
-  		
-    	py[i] = height/2+sin(angle.radians)*radius
-    	
-    	cx[i] = width/2+cos((angle+control_angle_1).radians)* 
-      			control_radius/cos((control_angle_1).radians)
-      			
-    	cy[i] = height/2+sin((angle+control_angle_1).radians)* 
-      			control_radius/cos((control_angle_1).radians)
-      			
-    	cx2[i] = width/2+cos((angle+control_angle_2).radians)* 
-      			control_radius/cos((control_angle_1).radians)
-      			
-    	cy2[i] = height/2+sin((angle+control_angle_2).radians)* 
-      			control_radius/cos((control_angle_1).radians)
-
-    	#increment angle so trig functions keep chugging along
-    	angle += 360.0/points
-  	end
-  end
-  
+	# directly the latter will use the setter function created by "attr_accessor".
+	@px, self.py, @cx, @cy, @cx2, @cy2 = [], [], [], [], [], [] 
+	
+	angle = 360.0/points
+	control_angle_1 = angle/3.0
+	control_angle_2 = control_angle_1*2.0
+	points.times do |i|
+	  px[i] = width/2+cos(angle.radians)*radius
+	  
+	  py[i] = height/2+sin(angle.radians)*radius
+	  
+	  cx[i] = width/2+cos((angle+control_angle_1).radians)* 
+	    control_radius/cos((control_angle_1).radians)
+	  
+	  cy[i] = height/2+sin((angle+control_angle_1).radians)* 
+	    control_radius/cos((control_angle_1).radians)
+	  
+	  cx2[i] = width/2+cos((angle+control_angle_2).radians)* 
+	    control_radius/cos((control_angle_1).radians)
+	  
+	  cy2[i] = height/2+sin((angle+control_angle_2).radians)* 
+	    control_radius/cos((control_angle_1).radians)
+	  
+	  #increment angle so trig functions keep chugging along
+	  angle += 360.0/points
+	end
 end
-
-BezierEllipse.new :title => "Bezier Ellipse", :width => 200, :height => 200