ruby-processing 2.6.3 → 2.6.4

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

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

@@ -1,35 +0,0 @@
-# Sine. 
-# 
-# Smoothly scaling size with the sin() function.
-
-
-def setup    
-  size 640, 360
-  no_stroke
-  @diameter = 84.0
-  @sin = 0.0
-  @angle = 0.0
-  @rad_points = 90
-  
-end
-
-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 += TAU/5
-  }  	
-  @diameter = 34 * sin( @angle ) + 168
-  @angle += 0.02
-  #@angle = 0.0 if @angle > TAU  
-end
-

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

@@ -1,48 +0,0 @@
-#
-# Sine Cosine. 
-# 
-# Linear movement with sin() and cos(). 
-# Numbers between 0 and PI*2 (TAU which angles roughly 6.28) 
-# are put into these functions and numbers between -1 and 1 are 
-# returned. These values are then scaled to produce larger movements.
-# note only angle1 angle2 need scope outside draw loop
-#
- 
-attr_reader :angle1, :angle2
-SCALAR = 70
-
-def setup
-  size(640, 360)
-  noStroke()
-  rectMode(CENTER)
-  @angle1 = 0
-  @angle2 = 0
-end
-
-def draw
-  background(0)
-
-  ang1 = angle1.radians
-  ang2 = angle2.radians
-
-  x1 = width / 2 + (SCALAR * cos(ang1))
-  x2 = width / 2 + (SCALAR * cos(ang2))
-  
-  y1 = height / 2 + (SCALAR * sin(ang1))
-  y2 = height / 2 + (SCALAR * sin(ang2))
-  
-  fill(255)
-  rect(width * 0.5, height * 0.5, 140, 140)
-
-  fill(0, 102, 153)
-  ellipse(x1, height * 0.5 - 120, SCALAR, SCALAR)
-  ellipse(x2, height * 0.5 + 120, SCALAR, SCALAR)
-  
-  fill(255, 204, 0)
-  ellipse(width * 0.5 - 120, y1, SCALAR, SCALAR)
-  ellipse(width * 0.5 + 120, y2, SCALAR, SCALAR)
-
-  @angle1 += 2
-  @angle2 += 3  
-end
-

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

@@ -1,43 +0,0 @@
-# Sine Wave
-# by Daniel Shiffman.  
-# 
-# Render a simple sine wave. 
-
-
-def setup    
-  size 640, 360    
-  frame_rate 30
-  color_mode RGB, 255, 255, 255, 100   
-  @w = width + 16
-  @period = 500.0
-  @x_spacing = 8
-  @dx = (TAU / @period) * @x_spacing
-  @y_values = []
-  @theta = 0.0
-  @amplitude = 75.0
-  
-end
-
-def draw    
-  background 0
-  calc_wave
-  draw_wave  	
-end
-
-def calc_wave    
-  @theta += 0.02  	
-  x = @theta
-  (0...(@w/@x_spacing)).each do |i|    
-    @y_values[i] = sin(x) * @amplitude
-    x += @dx
-  end  	
-end
-
-def draw_wave    
-	no_stroke
-	fill 255, 50
-	ellipse_mode CENTER	
-	@y_values.each_with_index do |v, x|  	    
-	  ellipse x*@x_spacing, height/2+v, 16, 16
-	end  	
-end

data/samples/processing_app/basics/objects/composite_objects.rb

@@ -1,113 +0,0 @@
-# Composite Objects
-# 
-# An object can include several other objects. Creating such composite objects 
-# is a good way to use the principles of modularity and build higher levels of 
-# abstraction within a program.
-attr_reader :rings
-
-def setup    
-  size 640, 360
-  @rings = []
-  rings << EggRing.new(width*0.45, height*0.5, 0.1, 120) 
-  rings << EggRing.new(width*0.65, height*0.8, 0.05, 180) 
-end
-
-def draw    
-  background 0  	
-  rings.each {|er| er.transmit} 
-end
-
-# vvv CLASS EGG RING
-
-class EggRing    
-  def initialize(x, y, t, sp)  		
-    @ovoid = Egg.new(x, y, t, sp) 
-    @circle = Ring.new
-    @circle.start x, y - sp/2
-  end
-  
-  def transmit  	    
-    @ovoid.wobble
-    @ovoid.display
-    @circle.grow
-    @circle.display
-    @circle.on = true unless @circle.on
-  end  	
-end 
-
-# ^^^ CLASS EGG RING
-
-# vvv CLASS EGG
-
-class Egg    
-  attr_accessor :x, :y  # these are (or better generate) getters/setters
-  # for these instance variables
-  attr_accessor :tilt
-  attr_accessor :angle
-  attr_accessor :scalar
-  
-  def initialize ( x, y, t, s )  	    
-    @x, @y = x, y # the @-sign means that these are instance variables
-    @tilt = t
-    @scalar = s / 100.0
-    @angle = 0.0
-  end
-  
-  def wobble  		
-    @tilt = Math.cos( angle ) / 8
-    @angle += 0.1
-  end
-  
-  def display  	    
-    no_stroke	# in Ruby-Processing classes defined inside the main sketch
-    # class automatically inherit the Processing commands, just
-    # like "inner classes" in Java
-    fill 255  		
-    push_matrix  		
-    translate x, y
-    rotate tilt
-    scale scalar  		
-    begin_shape  		    
-    vertex 0, -100
-    bezier_vertex 25, -100, 40, -65, 40, -40
-    bezier_vertex 40, -15, 25, 0, 0, 0
-    bezier_vertex -25, 0, -40, -15, -40, -40
-    bezier_vertex -40, -65, -25, -100, 0, -100  		    
-    end_shape        
-    pop_matrix
-  end    
-end
-  
-# ^^^ CLASS EGG
-
-# vvv CLASS RING # note width not directly available in Ring class
-
-class Ring    
-  attr_accessor :x, :y
-  attr_accessor :diameter
-  attr_accessor :on
-  attr_accessor :max_diameter
-  def start (xpos, ypos)        
-    @x, @y = xpos, ypos
-    @on = true
-    @diameter = 1.0
-    @max_diameter = $app.width * 2
-  end
-  
-  def grow        
-    @diameter += 0.5 if on
-    @diameter = 0.0 if diameter > max_diameter
-  end
-  
-  def display        
-    if on
-      no_fill
-      stroke_weight 4
-      stroke 155, 153
-      ellipse x, y, diameter, diameter
-    end
-  end    
-end
-
-# ^^^ CLASS RING
-

data/samples/processing_app/basics/objects/inheritance.rb

@@ -1,84 +0,0 @@
-# Inheritance
-# 
-# A class can be defined using another class as a foundation. In object-oriented
-# programming terminology, one class can inherit fields and methods from another. 
-# An object that inherits from another is called a subclass, and the object it 
-# inherits from is called a superclass. A subclass extends the superclass.
-# see also inheritance_two for the use of hash args and inheritance that 
-# avoids the inherited class call to super 
-
-
-def setup    
-  size 640, 360
-  @arm = SpinArm.new width/2, height/2, 0.01
-  @spots = SpinSpots.new width/2, height/2, -0.02, 90.0
-end
-
-def draw
-  background 204  	
-  @arm.display
-  @spots.display
-end
-
-# vvv CLASS SPIN
-
-class Spin
-  
-  attr_accessor :x, :y, :speed
-  attr_accessor :angle
-  
-  def initialize(x, y, s)  	    
-    @x, @y = x, y
-    @speed = s
-    @angle = 0.0
-  end
-  
-  def update  	    
-    @angle += speed
-  end
-  
-end
-
-# ^^^ CLASS SPIN
-
-# vvv CLASS SPINARM
-
-class SpinArm < Spin # inherit from (or "extend") class Spin
-  # NB: initialize inherited from Spin class
-  
-  def display  		
-    stroke_weight 1
-    stroke 0  		
-    push_matrix  		
-    translate x, y
-    update
-    rotate angle
-    line 0, 0, 165, 0
-    pop_matrix
-  end  	
-end
-
-# ^^^ CLASS SPINARM
-
-# vvv CLASS SPINSPOTS
-
-class SpinSpots < Spin    
-  attr_accessor :dim  	
-  def initialize (x, y, s, d)  	    
-    super(x, y, s)
-    @dim = d
-  end
-  
-  def display  	    
-    no_stroke  		
-    push_matrix  		
-    translate x, y
-    update
-    rotate angle
-    ellipse(-dim/2, 0, dim, dim) 
-    ellipse(dim/2, 0, dim, dim)  
-    pop_matrix
-  end  	
-end
-
-# ^^^ CLASS SPINSPOTS

data/samples/processing_app/basics/objects/inheritance_two.rb

@@ -1,88 +0,0 @@
-# Inheritance
-# 
-# A class can be defined using another class as a foundation. In object-oriented
-# programming terminology, one class can inherit fields and methods from another. 
-# An object that inherits from another is called a subclass, and the object it 
-# inherits from is called a superclass. A subclass extends the superclass.
-# NB: note the use of hook means inheriting class does not need to call super
-
-
-def setup    
-  size 640, 360
-  @arm = SpinArm.new({ x: width/2, y: height/2, s: 0.01 })
-  @spots = SpinSpots.new({ x: width/2, y: height/2, s: -0.02, d: 90.0 })
-end
-
-def draw
-  background 204  	
-  @arm.display
-  @spots.display
-end
-
-# vvv CLASS SPIN
-
-class Spin
-  
-  attr_accessor :x, :y, :speed
-  attr_accessor :angle
-  
-  def initialize(args = {})  	    
-    @x, @y = args[:x], args[:y]
-    @speed = args[:s]
-    @angle = args[:angle] || 0.0
-    post_initialize(args)  # this is the hook
-  end
-  
-  def update  	    
-    @angle += speed
-  end
-  
-  def post_initialize args
-    nil
-  end
-  
-end
-
-# ^^^ CLASS SPIN
-
-# vvv CLASS SPINARM
-
-class SpinArm < Spin # inherit from (or "extend") class Spin
-  # NB: initialize inherited from Spin class
-  
-  def display  		
-    stroke_weight 1
-    stroke 0  		
-    push_matrix  		
-    translate x, y
-    update
-    rotate angle
-    line 0, 0, 165, 0
-    pop_matrix
-  end  	
-end
-
-# ^^^ CLASS SPINARM
-
-# vvv CLASS SPINSPOTS
-
-class SpinSpots < Spin    
-  attr_accessor :dim
-  
-  def post_initialize args
-    @dim = args[:d]
-  end
-  
-  def display  	    
-    no_stroke  		
-    push_matrix  		
-    translate x, y
-    update
-    rotate angle
-    ellipse(-dim/2, 0, dim, dim) 
-    ellipse(dim/2, 0, dim, dim)  
-    pop_matrix
-  end  	
-end
-
-# ^^^ CLASS SPINSPOTS

data/samples/processing_app/basics/objects/module.rb

@@ -1,89 +0,0 @@
-# Ruby modules, are another way of extending a classes behaviour, the class 
-# ParticleSystem includes Enumerable (from ruby core) and our custom Runnable 
-# module. Here we use the module Runnable to capture behaviour that can be 
-# shared between different classes. Modules are also very useful for wrapping 
-# imported classes (wrapped packages can then be called using convenient names).
-
-# This example is bit complicated, because Enumerable and Forwardable are used
-# to make the ParticleSystem behave as though it were an Array. This is very
-# convenient and is preferred to ParticleSystem subclassing Array.
-
-# Ported from http://processing.org/learning/topics/simpleparticlesystem.html
-
-
-require 'forwardable'
-
-load_library :vecmath
-
-attr_reader :ps
-
-def setup
-  size(640,360)
-  @ps = ParticleSystem.new(Vec2D.new(width/2, 50))
-end
-
-def draw
-  background(0)
-  ps.add_particle
-  ps.run
-end
-
-module Runnable
-  def run
-    self.reject! { |item| item.lifespan <= 0 }
-    self.each    { |item| item.run   }
-  end
-end
-
-class ParticleSystem 
-  extend Forwardable
-  def_delegators(:@particle_system, :each, :<<, :reject!)  
-  include Enumerable 
-  include Runnable
-  
-  attr_reader :origin
- 
-  def initialize(loc)
-    @particle_system = []
-    @origin = Vec2D.new(loc.x, loc.y)
-  end
-  
-  def add_particle
-    self << Particle.new(origin) 
-  end
-  
-end
-
-# A simple Particle class
-
-class Particle 
-  include Processing::Proxy 
-  
-  attr_reader :loc, :vel, :acc, :lifespan
-  def initialize(loc) 
-    @acc = Vec2D.new(0, 0.05)
-    @vel = Vec2D.new(rand(-1.0..1), rand(-2.0..0))
-    @loc = loc    # loc.clone is unecessary in ruby
-    @lifespan = 255.0
-  end
-
-  def run
-    update
-    display
-  end
-
-  # Method to update loc
-  def update
-    @vel += acc
-    @loc += vel
-    @lifespan -= 1.0
-  end
-
-  # Method to display
-  def display
-    stroke(255,lifespan)
-    fill(255,lifespan)
-    ellipse(loc.x, loc.y, 8, 8)
-  end
-  
-end