ruby-processing 2.4.4 → 2.5.0

data/samples/processing_app/library/vecmath/{library → vec2d/library}/particle/particle_system.rb

@@ -56,17 +56,17 @@ class Particle
     s_shape.no_stroke
     s_shape.texture(sprite)
     s_shape.normal(0, 0, 1)
-    s_shape.vertex(-part_size/2, -part_size/2, 0, 0)
-    s_shape.vertex(+part_size/2, -part_size/2, sprite.width, 0)
-    s_shape.vertex(+part_size/2, +part_size/2, sprite.width, sprite.height)
-    s_shape.vertex(-part_size/2, +part_size/2, 0, sprite.height)
+    s_shape.vertex(-part_size / 2.0, -part_size / 2.0, 0, 0)
+    s_shape.vertex(+part_size / 2.0, -part_size / 2.0, sprite.width, 0)
+    s_shape.vertex(+part_size / 2.0, +part_size / 2.0, sprite.width, sprite.height)
+    s_shape.vertex(-part_size / 2.0, +part_size / 2.0, 0, sprite.height)
     s_shape.end_shape
 
     # Initialize center vector
     @center = Vec2D.new 
     
     # Set the particle starting location
-    rebirth(width/2, height/2)
+    rebirth(width / 2.0, height / 2.0)
   end
 
   def rebirth(x, y)

data/samples/processing_app/library/vecmath/vec2d/library/tile/tile.rb

@@ -0,0 +1,85 @@
+module Tiler
+  @acute = false
+
+  def self.acute(x)
+    @acute = x
+  end
+
+  # setup the initial tiling with all red tiles
+  def self.tile(a, b, c)
+    tile = @acute ? ATile.new(0, a, b, c) : Tile.new(0, a, b, c)
+  end
+end
+
+class Tile
+  include Processing::Proxy
+  PHI = (1.0 + Math.sqrt(5)) / 2.0 # golden ratio
+  RED = [255, 0, 0]
+  BLUE = [0, 0, 255]
+  COLORS = [RED, BLUE]
+  attr_reader :a, :b, :c, :col
+
+  def initialize(col,  a,  b,  c)
+    @col, @a, @b, @c = col, a, b, c
+  end
+
+  def display
+    no_stroke
+    fill(*COLORS[col])
+    triangle(a.x, a.y, b.x, b.y, c.x, c.y)
+    # fill(0, 0, 255)
+    # ellipse(a.x, a.y, 4,4)
+    # ellipse(b.x, b.y, 4,4)
+    # ellipse(c.x, c.y, 4,4)
+  end
+
+  def subdivide
+    result = []
+    if (col == 0)
+      # Subdivide red triangle
+      p = b - a
+      p /= PHI
+      p += a
+      result << Tile.new(0, c, p, b)
+      result << Tile.new(1, p, c, a)
+    else
+      # Subdivide blue triangle
+      q = a - b
+      q /= PHI
+      q += b
+      r = c - b
+      r /= PHI
+      r += b
+      result << Tile.new(1, r, c, a)
+      result << Tile.new(1, q, r, b)
+      result << Tile.new(0, r, q, a)
+    end
+    result
+  end
+end
+
+class ATile < Tile
+  def subdivide
+    result = []
+    if (col == 0)
+      # Subdivide red (half kite) triangle
+      q = b - a
+      q /= PHI
+      q += a
+      r = c - b
+      r /= PHI
+      r += b
+      result << ATile.new(1, r, q, b)
+      result << ATile.new(0, q, a, r)
+      result << ATile.new(0, c, a, r)
+    else
+      # Subdivide blue (half dart) triangle
+      p = a - c
+      p /= PHI
+      p += c
+      result << ATile.new(1, b, p, a)
+      result << ATile.new(0, p, c, b)
+    end
+   result
+  end
+end

data/samples/processing_app/library/vecmath/{morph.rb → vec2d/morph.rb}

@@ -1,12 +1,16 @@
 #
-# Morph. 
+# Morph.
 # 
 # Changing one shape into another by interpolating
 # vertices from one to another
 #
 load_library :vecmath
 
-attr_reader :circle, :square, :morph, :state, :v1, :v2
+attr_reader :circle, :square, :morph, :state, :v1, :v2, :renderer
+
+ALPHA = Math::PI / 4.0
+OMEGA = TAU + ALPHA
+THETA = Math::PI / 20.0
 
 def setup
   size(640, 360)
@@ -14,19 +18,18 @@ def setup
   @square = []
   @morph = []
   @state = false
-  frameRate(15)
+  @renderer = AppRender.new(self)
+  frame_rate(15)
   # Create a circle using vectors pointing from center
-  (0 .. TAU).step(Math::PI / 20.0) do |angle|
+  (ALPHA .. OMEGA).step(THETA) do |angle|
     # Note we are not starting from 0 in order to match the
-    # path of a circle.  
-    v = Vec2D.from_angle(angle + Math::PI / 4.0 )
-    v *= 100
-    circle << v
+    # path of a circle.
+    circle << Vec2D.from_angle(angle) * 100
     # Let's fill out morph Array with blank Vec2Ds while we are at it
     morph << Vec2D.new
   end
 
-  # A square is a bunch of vertices along straight lines
+  # A square is a bunch of vertices along straight line
   # Top of square
   (-50 .. 50).step(10) do |x|
     square << Vec2D.new(x, -50)
@@ -54,30 +57,28 @@ def draw
   # Look at each vertex
   circle.length.times do |i|
     # Are we lerping to the circle or square?
-    v1 = (state)?  circle[i] : square[i]
+    v1 = state ?  circle[i] : square[i]
     # Get the vertex we will draw
     v2 = morph[i]
     
     # Lerp to the target
     v2.lerp!(v1, 0.1)
     # Check how far we are from target
-    @total_distance += Vec2D.dist(v1, v2)
+    @total_distance += v1.dist(v2)
   end
   
   # If all the vertices are close, switch shape
-  if (@total_distance < 0.08)
-    @state = !state
-  end
+  @state = !state if @total_distance < 0.08
   
   # Draw relative to center
-  translate(width/2, height/2)
+  translate(width / 2, height / 2)
   stroke_weight(4)
   # Draw a polygon that makes up all the vertices
   begin_shape
   no_fill
   stroke(255)
   morph.each do |v|
-    vertex(v.x, v.y)
+    v.to_vertex(renderer)
   end
   end_shape(CLOSE)
 end

data/samples/processing_app/library/vecmath/{multiple_particle_systems.rb → vec2d/multiple_particle_systems.rb}

@@ -4,17 +4,21 @@
 
 # Each burst is one instance of a particle system with Particles and
 # CrazyParticles (a subclass of Particle).
+
+require 'forwardable'
 load_library :vecmath
 
 module Runnable
   def run
     self.reject! { |item| item.dead? }
-    self.each    { |item| item.run   }
+    self.each { |item| item.run }
   end
 end
 
 class ParticleSystem 
-  extend Enumerable
+  extend Forwardable
+  def_delegators(:@particle_systems, :each, :<<, :reject!, :empty?)
+  include Enumerable
   include Runnable    
   
   attr_reader :particle_systems 
@@ -26,20 +30,8 @@ class ParticleSystem
     number.times { self << kind.new(origin) }
   end
   
-  def each &block
-    particle_systems.each &block    
-  end
-  
-  def << obj
-    particle_systems << obj
-  end
-  
-  def reject! &block
-    particle_systems.reject! &block
-  end
-  
   def dead?
-    particle_systems.empty?
+    self.empty?
   end  
 end
 
@@ -48,7 +40,9 @@ def setup
   size 640, 580   
   color_mode(RGB, 255, 255, 255, 100)
   ellipse_mode(CENTER)    
-  @particle_systems = ParticleSystem.new(rand(21) + 5, Vec2D.new(width/2, height/2))
+  origin = rand(5 .. 16)
+  start_pos = Vec2D.new(width / start2, height / 2)
+  @particle_systems = ParticleSystem.new(origin, start_pos)
 end
 
 def draw
@@ -57,7 +51,7 @@ def draw
 end
 
 def mouse_pressed
-  origin = rand(21) + 5
+  origin = rand(5 .. 16)
   vector = Vec2D.new(mouse_x, mouse_y)
   @particle_systems << ParticleSystem.new(origin, vector)
 end
@@ -102,18 +96,13 @@ class Particle
   def render_velocity_vector
     scale = 10
     arrow_size = 4
-    
     push_matrix
-    
     translate(origin.x, origin.y)
     rotate(velocity.heading)
-    
     length = velocity.mag * scale
-    
     line 0, 0, length, 0
     line length, 0, length - arrow_size, arrow_size / 2
     line length, 0, length - arrow_size, -arrow_size / 2
-    
     pop_matrix
   end
 end
@@ -143,16 +132,10 @@ class CrazyParticle < Particle
   
   def render_rotation_line
     push_matrix
-    
     translate(origin.x, origin.y)
     rotate(@theta)
-    
     stroke(255, lifespan)
-    
     line(0, 0, 25, 0)
-    
     pop_matrix
   end
 end
-
-

data/samples/processing_app/library/vecmath/{particle_system_pshape.rb → vec2d/particle_system_pshape.rb}

@@ -7,32 +7,30 @@ load_library :vecmath
 load_library :particle
 
 # Particle System object and image
-attr_reader :ps 
+attr_reader :ps
 
 def setup
   size(640, 360, P2D)
   # Load the image
-  sprite = loadImage("sprite.png")
+  sprite = loadImage('sprite.png')
   # A new particle system with 10,000 particles
-  @ps = ParticleSystem.new(width, height, sprite, 10000)
+  @ps = ParticleSystem.new(width, height, sprite, 10_000)
   # Writing to the depth buffer is disabled to avoid rendering
   # artifacts due to the fact that the particles are semi-transparent
   # but not z-sorted.
   hint(DISABLE_DEPTH_MASK)
 end 
 
-def draw 
+def draw
   background(0)
   # Update and display system
   ps.update
   ps.display
   # Set the particle system's emitter location to the mouse
   ps.set_emitter(mouse_x, mouse_y)
-  
   # Display frame rate
   fill(255, 0, 255)
   text_size(16)
   text("Frame rate: #{frame_rate.round(1)}", 10, 20)
-  
 end
 

data/samples/processing_app/library/vecmath/vec2d/penrose.rb

@@ -0,0 +1,71 @@
+# Penrose Tile Generator
+# Using a variant of the "ArrayList" recursion technique: http://natureofcode.com/book/chapter-8-fractals/chapter08_section4
+# Penrose Algorithm from: http://preshing.com/20110831/penrose-tiling-explained
+# Daniel Shiffman May 2013
+# Translated (and refactored) to ruby-processing Jan 2014 by Martin Prout
+
+load_libraries :vecmath, :tile, :control_panel
+attr_reader :tris, :s, :panel, :hide, :acute
+
+def setup
+  size(1024, 576)
+  control_panel do |c|
+    c.title = 'Tiler Control'
+    c.look_feel 'Nimbus'
+    c.checkbox  :seed
+    c.checkbox  :acute
+    c.button    :generate
+    c.button    :reset!
+    @panel = c
+  end
+  @hide = false
+  init false # defaults to regular penrose
+end
+
+def draw
+  # only make control_panel visible once, or again when hide is false
+  unless hide
+    @hide = true
+    panel.set_visible(hide)
+  end
+  background(255)
+  translate(width / 2, height / 2)
+  tris.each do |t|
+    t.display
+  end
+end
+
+def generate
+  next_level = []
+  tris.each do |t|
+    more = t.subdivide
+    more.each do |m|
+      next_level << m
+    end
+  end
+  @tris = next_level
+end
+
+def reset!
+  Tiler.acute(acute)  # set the Tiler first
+  init @seed
+  java.lang.System.gc # but does it do any good?
+end
+
+def init(alt_seed)
+  @tris = []
+  10.times do |i|     # create 36 degree segments
+    a = Vec2D.new
+    b = Vec2D.from_angle((2 * i - 1) * PI / 10)
+    c = Vec2D.from_angle((2 * i + 1) * PI / 10)
+    b *= 370
+    c *= 370
+    if alt_seed
+      tile = i.even? ? Tiler.tile(b, a, c) : Tiler.tile(c, a, b)
+      tris << tile
+    else
+      tile = i.even? ? Tiler.tile(a, b, c) : Tiler.tile(a, c, b)
+      tris << tile
+    end
+  end
+end

data/samples/processing_app/library/vecmath/{reflection1.rb → vec2d/reflection1.rb}

@@ -20,7 +20,7 @@ def setup
   @base2 = Vec2D.new(width, height)
   @coords = create_ground
   # start ellipse at middle top of screen
-  @position = Vec2D.new(width/2, 0)  
+  @position = Vec2D.new(width / 2, 0)  
   # set initial random direction
   @direction = Vec2D.new(rand, rand)
   
@@ -58,7 +58,7 @@ def draw
   # detect and handle collision
   coords.each do |coord|
     # check distance between ellipse and base top coordinates
-    if (Vec2D.dist(position, coord) < radius)
+    if position.dist(coord) < radius
       
       # calculate dot product of incident vector and base top normal 
       dot = incidence.dot(normal)
@@ -73,17 +73,17 @@ def draw
   
   # detect boundary collision
   # right
-  if (position.x > width - radius)
+  if position.x > (width - radius)
     @position.x = width - radius
     @direction.x *= -1
   end
   # left 
-  if (position.x < radius)
+  if position.x < radius
     @position.x = radius
     @direction.x *= -1
   end
   # top
-  if (position.y < radius)
+  if position.y < radius
     @position.y = radius
     @direction.y *= -1
     # randomize base top
@@ -95,7 +95,7 @@ end
 
 def create_ground
   # calculate length of base top
-  @base_length = Vec2D.dist(base1, base2)
+  @base_length = base1.dist(base2)
   # fill base top coordinate array
   coords = []
   (0 ... base_length.ceil).each do |i|

data/samples/processing_app/library/vecmath/{seeking_neural.rb → vec2d/seeking_neural.rb}

@@ -9,23 +9,23 @@ module SeekingNeural
   class Perceptron
     # Perceptron is created with n weights and learning constant
     def initialize(n, c)
-      @weights = Array.new(n){ rand(0 .. 1.0) }
+      @weights = Array.new(n) { rand(0 .. 1.0) }
       @c = c
     end
     
     # Function to train the Perceptron
     # Weights are adjusted based on vehicle's error
     def train(forces, error)
-      trained = @weights.zip(forces.map{|f| f.to_a}
-        .map{|a, b| (a * error.x + b * error.y) * @c})
-      .map {|w, c| constrain(w + c, 0.0, 1.0)}
-      @weights = trained    
+      trained = @weights.zip(forces.map { |f| f.to_a }
+        .map { |a, b| (a * error.x + b * error.y) * @c })
+      .map { |w, c| constrain(w + c, 0.0, 1.0) }
+      @weights = trained
     end
     
     # Give me a steering result
     def feedforward(forces)
       # Sum all values
-      forces.zip(@weights).map{|a, b| a * b}.inject(Vec2D.new, :+)
+      forces.zip(@weights).map { |a, b| a * b }.inject(Vec2D.new, :+)
     end
   end
   
@@ -33,11 +33,10 @@ module SeekingNeural
   # Daniel Shiffman <http://www.shiffman.net>
   
   class Vehicle
-    
     MAX_SPEED = 4
     MAX_FORCE = 0.1
-    attr_reader :brain, :sz, :location, :targets, :desired  
-    attr_reader :maxforce_squared, :maxspeed_squared
+
+    attr_reader :brain, :sz, :location, :targets, :desired
     
     def initialize(n, x, y)
       @brain = Perceptron.new(n, 0.001)
@@ -45,8 +44,6 @@ module SeekingNeural
       @velocity = Vec2D.new
       @location = Vec2D.new(x, y)
       @sz = 6.0
-      @maxspeed_squared = MAX_SPEED * MAX_SPEED
-      @maxforce_squared = MAX_FORCE * MAX_FORCE
     end
     
     # Method to update location
@@ -54,11 +51,10 @@ module SeekingNeural
       # Update velocity
       @velocity += @acceleration
       # Limit speed
-      @velocity.set_mag(MAX_SPEED) {@velocity.mag_squared > maxspeed_squared}
+      @velocity.set_mag(MAX_SPEED) { @velocity.mag > MAX_SPEED }
       @location += @velocity
       # Reset acceleration to 0 each cycle
       @acceleration *= 0
-      
       @location.x = constrain(location.x, 0, width)
       @location.y = constrain(location.y, 0, height)
     end
@@ -71,7 +67,7 @@ module SeekingNeural
     # Here is where the brain processes everything
     def steer(targets, desired)
       # Steer towards all targets
-      forces = targets.map{|target| seek(target) }
+      forces = targets.map { |target| seek(target) }
       
       # That array of forces is the input to the brain
       result = brain.feedforward(forces)
@@ -94,7 +90,7 @@ module SeekingNeural
       desired *= MAX_SPEED
       # Steering = Desired minus velocity
       steer = desired - @velocity
-      steer.set_mag(MAX_FORCE) {steer.mag_squared > maxforce_squared} # Limit to a maximum steering force
+      steer.set_mag(MAX_FORCE) { steer.mag > MAX_FORCE } # Limit to a maximum steering force
       steer
     end
     
@@ -127,7 +123,7 @@ attr_reader :targets, :desired, :v
 def setup
   size(640, 360)
   # The Vehicle's desired location
-  @desired = Vec2D.new(width/2, height/2)
+  @desired = Vec2D.new(width / 2, height / 2)
   
   # Create a list of targets
   make_targets