ruby-processing 2.6.3 → 2.6.4

data/samples/processing_app/library/vecmath/vec2d/data/java_args.txt

@@ -1,2 +0,0 @@
--Xmn128m -Xms256m -Xmx256m -Djruby.ji.objectProxyCache=false -XX:CompileCommand=dontinline,org.jruby.runtime.invokedynamic.InvokeDynamicSupport::invocationFallback -XX:+OptimizeStringConcat 
-

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

@@ -1,30 +0,0 @@
-#
-# Flocking 
-# by Daniel Shiffman.  
-# 
-# An implementation of Craig Reynold's Boids program to simulate
-# the flocking behavior of birds. Each boid steers itself based on 
-# rules of avoidance, alignment, and coherence.
-# 
-# Click the mouse to add a new boid.
-#
-load_library :vecmath # load_library required by flock library 
-load_library :flock
-
-attr_reader :flock
-
-def setup
-  size(640, 360)
-  # Add an initial set of boids into the system at the center
-  @flock = Flock.new(150, Vec2D.new(width / 2.0, height / 2.0))
-end
-
-def draw
-  background(50)
-  flock.run
-end
-
-# Add a new boid into the System
-def mouse_pressed
-  flock << Boid.new(Vec2D.new(mouse_x, mouse_y))
-end

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

@@ -1,191 +0,0 @@
-# The Flock (a list of Boid objects)
-require 'forwardable'
-
-class Flock 
-  extend Forwardable
-  def_delegators(:@boids, :each, :<<, :reject)
-  include Enumerable
-  
-  def initialize(size, position)
-    @boids = (0..size).map{ Boid.new(position) }	  
-  end
-
-  def run
-    self.each do |bird|
-      bird.run(self)  # Passing the entire list of boids to each boid individually
-    end
-  end
-  
-end
-
-# The Boid class
-
-class Boid
-  include Processing::Proxy
-  import 'vecmath'
-  attr_reader :location, :velocity, :acceleration, :r, :maxforce, :maxspeed
-  attr_reader :width, :height
-  def initialize(loc)
-    @acceleration = Vec2D.new
-    @velocity = Vec2D.new(rand(-1.0..1), rand(-1.0..1))
-    @location = loc
-    @r = 2.0
-    @maxspeed = 2
-    @maxforce = 0.03
-    @width = $app.width    
-    @height = $app.height
-  end
-  
-  def run(boids)
-    flock(boids)
-    update
-    borders
-    render
-  end
-  
-  def apply_force(force)
-    # We could add mass here if we want A = F / M
-    @acceleration += force
-  end
-  
-  # We accumulate a new acceleration each time based on three rules
-  def flock(boids)
-    sep = separate(boids)   # Separation
-    ali = align(boids)      # Alignment
-    coh = cohesion(boids)   # Cohesion
-    # Arbitrarily weight these forces
-    sep *= 1.5
-    ali *= 1.0
-    coh *= 1.0
-    # Add the force vectors to acceleration
-    apply_force(sep)
-    apply_force(ali)
-    apply_force(coh)
-  end
-  
-  # Method to update location
-  def update
-    # Update velocity
-    @velocity += acceleration
-    # Limit speed
-    velocity.set_mag(maxspeed) { velocity.mag > maxspeed }
-    @location += velocity
-    # Reset accelertion to 0 each cycle
-    @acceleration *= 0
-  end
-  
-  # A method that calculates and applies 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 maximum speed
-    desired.normalize!
-    desired *= maxspeed
-    # Steering = Desired minus Velocity
-    steer = desired - velocity
-    # Limit to maximum steering force
-    steer.set_mag(maxforce) { steer.mag > maxforce }   
-    return steer
-  end
-
-  def render
-    # Draw a triangle rotated in the direction of velocity
-    theta = velocity.heading + Math::PI/2
-    fill(200, 100)
-    stroke(255)
-    push_matrix
-    translate(location.x,location.y)
-    rotate(theta)
-    begin_shape(TRIANGLES)
-    vertex(0, -r * 2)
-    vertex(-r, r * 2)
-    vertex(r, r * 2)
-    end_shape
-    pop_matrix
-  end
-
-  # Wraparound
-  def borders
-    location.x = width + r if location.x < -r
-    location.y = height + r if location.y < -r
-    location.x = -r if location.x > width + r
-    location.y = -r if location.y > height + r
-  end
-          
-  # Separation
-  # Method checks for nearby boids and steers away
-  def separate(boids)
-    desiredseparation = 25.0
-    steer = Vec2D.new
-    count = 0
-    # For every other bird in the system, check if it's too close
-    boids.reject{ |bd| bd.equal? self }.each do |other|
-      d = location.dist(other.location)
-      # If the distance is greater than 0 and less than an arbitrary amount 
-      if (0.0001..desiredseparation).include? d
-        # Calculate vector pointing away from neighbor
-        diff = location - other.location
-        diff.normalize!
-        diff /= d             # Weight by distance
-        steer += diff
-        count += 1            # Keep track of how many
-      end
-    end
-    # Average -- divide by how many
-    if count > 0
-      steer /= count.to_f
-    end
-    
-    # As long as the vector is greater than 0
-    if steer.mag > 0
-      # Implement Reynolds: Steering = Desired - Velocity
-      steer.normalize!
-      steer *= maxspeed
-      steer -= velocity      
-      steer.set_mag(maxforce) { steer.mag > maxforce } 
-    end
-    return steer
-  end
-    
-  # Alignment
-  # For every other nearby boid in the system, calculate the average velocity
-  def align(boids)
-    neighbordist = 50
-    sum = Vec2D.new
-    steer = Vec2D.new
-    count = 0
-    boids.reject{ |bd| bd.equal? self }.each do |other|
-      d = location.dist(other.location)
-      if (0..neighbordist).include? d
-        sum += other.velocity
-        count += 1
-      end
-    end
-    if (count > 0)
-      sum /= count.to_f
-      sum.normalize!
-      sum *= maxspeed
-      steer = sum - velocity
-      steer.set_mag(maxforce) { steer.mag > maxforce }
-    end
-    return steer
-  end
-    
-  # Cohesion
-  # For the average location (i.e. center) of all other nearby boids, calculate
-  # steering vector towards that location
-  def cohesion(boids)
-    neighbordist = 50
-    sum = Vec2D.new   # Start with empty vector to accumulate all locations
-    count = 0
-    boids.reject { |bd| bd.equal? self }.each do |other|
-      d = location.dist(other.location)
-      if (0.0001..neighbordist).include? d
-        sum += other.location # Add location
-        count += 1
-      end
-    end
-    sum /= count unless count == 0        # avoid div by zero
-    (count > 0) ? seek(sum) : Vec2D.new 
-  end
-end

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

@@ -1,113 +0,0 @@
-# The Particle System
-
-class ParticleSystem
-  include Processing::Proxy
-
-  attr_reader :particles, :particle_shape
-
-  def initialize(width, height, sprite, n)
-    @particles = []
-    # The PShape is a group
-    @particle_shape = create_shape(GROUP)
-
-    # Make all the Particles
-    n.times do |i|
-      particles << Particle.new(width, height, sprite)
-      # Each particle's PShape gets added to the System PShape
-      particle_shape.add_child(particles[i].s_shape)
-    end
-  end
-
-  def update
-    particles.each do |p|
-      p.update
-    end
-  end
-
-  def set_emitter(x, y)
-    particles.each do |p|
-      # Each particle gets reborn at the emitter location
-      p.rebirth(x, y) if (p.dead?)
-    end
-  end
-
-  def display
-    shape(particle_shape)
-  end
-end
-
-# An individual Particle
-
-class Particle
-  include Processing::Proxy
-  
-  GRAVITY = Vec2D.new(0, 0.1)
-
-  attr_reader :center, :velocity, :lifespan, :s_shape, :part_size,
-  :boundary_x, :boundary_y, :sprite
-
-  def initialize width, height, sprite
-    @sprite = sprite
-    @boundary_x = Boundary.new(0, width)
-    @boundary_y = Boundary.new(0, height)
-    part_size = rand(10..60)
-    # The particle is a textured quad
-    @s_shape = create_shape
-    s_shape.begin_shape(QUAD)
-    s_shape.no_stroke
-    s_shape.texture(sprite)
-    s_shape.normal(0, 0, 1)
-    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.0, height / 2.0)
-  end
-
-  def rebirth(x, y)
-    theta = rand(-PI .. PI)
-    speed = rand(0.5 .. 4)
-    # A velocity with random angle and magnitude
-    @velocity = Vec2D.from_angle(theta)
-    @velocity *= speed
-    # Set lifespan
-    @lifespan = 255
-    # Set location using translate
-    s_shape.reset_matrix
-    s_shape.translate(x, y)
-    # Update center vector
-    center.x, center.y = x, y
-  end
-
-  # Is it off the screen, or its lifespan is over?
-  def dead?
-    return true if lifespan < 0
-    return true if boundary_y.exclude? center.y
-    return true if boundary_x.exclude? center.x
-    false
-  end
-
-  def update
-    # Decrease life
-    @lifespan = lifespan - 1
-    # Apply gravity
-    @velocity += GRAVITY
-    s_shape.set_tint(color(255, lifespan))
-    # Move the particle according to its velocity
-    s_shape.translate(velocity.x, velocity.y)
-    # and also update the center location
-    @center += velocity
-  end
-end
-
-# unusually in this case we are looking for excluded values
-
-Boundary = Struct.new(:lower, :upper) do
-  def exclude? val
-    true unless (lower...upper).cover? val
-  end
-end

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

@@ -1,85 +0,0 @@
-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/vec2d/morph.rb

@@ -1,87 +0,0 @@
-#
-# Morph.
-# 
-# Changing one shape into another by interpolating
-# vertices from one to another
-#
-load_library :vecmath
-
-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)
-  @circle = []
-  @square = []
-  @morph = []
-  @state = false
-  @renderer = AppRender.new(self)
-  frame_rate(15)
-  # Create a circle using vectors pointing from center
-  (ALPHA..OMEGA).step(THETA) do |angle|
-    # Note we are not starting from 0 in order to match the
-    # 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 line
-  # Top of square
-  (-50..50).step(10) do |x|
-    square << Vec2D.new(x, -50)
-  end
-  # Right side
-  (-50..50).step(10) do |y|
-    square << Vec2D.new(50, y)
-  end
-  # Bottom, NB: can't negative step ruby so use your loaf
-  5.downto(-5) do |x|
-    square << Vec2D.new(x * 10, 50)
-  end
-  # Left side
-  5.downto(-5) do |y|
-    square << Vec2D.new(-50, y * 10)
-  end
-end
-
-def draw
-  background(51)
-
-  # We will keep how far the vertices are from their target
-  @total_distance = 0
-  
-  # Look at each vertex
-  circle.length.times do |i|
-    # Are we lerping to the circle or square?
-    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 += v1.dist(v2)
-  end
-  
-  # If all the vertices are close, switch shape
-  @state = !state if @total_distance < 0.08
-  
-  # Draw relative to center
-  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|
-    v.to_vertex(renderer)
-  end
-  end_shape(CLOSE)
-end
-
-
-