ruby-processing 2.6.3 → 2.6.4

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

@@ -1,36 +0,0 @@
-#
-# ParticleSystemPShape
-# A particle system optimized for drawing using PShape
-# For guts of implementation see 'particle' library
-#
-load_library :vecmath
-load_library :particle
-
-# Particle System object and image
-attr_reader :ps
-
-def setup
-  size(640, 360, P2D)
-  # Load the image
-  sprite = load_image('sprite.png')
-  # A new particle system with 10,000 particles
-  @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
-  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: #{format('%0.1f', frame_rate)}", 10, 20)
-end
-

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

@@ -1,71 +0,0 @@
-# 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/vec2d/reflection1.rb

@@ -1,108 +0,0 @@
-#
-# Non-orthogonal Reflection 
-# by Ira Greenberg. 
-# 
-# Based on the equation (R = 2N(N*L)-L) where R is the 
-# reflection vector, N is the normal, and L is the incident
-# vector. NB: variant uses Vec2D in place of PVector
-#
-load_library :vecmath
-
-attr_reader :base1, :base2, :base_length, :coords, :position, :radius
-attr_reader :direction, :speed, :velocity, :incidence 
-
-def setup
-  size(640, 360)
-  @radius = 6
-  @speed = 3.5
-  fill(128)
-  @base1 = Vec2D.new(0, height - 150)
-  @base2 = Vec2D.new(width, height)
-  @coords = create_ground
-  # start ellipse at middle top of screen
-  @position = Vec2D.new(width / 2, 0)  
-  # set initial random direction
-  @direction = Vec2D.new(rand, rand)
-  
-end
-
-def draw
-  # draw background
-  fill(0, 12)
-  no_stroke
-  rect(0, 0, width, height)
-  
-  # draw base
-  fill(200)
-  quad(base1.x, base1.y, base2.x, base2.y, base2.x, height, 0, height)
-  
-  # calculate base top normal
-  base_delta = base2 - base1
-  base_delta.normalize!
-  normal = Vec2D.new(-base_delta.y, base_delta.x)  
-  # draw ellipse
-  no_stroke
-  fill(255)
-  ellipse(position.x, position.y, radius * 2, radius * 2)
-  
-  # set ellipse velocity vector
-  @velocity = Vec2D.new(direction.x, direction.y) 
-  @velocity *= speed
-  
-  # move ellipse according to velocity vector
-  @position += velocity
-  
-  # normalized incidence vector
-  @incidence = direction * -1
-  
-  # detect and handle collision
-  coords.each do |coord|
-    # check distance between ellipse and base top coordinates
-    if position.dist(coord) < radius
-      
-      # calculate dot product of incident vector and base top normal 
-      dot = incidence.dot(normal)
-      
-      # assign reflection vector to direction vector
-      direction.x, direction.y = 2 * normal.x * dot - incidence.x, 2 * normal.y * dot - incidence.y, 0      
-      # draw base top normal at collision point
-      stroke(255, 128, 0)
-      line(position.x, position.y, position.x - normal.x * 100, position.y - normal.y * 100)
-     end 
-  end
-  
-  # detect boundary collision
-  # right
-  if position.x > (width - radius)
-    @position.x = width - radius
-    @direction.x *= -1
-  end
-  # left 
-  if position.x < radius
-    @position.x = radius
-    @direction.x *= -1
-  end
-  # top
-  if position.y < radius
-    @position.y = radius
-    @direction.y *= -1
-    # randomize base top
-    @base1.y = rand(height - 100..height)
-    @base2.y = rand(height - 100..height)
-    @coords = create_ground
-  end
-end
-
-def create_ground
-  # calculate length of base top
-  @base_length = base1.dist(base2)
-  # fill base top coordinate array
-  coords = []
-  (0 ... base_length.ceil).each do |i|
-     coords << Vec2D.new(
-     base1.x + ((base2.x - base1.x) / base_length) * i,
-     base1.y + ((base2.y - base1.y) / base_length) * i)
-  end
-  return coords
-end
-

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

@@ -1,169 +0,0 @@
-# Based on SeekingNeural example by Daniel Shiffman
-# The Nature of Code
-# http://natureofcode.com
-
-load_library :vecmath
-
-
-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) }
-      @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
-    end
-    
-    # Give me a steering result
-    def feedforward(forces)
-      # Sum all values
-      forces.zip(@weights).map { |a, b| a * b }.reduce(Vec2D.new, :+)
-      # forces.zip(@weights).map { |a, b| a * b }.reduce(:+)
-    end
-  end
-  
-  # Seek
-  # Daniel Shiffman <http://www.shiffman.net>
-  
-  class Vehicle
-    MAX_SPEED = 4
-    MAX_FORCE = 0.1
-
-    attr_reader :brain, :sz, :location, :targets, :desired
-    
-    def initialize(n, x, y)
-      @brain = Perceptron.new(n, 0.001)
-      @acceleration = Vec2D.new
-      @velocity = Vec2D.new
-      @location = Vec2D.new(x, y)
-      @sz = 6.0
-    end
-    
-    # Method to update location
-    def update(width, height)
-      # Update velocity
-      @velocity += @acceleration
-      # Limit speed
-      @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
-    
-    def apply_force(force)
-      # We could add mass here if we want A = F / M
-      @acceleration += force
-    end
-    
-    # Here is where the brain processes everything
-    def steer(targets, desired)
-      # Steer towards all targets
-      forces = targets.map { |target| seek(target) }
-      
-      # That array of forces is the input to the brain
-      result = brain.feedforward(forces)
-      
-      # Use the result to steer the vehicle
-      apply_force(result)
-      
-      # Train the brain according to the error
-      error = desired - location
-      brain.train(forces, error)
-    end
-    
-    # A method that calculates a steering force towards a target
-    # STEER = DESIRED MINUS VELOCITY
-    def seek(target)
-      desired = target - location  # A vector pointing from the location to the target
-      
-      # Normalize desired and scale to the maximum speed
-      desired.normalize!
-      desired *= MAX_SPEED
-      # Steering = Desired minus velocity
-      steer = desired - @velocity
-      steer.set_mag(MAX_FORCE) { steer.mag > MAX_FORCE } # Limit to a maximum steering force
-      steer
-    end
-    
-    def display
-      
-      # Draw a triangle rotated in the direction of velocity
-      theta = @velocity.heading + Math::PI / 2
-      fill(175)
-      stroke(0)
-      stroke_weight(1)
-      push_matrix
-      translate(location.x, location.y)
-      rotate(theta)
-      begin_shape
-        vertex(0, -sz)
-        vertex(-sz * 0.5, sz)
-        vertex(sz * 0.5, sz)
-      end_shape(CLOSE)
-      pop_matrix
-    end
-  end    
-end
-
-include SeekingNeural
-
-# A Vehicle controlled by a Perceptron
-attr_reader :targets, :desired, :v
-
-
-def setup
-  size(640, 360)
-  # The Vehicle's desired location
-  @desired = Vec2D.new(width / 2, height / 2)
-  
-  # Create a list of targets
-  make_targets
-  
-  # Create the Vehicle (it has to know about the number of targets
-  # in order to configure its brain)
-  @v = Vehicle.new(targets.size, rand(width), rand(height))
-end
-
-# Make a random ArrayList of targets to steer towards
-def make_targets
-  @targets = Array.new(8) { Vec2D.new(rand(width), rand(height)) }
-end
-
-def draw
-  background(255)
-  
-  # Draw a circle to show the Vehicle's goal
-  stroke(0)
-  stroke_weight(2)
-  fill(0, 100)
-  ellipse(desired.x, desired.y, 36, 36)
-  
-  # Draw the targets
-  targets.each do |target|
-    no_fill
-    stroke(0)
-    stroke_weight(2)
-    ellipse(target.x, target.y, 16, 16)
-    line(target.x, target.y - 16, target.x, target.y + 16)
-    line(target.x - 16, target.y, target.x + 16, target.y)
-  end
-  
-  # Update the Vehicle
-  v.steer(targets, desired)
-  v.update(width, height)
-  v.display
-end
-
-def mouse_pressed
-  make_targets
-end

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

@@ -1,85 +0,0 @@
-# Ported from http://processing.org/learning/topics/simpleparticlesystem.html
-
-# Particles are generated each cycle, fall with gravity and fade out over
-# time. A ParticleSystem (Array) object manages a variable size list of
-# particles.
-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!, :empty?)
-  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
-  
-  def dead?
-    self.empty?
-  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