ruby-processing 2.6.3 → 2.6.4

data/samples/processing_app/topics/simulate/multiple_particle_systems.rb

@@ -1,133 +0,0 @@
-# Ported from http://processing.org/learning/topics/multipleparticlesystems.html
-
-# Click the mouse to generate a burst of particles at mouse location.
-
-# 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
-    reject! { |item| item.dead? }
-    each    { |item| item.run   }
-  end
-end
-
-class ParticleSystem
-  include Enumerable, Runnable
-  extend Forwardable
-  def_delegators(:@particles, :reject!, :<<, :each, :empty?)
-  def_delegator(:@particles, :empty?, :dead?)
-
-  def initialize(number, origin)
-    @particles = []
-    @origin = origin
-    kind = rand < 0.5 ? Sketch::Particle : Sketch::CrazyParticle
-    number.times { self << kind.new(origin) }
-  end
-end
-
-attr_reader :particle_systems
-
-def setup
-  size 640, 580
-  color_mode(RGB, 255, 255, 255, 100)
-  ellipse_mode(CENTER)
-  @particle_systems = ParticleSystem.new(rand(5..26), Vec2D.new(width / 2, height / 2))
-end
-
-def draw
-  background 0
-  particle_systems.run
-end
-
-def mouse_pressed
-  origin = rand(5..26)
-  vector = Vec2D.new(mouse_x, mouse_y)
-  particle_systems << ParticleSystem.new(origin, vector)
-end
-
-
-class Particle
-  attr_reader :acceleration, :velocity
-
-  def initialize(origin)
-    @origin = origin
-    @velocity = Vec2D.new(rand(-1.0..1), rand(-2.0..0))
-    @acceleration = Vec2D.new(0, 0.05)
-    @radius = 10
-    @lifespan = 100
-  end
-
-  def run
-    update
-    grow
-    render
-    render_velocity_vector
-  end
-
-  def update
-    @velocity += acceleration
-    @origin += velocity
-  end
-
-  def grow
-    @lifespan -= 1
-  end
-
-  def dead?
-    @lifespan <= 0
-  end
-
-  def render
-    stroke(255, @lifespan)
-    fill(100, @lifespan)
-    ellipse(@origin.x, @origin.y, @radius, @radius)
-  end
-
-  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
-
-class CrazyParticle < Particle
-  def initialize(origin)
-    super
-    @theta = 0
-  end
-
-  def run
-    update
-    grow
-    render
-    render_rotation_line
-  end
-
-  def update
-    super
-    @theta += velocity.x * velocity.mag / 10
-  end
-
-  def grow
-    @lifespan -= 0.8
-  end
-
-  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/topics/simulate/simple_particle_system.rb

@@ -1,78 +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
-    reject! { |item| item.lifespan <= 0 }
-    each    { |item| item.run   }
-  end
-end
-
-class ParticleSystem
-  include Enumerable, Runnable
-  extend Forwardable
-  def_delegators(:@particles, :reject!, :<<, :each, :empty?)
-  def_delegator(:@particles, :empty?, :dead?)
-
-  attr_reader :origin
-
-  def initialize(loc)
-    @particles = []
-    @origin = loc
-  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(l)
-    @acc = Vec2D.new(0, 0.05)
-    @vel = Vec2D.new(rand(-1.0..1), rand(-2.0..0))
-    @loc = l.copy
-    @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

data/samples/processing_app/topics/simulate/smoke_particle_system.rb

@@ -1,125 +0,0 @@
-# Ported from http://processing.org/learning/topics/smokeparticlesystem.html
-# For some reason this sketch needs to be run with the --nojruby flag
-#
-# A ParticleSystem (Array) object manages a variable size list of
-# particles.
-load_library :vecmath
-
-attr_reader :ps, :img, :wind
-
-def setup
-  size(640,360)
-  @img = load_image('texture.png')
-  @ps = ParticleSystem.new(0, Vec2D.new(width / 2, height - 75), img)
-end
-
-def draw
-  background(0)
-  # Calculate a "wind" force based on mouse horizontal position
-  dx = map1d(mouse_x, (0..width), (-0.2..0.2))
-  wind = Vec2D.new(dx, 0)
-  ps.apply_force(wind)
-  ps.run
-  2.times { ps.add_particle }
-  # Draw an arrow representing the wind force
-  draw_vector(wind, Vec2D.new(width / 2, 50), 500)
-end
-
-# Renders a vector object 'v' as an arrow and a location 'loc'
-def draw_vector(v, loc, scayl)
-  push_matrix
-  arrowsize = 4
-  # Translate to location to render vector
-  translate(loc.x, loc.y)
-  stroke(255)
-  # Call vector heading function to get direction (note that pointing up is a heading of 0) and rotate
-  rotate(v.heading)
-  # Calculate length of vector & scale it to be bigger or smaller if necessary
-  len = v.mag * scayl
-  # Draw three lines to make an arrow (draw pointing up since we've rotate to the proper direction)
-  line(0, 0, len, 0)
-  line(len, 0, len - arrowsize, arrowsize / 2)
-  line(len, 0, len - arrowsize, -arrowsize / 2)
-  pop_matrix
-end
-
-module Runnable
-  def run
-    reject! { |item| item.lifespan <= 0 }
-    each    { |item| item.run }
-  end
-end
-
-require 'forwardable'
-
-class ParticleSystem
-  include Enumerable, Runnable
-  extend Forwardable
-  def_delegators(:@particles, :reject!, :<<, :each)
-
-  attr_reader :particles, :origin, :image, :generator
-
-  def initialize(num, location, image)
-    @particles = []
-    @origin = location.copy
-    @image = image
-    (0 ... num).each do
-      particles << Particle.new(origin, image)
-    end
-  end
-
-  def add_particle(p = Particle.new(origin, image))
-    self << p
-  end
-
-  # Method to add a force vector to all particles currently in the system
-  def apply_force(dir)
-    each do |p|
-      p.apply_force(dir)
-    end
-  end
-end
-
-# A simple Particle class
-
-class Particle
-  include Processing::Proxy
-
-  attr_reader :loc, :acc, :vel, :lifespan, :img, :generator
-
-  def initialize(l, img_)
-    @acc = Vec2D.new(0, 0)
-    vx = random_gaussian * 0.3
-    vy = random_gaussian * 0.3 - 1.0
-    @vel = Vec2D.new(vx, vy)
-    @loc = l.copy
-    @lifespan = 100.0
-    @img = img_
-  end
-
-  def run
-    update
-    render
-  end
-
-  # Method to update location
-  def update
-    @vel += acc
-    @loc += vel
-    @lifespan -= 1.0
-  end
-
-  # Method to display
-  def render
-    image_mode(CENTER)
-    tint(255,lifespan)
-    image(img, loc.x, loc.y)
-  end
-
-  # Method to add a force vector to all particles currently in the system
-  def apply_force(f)
-    @acc += f
-  end
-end
-
-

data/samples/processing_app/topics/simulate/spring.rb

@@ -1,80 +0,0 @@
-#
-# Ported from http://www.processing.org/learning/topics/spring.html
-#
-# Click, drag, and release the horizontal bar to start the spring.
-#
-
-
-def setup
-  size 200, 200  
-  rect_mode CORNERS
-  no_stroke
-  
-  @s_height = 16    # Height
-  @left     = 50    # Left position
-  @right    = 150   # Right position
-  @max      = 100   # Maximum Y value
-  @min      = 20    # Minimum Y value
-  @over     = false # If mouse over
-  @move     = false # If mouse down and over
-  
-  # Spring simulation constants
-  @M        = 0.8   # Mass
-  @K        = 0.2   # Spring constant
-  @D        = 0.92  # Damping
-  @R        = 60    # Rest position
-  
-  # Spring simulation variables
-  @ps       = 60.0  # Position
-  @vs       = 0.0   # Velocity
-  @as       = 0     # Acceleration
-  @f        = 0     # Force
-end
-
-def draw
-  background 102
-  update_spring
-  draw_spring
-end
-
-def draw_spring
-  # Draw base
-  fill 0.2
-  b_width = 0.5 * @ps + -8
-  rect(width/2 - b_width, @ps + @s_height, width/2 + b_width, 150)
-  
-  # Set color and draw top bar
-  fill (@over || @move) ? 255 : 204
-  rect @left, @ps, @right, @ps + @s_height
-end
-
-def update_spring
-  # Update the spring position
-  if (!@move)
-    @f = -1 * @K * (@ps - @R) # f=-ky
-    @as = @f / @M             # Set the acceleration, f=ma == a=f/m
-    @vs = @D * (@vs + @as)    # Set the velocity
-    @ps = @ps + @vs           # Updated position
-  end
-  @vs = 0.0 if @vs.abs < 0.1
-  
-  # Test if mouse is over the top bar
-  within_x = (@left..@right).include?(mouse_x)
-  within_y = (@ps..@ps+@s_height).include?(mouse_y)
-  @over = within_x && within_y
-  
-  # Set and constrain the position of top bar
-  if (@move) 
-    @ps = mouseY - @s_height/2
-    @ps = constrain(@ps, @min, @max)
-  end
-end
-
-def mouse_pressed
-  @move = true if @over
-end
-
-def mouse_released
-  @move = false
-end
-

data/samples/processing_app/topics/simulate/springs.rb

@@ -1,120 +0,0 @@
-#
-# Ported from http://www.processing.org/learning/topics/springs.html
-#
-# Move the mouse over one of the circles and click to re-position. When you release the mouse, it will
-# snap back into position. Each circle has a slightly different behavior.
-#
-
-
-def setup
-  size 400, 400
-  no_stroke
-  smooth 4
-  @springs = []
-  @springs << Spring.new(70, 160,  20, 0.98, 8.0, 0.1, @springs, 0)
-  @springs << Spring.new(160, 130,  60, 0.95, 9.0, 0.1, @springs, 1)
-  @springs << Spring.new(80,  70, 120, 0.90, 9.9, 0.1, @springs, 2)
-end
-
-def draw
-  background(51)
-  @springs.each do |sp|
-    sp.update
-    sp.display
-  end
-end
-
-def mouse_pressed
-  @springs.each { |x| x.pressed }
-end
-
-def mouse_released
-  @springs.each { |x| x.released }
-end
-
-class Spring
-  include Processing::Proxy
-
-  def initialize(x, y, s, d, m, k, others, id)
-
-    # Screen values
-    @xpos      = @tempxpos = x
-    @ypos      = @tempypos = y
-    @rest_posx = x       # Rest position X
-    @rest_posy = y       # Rest position Y
-    @size      = s
-    @damp      = d       # Damping
-
-    # Spring simulation constants
-    @mass      = m       # Mass
-    @kin       = k       # Spring constant
-    @friends   = others
-    @me        = id      # Index of me in @friends
-    @over      = false
-    @move      = false
-
-    # Spring simulation variables
-    @velx      = 0.0     # X Velocity
-    @vely      = 0.0     # Y Velocity
-    @accel     = 0       # Acceleration
-    @force     = 0       # Force
-  end
-
-  def update
-    if (@move)
-      @rest_posx = mouse_x
-      @rest_posy = mouse_y
-    end
-
-    @force = -1 * @kin * (@tempypos - @rest_posy)   # f=-ky
-    @accel = @force / @mass                         # Set the acceleration, f=ma == a=f/m
-    @vely = @damp * (@vely + @accel);               # Set the velocity
-    @tempypos = @tempypos + @vely;                  # Updated position
-
-    @force = -1 * @kin * (@tempxpos - @rest_posx)   # f=-ky
-    @accel = @force / @mass;                        # Set the acceleration, f=ma == a=f/m
-    @velx = @damp * (@velx + @accel);               # Set the velocity
-    @tempxpos = @tempxpos + @velx;                  # Updated position
-
-    @over = ((over? || @move) && !other_over?)
-  end
-
-  # Test to see if mouse is over this spring
-  def over?
-    dis_x = @tempxpos - mouse_x
-    dis_y = @tempypos - mouse_y
-    Math::sqrt((dis_x * dis_x) + (dis_y * dis_y)) < @size/2
-  end
-
-  # Make sure no other springs are active
-  def other_over?
-    @friends.each_with_index do |f, i|
-      if (i != @me)
-        if f.over?
-          return true
-        end
-      end
-    end
-    return false
-  end
-
-  def display
-    if (over?)
-      fill(153)
-    else
-      fill(255)
-    end
-    ellipse(@tempxpos, @tempypos, @size, @size)
-  end
-
-  def pressed
-    @move = over?
-  end
-
-  def released
-    @move = false
-    @rest_posx = @xpos
-    @rest_posy = @ypos
-  end
-
-end