ruby-processing 1.0.11 → 2.4.1

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

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

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

@@ -1,61 +1,41 @@
+#
 # Noise Wave
+# by Daniel Shiffman.  
+# 
+# Using Perlin Noise to generate a wave-like pattern. 
+#
 
-class NoiseWave < Processing::App
+attr_reader :yoff         # 2nd dimension of perlin noise
 
-  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
+def setup
+  size(640, 360)
+  @yoff = 0.0        
+end
+
+def draw
+  background(51)
+
+  fill(255)
+  # We are going to draw a polygon out of the wave points
+  begin_shape 
+  
+  xoff = 0       # Option #1: 2D Noise
+  # xoff = yoff # Option #2: 1D Noise
+  
+  # Iterate over horizontal pixels
+  (0 .. width).step(10) do |x|
+    # Calculate a y value according to noise, map to 
+    y = map(noise(xoff, yoff), 0, 1, 200,300) # Option #1: 2D Noise
+    # y = map(noise(xoff), 0, 1, 200,300)    # Option #2: 1D Noise
     
+    # Set the vertex
+    vertex(x, y) 
+    # Increment x dimension for noise
+    xoff += 0.05
   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
-  
+  # increment y dimension for noise
+  @yoff += 0.01
+  vertex(width, height)
+  vertex(0, height)
+  end_shape(CLOSE)
 end
-
-NoiseWave.new :title => "Noise Wave"

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

@@ -9,7 +9,7 @@
 # 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: * / %
@@ -20,51 +20,30 @@
 # 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
-  
+size 640, 360    
+background 51    
+no_fill
+stroke 204    
+(0...(width-20)).step(4) do |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
+end
+
+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, 290, 48 )
+rect( (4 + 2) * 8, 100, 290, 49 )
+stroke 153    
+(0...width).step(2) do |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
 
-OperatorPrecedence.new :title => "Operator Precedence"

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

@@ -4,41 +4,28 @@
 # Convert a polar coordinate (r,theta) to cartesian (x,y):  
 # x = r * cos(theta)
 # y = r * sin(theta)
- 
-class PolarToCartesian < Processing::App
+attr_reader :r, :theta
 
-  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
-  
+def setup  
+  size 640, 360  
+  frame_rate 30
+  @r = height * 0.45
+  @theta = 0.0
+  @theta_vel = 0.0
+  @theta_acc = 0.1e-3
+end
+
+def draw  
+  background 0  
+  translate width/2, height/2 
+  # Convert polar to cartesian
+  x = r * cos(theta)
+  y = r * sin(theta)  
+  ellipse_mode CENTER
+  no_stroke
+  fill 200
+  ellipse x, y, 32, 32  
+  @theta_vel += @theta_acc
+  @theta += @theta_vel  
 end
 
-PolarToCartesian.new :title => "Polar To Cartesian"

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

@@ -3,33 +3,19 @@
 # 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
-  
+def setup    
+  size 640, 360
+  stroke_weight 10    
+  no_loop    
 end
 
-Random.new :title => "Random"
+def draw  	
+  background 0    
+  (0...width).each do |i|    
+    r = rand(255)
+    x = rand(0 .. width)
+    stroke(r, 100)
+    line(i, 0, x, height)
+  end    
+end

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

@@ -0,0 +1,23 @@
+#
+# Random Gaussian. 
+# 
+# This sketch draws ellipses with x and y locations tied to a gaussian distribution of random numbers.
+#
+
+def setup
+  size(640, 360)
+  background(0)
+end
+
+def draw
+  # Get a gaussian random number w/ mean of 0 and standard deviation of 1.0
+  val = random_gaussian
+  sd = 60                  # Define a standard deviation
+  mean = width/2           # Define a mean value (middle of the screen along the x-axis)
+  x = (val * sd) + mean    # Scale the gaussian random number by standard deviation and mean
+  fill(200, 20)
+  no_stroke
+  ellipse(x, height/2, 32, 32)   # Draw an ellipse at our "normal" random location
+end
+
+

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

@@ -2,48 +2,34 @@
 # 
 # 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
+def setup    
+  size 640, 360
+  no_stroke
+  @diameter = 84.0
+  @sin = 0.0
+  @angle = 0.0
+  @rad_points = 90
   
 end
 
-Sine.new :title => "Sine"
+def draw  
+  background 153  	
+  translate width / 2, height / 2  	
+  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
+