ruby-processing 2.6.3 → 2.6.4

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

@@ -1,22 +0,0 @@
-# Distance 2D. 
-# 
-# Move the mouse across the image to obscure and reveal the matrix.  
-# Measures the distance from the mouse to each square and sets the
-# size proportionally. 
-
-def setup    
-  size 640, 360    
-  no_stroke
-  @max_distance = dist(0, 0, width, height)    
-end
-
-def draw  
-  background 51  
-  (0..width).step(20) do |i|  	
-    (0..height).step(20) do |j|  		
-      size = dist(mouse_x, mouse_y, i, j) 
-      size = size / @max_distance * 66      
-      ellipse i, j, size, size
-    end
-  end  
-end

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

@@ -1,31 +0,0 @@
-# Double Random 
-# by Ira Greenberg.  
-# 
-# Using two rand(..) calls and the point() function to 
-# create an irregular sawtooth line. The noise line guards 
-# against an illegal input to rand range when min > max, 
-# and to return min as vanilla processing does 
-# (NB: the sawtooth relies on this)
-
-attr_reader :steps
-
-def setup  
-  size 640, 360  
-  frame_rate(1) 
-  total_pts = 300  
-  @steps = total_pts + 1.0
-  stroke_weight 2
-  stroke 255  
-end
-
-def draw
-  background 0
-  rand_y = 0.0  
-  (1 ... steps).each do |i|
-    noise_y = (rand_y > 0)? rand(-rand_y..rand_y) : rand(rand_y..-rand_y)    
-    point( (width/steps) * i, (height/2) + noise_y )
-    rand_y += rand(-5..5)  
-  end
-end
-
-

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

@@ -1,39 +0,0 @@
-#
-# Graphing 2D Equations
-# by Daniel Shiffman. 
-# 
-# Graphics the following equation: 
-# sin(n*cos(r) + 5*theta) 
-# where n is a function of horizontal mouse location.  
-#
- 
-def setup
-  size(640, 360)
-end
-
-def draw
-  load_pixels
-  n = (mouse_x * 10.0) / width
-  w = 16.0            # 2D space width
-  h = 16.0            # 2D space height
-  dx = w / width      # Increment x this amount per pixel
-  dy = h / height     # Increment y this amount per pixel
-  x = -w / 2          # Start x at -1 * width / 2
-  width.times do |i|
-    y = -h / 2        # Start y at -1 * height / 2
-    height.times do |j|
-      r = sqrt((x * x) + (y * y))    # Convert cartesian to polar
-      theta = atan2(y, x)            # Convert cartesian to polar
-      # Compute 2D polar coordinate function
-      val = sin(n * cos(r) + 5 * theta)        # Results in a value between -1 and 1
-      #val = cos(r)                            # Another simple function
-      #val = sin(theta)                        # Another simple function
-      # Map the resulting value to a grayscale value
-      pixels[i + j * width] = color((val + 1.0) * 255.0/2.0)     # Scale to between 0 and 255
-      y += dy                # Increment y
-    end
-    x += dx                  # Increment x
-  end
-  update_pixels
-end
-

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

@@ -1,54 +0,0 @@
-# Increment Decrement. 
-# 
-# In Java and C ...
-# Writing "a++" is equivalent to "a = a + 1".  
-# Writing "a--" is equivalent to "a = a - 1". 
-
-# In Ruby there is += 1 and -= 1:
-# a += 1 is equal to a = a + 1
-
-
-def setup
-  
-  size 640, 360
-  
-  color_mode RGB, width
-  
-  @a = 0
-  @b = width
-  @direction = false
-  
-  frame_rate 30
-  
-end
-
-def draw
-  
-  @a += 1
-  
-  if @a > width
-    @a = 0
-    @direction = !@direction
-  end
-  
-  if @direction
-    stroke @a
-  else
-    stroke width-@a
-  end
-  
-  line @a, 0, @a, height/2
-  
-  @b -= 1
-  
-  @b = width if @b < 0
-  
-  if @direction
-    stroke width-@b
-  else
-    stroke @b
-  end
-  
-  line @b, height/2+1, @b, height
-  
-end

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

@@ -1,34 +0,0 @@
-#
-# Linear Interpolation. 
-# 
-# Move the mouse across the screen and the symbol will follow.  
-# Between drawing each frame of the animation, the ellipse moves 
-# part of the distance (0.05) from its current position toward 
-# the cursor using the lerp() function
-#
-# This is the same as the Easing under input only with lerp() instead. 
-#
- 
-attr_reader :x, :y
-
-def setup
-  size(640, 360) 
-  no_stroke  
-end
-
-def draw 
-  background(51)
-  
-  # lerp() calculates a number between two numbers at a specific increment. 
-  # The amt parameter is the amount to interpolate between the two values 
-  # where 0.0 equal to the first point, 0.1 is very near the first point, 0.5 
-  # is half-way in between, etc.  
-  
-  # Here we are moving 5% of the way to the mouse location each frame
-  @x = lerp(x, mouse_x, 0.05)
-  @y = lerp(y, mouse_y, 0.05)
-  
-  fill(255)
-  stroke(255)
-  ellipse(x, y, 66, 66)
-end

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

@@ -1,39 +0,0 @@
-# Modulo. 
-# 
-# The modulo operator (%) returns the remainder of a number 
-# divided by another. As in this example, it is often used 
-# to keep numerical values within a set range. 
-
-
-def setup
-  
-  size 200, 200
-  
-  @c = 0.0
-  @num = 20
-  
-  fill 255
-  frame_rate 30
-  
-end
-
-def draw
-  
-  background 0
-  
-  @c += 0.1
-  
-  (1...(height/@num)).each { |i|
-    
-    x = (@c %i ) * i * i
-    stroke 102
-    
-    line 0, i*@num, x, i*@num
-    
-    no_stroke
-    
-    rect x, i*@num-@num/2, 8, @num
-  }
-  
-end
-

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

@@ -1,21 +0,0 @@
-# Noise1D. 
-# 
-# Using 1D Perlin Noise to assign location. 
-
-
-def setup  
-  size 640, 360  
-  @xoff = 0.0
-  @x_increment = 0.01  
-  background 0
-  no_stroke  
-end
-
-def draw  
-  fill 0, 10
-  rect 0, 0, width, height  
-  n = noise(@xoff) * width  
-  @xoff += @x_increment  
-  fill 200
-  ellipse n, height/2, 64, 64  
-end

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

@@ -1,30 +0,0 @@
-# Noise2D 
-# by Daniel Shiffman.  
-# 
-# Using 2D noise to create simple texture. 
-
-
-def setup    
-  size 640, 360   
-  @increment = 0.02   
-end
-
-def draw    
-  background 0  	
-  load_pixels  	
-  xoff = 0.0 
-  detail = map(mouse_x, 0, width, 0.1, 0.6)
-  noise_detail(8, detail)
-  (0...width).each { |x|  	    
-    xoff += @increment
-    yoff = 0.0  		
-    (0...height).each { |y|  		    
-      yoff += @increment  			
-      bright = noise(xoff, yoff) * 255  			
-      pixels[x+y*width] = color bright
-    }
-  }  	
-  update_pixels  	
-end
-
-

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

@@ -1,30 +0,0 @@
-# Noise3D. 
-# 
-# Using 3D noise to create simple animated texture. 
-# Here, the third dimension ('z') is treated as time.
-attr_reader :increment, :z_increment
-
-def setup    
-  size 640, 360
-  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 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,41 +0,0 @@
-#
-# Noise Wave
-# by Daniel Shiffman.  
-# 
-# Using Perlin Noise to generate a wave-like pattern. 
-#
-
-attr_reader :yoff         # 2nd dimension of perlin noise
-
-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
-  # increment y dimension for noise
-  @yoff += 0.01
-  vertex(width, height)
-  vertex(0, height)
-  end_shape(CLOSE)
-end

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

@@ -1,49 +0,0 @@
-# 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: = += -= *= /= %=
-
-
-    
-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
-

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

@@ -1,31 +0,0 @@
-# PolarToCartesian
-# by Daniel Shiffman.  
-# 
-# Convert a polar coordinate (r,theta) to cartesian (x,y):  
-# x = r * cos(theta)
-# y = r * sin(theta)
-attr_reader :r, :theta
-
-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
-

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

@@ -1,21 +0,0 @@
-# Random. 
-# 
-# Random numbers create the basis of this image. 
-# Each time the program is loaded the result is different. 
-
-
-def setup    
-  size 640, 360
-  stroke_weight 10    
-  no_loop    
-end
-
-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