ruby-processing 2.6.3 → 2.6.4

data/samples/external_library/ruby_gem/game_of_life.rb

@@ -1,127 +0,0 @@
-# game_of_life.rb featuring MDArray in ruby-processing
-# A Processing implementation of Game of Life
-# By Joan Soler-Adillon
-#
-# Press SPACE BAR to pause and change the cell's values with the mouse
-# On pause, click to activate/deactivate cells
-# Press R to randomly reset the cells' grid
-# Press C to clear the cells' grid
-#
-# The original Game of Life was created by John Conway in 1970.
-#
-
-require 'mdarray'
-
-CELL_SIZE = 5
-ALIVE = true
-DEAD = false
-ALIVE_START = 150
-WIDTH = 960
-HEIGHT = 640
-SKIP = 10
-INTERVAL = 100
-
-attr_reader :pause, :cells, :row, :column, :last_time, :alive, :cells_buffer
-
-def setup
-  size WIDTH, HEIGHT
-  @row = WIDTH / CELL_SIZE
-  @column = HEIGHT / CELL_SIZE
-  background 0
-  stroke_weight 2
-  @last_time = 0
-  @pause = false
-  @cells = MDArray.boolean([row, column], random_data)
-  @alive = color(100, 255, 100)
-  stroke(48, 100)
-  no_smooth
-end
-
-def draw
-  background(0)
-  #Draw live cells
-  (0 ... row).each do |x|
-    (0 ... column).each do |y|
-      if (cells.get([x, y]))
-        fill(alive)
-        rect(x * CELL_SIZE, y * CELL_SIZE, CELL_SIZE, CELL_SIZE)
-      end
-    end
-  end
-  # Iterate if timer ticks
-  if (millis - last_time > INTERVAL)
-    if (!pause)
-      tick!
-      @last_time = millis
-    end
-  end
-  
-  # Create  new cells manually on pause
-  if (pause && mouse_pressed?)
-    # # Map and avoid out of bound errors
-    x_cell_over = (map(mouse_x, 0, width, 0, row)).to_i
-    x_cell_over = constrain(x_cell_over, 0, row - 1)
-    y_cell_over = (map(mouse_y, 0, height, 0, column)).to_i
-    y_cell_over = constrain(y_cell_over, 0, column - 1)
-    
-    # Check against cells in buffer
-    if (cells_buffer.get([x_cell_over, y_cell_over]))  # Cell is alive
-      cells.set([x_cell_over, y_cell_over], DEAD) # Kill
-      fill(0) #reflect changed status
-    else  # Cell is dead
-      cells.set([x_cell_over, y_cell_over], ALIVE) # Make alive
-      fill(alive) # Fill alive color
-    end
-    
-  elsif (pause && !mouse_pressed?)  # And then save to buffer once mouse goes up
-    # Save cells to buffer (so we operate with one array keeping the other intact)
-    @cells_buffer = cells.copy
-  end
-end
-
-def tick!  # When the clock ticks
-  # Save cells to buffer (so we operate with one array keeping the other intact)
-  @cells_buffer = cells.copy
-  # Visit each cell:
-  (0 ... row).each do |x|
-    (0 ... column).each do |y|
-      # And visit all the neighbours of each cell
-      neighbours = 0 # We'll count the neighbours
-      (x - 1..x + 1).each do |xx|
-        (y - 1..y + 1).each do |yy|
-          # Make sure you are not out of bounds
-          if [(xx>=0), (xx<row), (yy>=0), (yy<column)].all? {|in_bounds| in_bounds == true}
-            # Make sure to check against self
-            if ![(xx == x), (yy == y)].all? {|is_self| is_self == true}
-              if (cells_buffer.get([xx, yy])) # true == ALIVE
-                neighbours += 1 # Check alive neighbours and count them
-              end # alive
-            end # End of if self
-          end # End of if grid bounds
-        end # End of yy loop
-      end #End of xx loop
-      # We've checked the neighbours: apply rules in one line (only in ruby)!
-      cells.set([x, y], (cells_buffer.get([x, y]))?  ((2..3) === neighbours) : (neighbours == 3))
-    end # End of y loop
-  end # End of x loop
-end # End of function
-
-def key_pressed
-  case key
-  when 'r', 'R'
-    # Restart: reinitialization of cells 
-    @cells = MDArray.boolean([row, column], random_data)
-  when ' ' # On/off of pause
-    @pause = !pause
-  when 'c', 'C' # Clear all
-    @cells = MDArray.boolean([row, column], DEAD)
-  end
-end
-
-def random_data
-  data = []
-  (0 ... row * column).each do
-    data << (rand(1000) < ALIVE_START)
-  end
-  return data
-end

data/samples/external_library/ruby_gem/mdarray_test.rb

@@ -1,28 +0,0 @@
-#  Demonstrates the syntax for creating a two-dimensional (2D) array,
-#  fromfunction (actually a block) using MDArray (for jruby).
-#  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.
-
-require 'mdarray'
-
-WIDTH=640
-HEIGHT=360
-SKIP=10
-
-def setup
-  size WIDTH, HEIGHT
-  background 0
-  stroke_weight 2
-  max_distance = ( (WIDTH / 2 - WIDTH)**2  + (HEIGHT / 2 - HEIGHT)**2 )**0.5
-  distances = MDArray.fromfunction("float", [WIDTH, HEIGHT]) do |x, y|
-    255 * ( (WIDTH / 2 - x)**2  + (HEIGHT / 2 - y)**2 )**0.5 / max_distance
-  end
-  (SKIP ... WIDTH).step(SKIP) do |x|
-      (SKIP ... HEIGHT).step(SKIP) do |y|
-        stroke distances[x, y]
-        point x, y
-      end
-  end
-end
-

data/samples/processing_app/ABOUT

@@ -1,3 +0,0 @@
-Here lie a scattering of examples that come with the Processing download.
-They are categorized by kind, and some of the code has been converted 
-into more idiomatic Ruby.

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

@@ -1,35 +0,0 @@
-#  * 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.  
-
-
-
-def setup
-  size 640, 360
-  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

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

@@ -1,32 +0,0 @@
-#  * 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.
-
-def setup
-  size 640, 360
-  distances = Array.new( width ) { Array.new( height ) } # [width][height]
-	stroke_weight 2
-  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
-
-

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

@@ -1,62 +0,0 @@
-# * Demonstrates the syntax for creating an array of custom objects. 
-
-
-
-UNIT = 40
-attr_reader :mods
-
-def setup
-  size 640, 360
-  wide_count = width / UNIT
-  height_count = height / UNIT
-  @mods = []  
-  wide_count.times do |i|
-    height_count.times do |j|
-      mods << CustomObject.new(j * UNIT, i * UNIT, UNIT/2, UNIT/2, rand(0.05..0.8))
-    end
-  end    
-  no_stroke
-end
-
-def draw
-  background 0   
-  mods.each do |mod|
-    mod.update
-    mod.draw
-  end
-end
-
-# the custom object
-
-class CustomObject
-  include Processing::Proxy
-  attr_reader :x, :y, :mx, :my, :size
-  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
-    unless (0..size).cover? x 
-      @xdir *= -1
-      @x += @xdir
-      @y += @ydir
-    end
-    if @y >= @size || x <= 0
-      @ydir *= -1
-      @y += @ydir
-    end
-  end
-  
-  def draw
-    fill(255)
-    ellipse(mx + x, my + y, 6, 6)
-  end
-  
-end
-
-

data/samples/processing_app/basics/camera/move_eye.rb

@@ -1,24 +0,0 @@
-# Move Eye. 
-# by Simon Greenwold.
-# 
-# The camera lifts up (controlled by mouseY) while looking at the same point.
-
-
-
-def setup
-  size 640, 360, P3D
-  fill 204
-end
-
-def draw
-  lights
-  background 0    
-  camera 30, mouseY, 220, 0, 0, 0, 0, 1, 0    
-  noStroke
-  box 90
-  stroke 255
-  line( -100, 0, 0, 100, 0, 0)
-  line( 0, -100, 0, 0, 100, 0)
-  line( 0, 0, -100, 0, 0, 100)
-end
-

data/samples/processing_app/basics/camera/perspective.rb

@@ -1,36 +0,0 @@
-# Move the mouse left and right to change the field of view (fov).
-# Click to modify the aspect ratio. The perspective method
-# sets a perspective projection applying foreshortening, making 
-# distant objects appear smaller than closer ones. The parameters 
-# define a viewing volume with the shape of truncated pyramid. 
-# Objects near to the front of the volume appear their actual size, 
-# while farther objects appear smaller. This projection simulates 
-# the perspective of the world more accurately than orthographic projection. 
-# The version of perspective without parameters sets the default 
-# perspective and the version with four parameters allows the programmer 
-# to set the area precisely.
-
-def setup
-  size 640, 360, P3D
-  no_stroke
-end
-
-def draw
-  lights
-  background 204
-  camera_y = height/2.0
-  fov = mouse_x/width.to_f * PI/2.0
-  camera_z = camera_y / tan(fov / 2.0)
-  aspect = width.to_f / height.to_f
-  
-  aspect /= 2.0 if mouse_pressed?
-  
-  perspective(fov, aspect, camera_z/10.0, camera_z*10.0)
-  
-  translate width/2.0+30, height/2.0, 0
-  rotate_x -PI/6
-  rotate_y PI/3 + mouse_y/height.to_f * PI
-  box 45
-  translate 0, 0, -50
-  box 30
-end

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

@@ -1,17 +0,0 @@
-# example of processing blend_color (uses PImage blend_color under the hood)
-# blend_color(c1, c2, MODE) returns a color int
-
-def setup
-  size 100, 100
-  orange = color(204, 102, 0)
-  blue = color(0, 102, 153)
-  orangeblueadd = blend_color(orange, blue, ADD)
-  background(51)
-  noStroke()
-  fill(orange)
-  rect(14, 20, 20, 60)
-  fill(orangeblueadd)
-  rect(40, 20, 20, 60)
-  fill(blue)
-  rect(66, 20, 20, 60)
-end

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

@@ -1,24 +0,0 @@
-# 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. 
-
-
-def setup
-  size 640, 480  
-  no_stroke
-  color_mode HSB, 360, height, height
-  @bar_width = 20
-  @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

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

@@ -1,90 +0,0 @@
-# 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.
-
-def setup
-  size 640, 360  
-  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       = 11
-  rot_adjust  = (360.0 / segs / 2.0) * PI / 180
-  radius      = 170.0
-  seg_width   = radius / steps
-  interval    = TAU / 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 mouse click.
-end
-
-def mouse_pressed
-  @style = @style == :tint ? :shade : :tint
-  create_wheel width/2, height/2, @style
-end