ruby-processing 2.6.3 → 2.6.4

data/samples/processing_app/basics/data/characters_strings.rb

@@ -1,50 +0,0 @@
-#
-# Characters Strings. 
-#  
-# The character datatype, abbreviated as char, stores letters and 
-# symbols in the Unicode format, a coding system developed to support 
-# a variety of world languages. Characters are distinguished from other
-# symbols by putting them between single quotes ('P').<br />
-# <br />
-# A string is a sequence of characters. A string is noted by surrounding 
-# a group of letters with double quotes ("Processing"). 
-# Chars and strings are most often used with the keyboard methods, 
-# to display text to the screen, and to load images or files.<br />
-# <br />
-# The String datatype must be capitalized because it is a complex datatype.
-# A String is actually a class with its own methods, some of which are
-# featured below. 
-#
-
-attr_reader :letter, :words
-
-def setup
-  size 640, 360
-  @words = "Begin..."
-  # Create the font
-  text_font create_font("Georgia", 36)
-end
-
-def draw
-  background(0) # Set background to black
-
-  # Draw the letter to the center of the screen
-  text_size(14)
-  text("Click on the program, then type to add to the String", 50, 50)
-  text("Current key: #{letter}", 50, 70)
-  text("The String is #{words.length()} characters long", 50, 90)
-  
-  text_size(36)
-  text(words, 50, 120, 540, 300)
-end
-
-def key_pressed
-  # The variable "key" always contains the value 
-  # of the most recent key pressed.
-  if (('A'..'z').include?(key) || key == ' ')
-    @letter = key
-    @words = words + key
-    puts(key)
-  end
-end
-

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

@@ -1,41 +0,0 @@
-
-# Processings datatype conversion functions make no sense for Ruby as it does
-# not have primitive datatypes. Try these instead:
-# "to_s" (to String)
-# "to_i" (to Integer, thats a Fixnum or Bignum)
-# "to_f" (to Float, which would be "double" in Processing, not "float")
-# "to_a" (to Array, i.e. from a Range or Hash)
-
-
-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
-
-

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

@@ -1,28 +0,0 @@
-# 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. 
-
-
-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
-
-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,31 +0,0 @@
-# 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
-# boolean value "x" is true, vertical black lines are drawn and when
-# the boolean value "x" is false, horizontal gray lines are drawn.
-
-# In Ruby, false and nil are "falsy" ... they are the only things
-# that will fail an "if" test. Absolutely everything else passes "if".
-
-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
-

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

@@ -1,74 +0,0 @@
-# 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
-# functions. Global variables, variables declared outside
-# of setup and draw, may be used anywhere within the program.
-# If a local variable is declared with the same name as a
-# global variable, the program will use the local variable to make 
-# its calculations within the current scope. Variables may be localized
-# within classes, functions, and iterative statements.
-
-# Please note that there are some changes on variable scope inside blocks
-# between Ruby versions 1.8 and 1.9.
-
-
-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 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
-
-# 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,35 +0,0 @@
-# Variables are used for storing values. In this example, changing 
-# the values of variables @one and @two significantly changes the composition. 
-
-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
-  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
-
-
-

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

@@ -1,20 +0,0 @@
-# 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. 
-
-
-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
-

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

@@ -1,99 +0,0 @@
-# Bezier Ellipse  
-# By Ira Greenberg 
-# 
-# Generates an ellipse using bezier and
-# trig functions. Approximately every 1/2 
-# second a new ellipse is plotted using 
-# random values for control/anchor points.
-
-
-# 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
-  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
-  
-  # 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
-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 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

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

@@ -1,89 +0,0 @@
-# Original by Ira Greenberg
-
-# 3D castle tower constructed out of individual bricks.
-# Uses the Vect struct and Cube class.
-
-attr_reader :angle, :brick, :bricks_per_layer, :brick_layers
-attr_reader :radius, :layer_num, :temp_y
-
-def setup
-  size 640, 360, P3D
-  @bricks_per_layer = 16
-  @brick_layers = 18
-  @brick_width, @brick_height, @brick_depth = 60, 25, 25
-  @radius = 175.0
-  @angle = 0
-  @brick = Cubeish.new(@brick_width, @brick_height, @brick_depth)
-end
-
-def draw
-  background 0
-  @temp_y = 0
-  fill 182, 62, 29
-  no_stroke
-  lights
-  translate(width / 2.0, height * 1.2, -380)             # move viewpoint into position
-  rotate_x(-45.radians)                                  # tip tower to see inside
-  rotate_y(frame_count * PI / 600)                         # slowly rotate tower
-  brick_layers.times { |i| draw_layer(i) }
-end
-
-def draw_layer(layer_num)
-  @layer_num = layer_num
-  @temp_y -= @brick_height                               # increment rows
-  @angle = 360.0 / bricks_per_layer * layer_num / 2.0    # alternate brick seams
-  bricks_per_layer.times { |i| draw_bricks(i) }
-end
-
-def draw_bricks(brick_num)
-  temp_z = cos(angle.radians) * radius
-  temp_x = sin(angle.radians) * radius
-  push_matrix
-  translate temp_x, temp_y, temp_z
-  rotate_y(angle.radians)
-  top_layer = layer_num == brick_layers - 1
-  brick.create unless top_layer                          # main tower
-  brick.create if top_layer && brick_num.even?           # add crenelation
-  pop_matrix
-  @angle += 360.0 / bricks_per_layer
-end
-
-
-# The Cubeish class works a little different than the cube in the
-# Processing example. SIDES tells you where the negative numbers go.
-# We dynamically create each of the PVectors by passing in the
-# appropriate signs.
-class Cubeish
-  include Processing::Proxy
-  attr_reader :vertices, :w, :h, :d
-
-  SIDES = {front: ['-- ', ' - ', '   ', '-  '],
-           left: ['-- ', '---', '- -', '-  '],
-           right: [' - ', ' --', '  -', '   '],
-           back: ['---', ' --', '  -', '- -'],
-           top: ['-- ', '---', ' --', ' - '],
-           bottom: ['-  ', '- -', '  -', '   ']}
-
-  SIGNS = {'-' => -1, ' ' =>  1}
-
-  def initialize(width, height, depth)
-    @vertices = {}
-    @w, @h, @d = width, height, depth
-    SIDES.each do |side, signs|
-      vertices[side] = signs.map do |s|
-        s = s.split('').map { |el| SIGNS[el] }
-        Vect.new(s[0] * w / 2, s[1] * h / 2, s[2] * d/2)
-      end
-    end
-  end
-
-  def create
-    vertices.each do |name, vectors|
-      begin_shape QUADS
-      vectors.each { |v| vertex(v.x, v.y, v.z) }
-      end_shape
-    end
-  end
-end
-
-Vect = Struct.new(:x, :y, :z)