ruby-processing 1.0.2 → 1.0.3

data/samples/processing_app/basics/input/storing_input.rb

@@ -0,0 +1,39 @@
+require 'ruby-processing'
+
+# Move the mouse across the screen to change the position
+# of the circles. The positions of the mouse are recorded
+# into an array and played back every frame. Between each
+# frame, the newest value are added to the end of each array
+# and the oldest value is deleted. 
+
+class StoringInput < Processing::App
+
+  def setup
+    @num = 60
+    @mx = Array.new @num, 0
+    @my = Array.new @num, 0
+    
+    smooth
+    no_stroke
+    fill 255, 153
+  end
+  
+  def draw
+  	background 51
+  	
+  	(1...@num).each do |i|
+  		@mx[i-1] = @mx[i]
+  		@my[i-1] = @my[i]
+  	end
+  	
+  	@mx[@num-1] = mouse_x
+  	@my[@num-1] = mouse_y
+  	
+  	(0...@num).each do |i|
+  		ellipse @mx[i], @my[i], i/2, i/2
+  	end
+  end
+  
+end
+
+StoringInput.new :title => "Storing Input", :width => 200, :height => 200

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

@@ -0,0 +1,66 @@
+require 'ruby-processing'
+
+# Additive Wave
+# by Daniel Shiffman. 
+# 
+# Create a more complex wave by adding two waves together. 
+
+class AdditiveWave < Processing::App
+
+  def setup
+  	@max_waves = 4				    # Total number of waves to add together
+    @wave_width = width + 16	# Width of entire wave
+    @x_spacing = 8				    # How far apart should each horizontal location be spaced
+    @theta = 0.0
+    @amplitude = []				    # Height of wave
+    @dx = []					        # Value for incrementing X, to be calculated as a function of period and x_spacing
+    
+    @max_waves.times do |i|
+    	@amplitude << random( 10, 30 )
+    	period = random( 100, 300 ) # How many pixels before the wave repeats
+    	@dx << (TWO_PI / period) * @x_spacing
+    end
+    
+    frame_rate 30
+    color_mode RGB, 255, 255, 255, 100
+    smooth
+  end
+  
+  def draw
+  	background 0
+  	calculate_wave
+  	render_wave
+  end
+  
+  def calculate_wave
+  	# Increment theta (try different values for 'angular velocity' here
+  	@theta += 0.02
+  	
+  	# Set all height values to zero
+  	@y_values = Array.new @wave_width/@x_spacing, 0
+  	
+  	# Accumulate wave height values
+  	@max_waves.times do |j|
+  		x = @theta
+  		@y_values.length.times do |i|
+  			# Every other wave is cosine instead of sine
+  			value = (j % 2) == 0 ? sin(x) : cos(x)
+  			@y_values[i] += value * @amplitude[j]
+  			x += @dx[j]
+  		end
+  	end
+  end
+  
+  def render_wave
+  	# A simple way to draw the wave with an ellipse at each location
+  	no_stroke
+  	fill 255, 50
+  	ellipse_mode CENTER
+  	@y_values.each_with_index do |y, i|
+  		ellipse i*@x_spacing, width/2+y, 16, 16
+  	end
+  end
+  
+end
+
+AdditiveWave.new :title => "Additive Wave", :width => 200, :height => 200

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

@@ -0,0 +1,54 @@
+require 'ruby-processing'
+
+ # Move the mouse to change the direction of the eyes. 
+ # The atan2() function computes the angle from each eye 
+ # to the cursor. 
+
+class Arctangent < Processing::App
+
+  def setup
+    @eyes = [
+	  Eye.new(  50,  16,  80),
+	  Eye.new(  64,  85,  40),  
+	  Eye.new(  90, 200, 120),
+	  Eye.new( 150,  44,  40), 
+	  Eye.new( 175, 120,  80)
+    ]
+    
+    smooth
+    no_stroke
+  end
+  
+  def draw
+  	background 102
+  	
+  	@eyes.each do |eye|
+  		eye.update mouse_x, mouse_y
+  		eye.display self
+  	end
+  end
+  
+  class Eye
+  	def initialize( _x, _y, _s) # contructor, called by Eye.new
+  		@x, @y, @size = _x, _y, _s
+  	end
+  	
+  	def update( mx, my )
+  		@angle = Arctangent::atan2( my-@y, mx-@x )
+  	end
+  	
+  	def display( context )
+  		context.push_matrix
+  			context.translate @x, @y
+  			context.fill 255
+  			context.ellipse 0, 0, @size, @size
+  			context.rotate @angle
+  			context.fill 153
+  			context.ellipse @size/4, 0, @size/2, @size/2
+  		context.pop_matrix
+  	end
+  end
+  
+end
+
+Arctangent.new :title => "Arctangent", :width => 200, :height => 200

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

@@ -0,0 +1,82 @@
+require 'ruby-processing'
+
+#
+# Ported from http://processing.org/learning/topics/chain.html
+#
+# One mass is attached to the mouse position and the other is attached the position of the other mass. 
+# The gravity in the environment pulls down on both.
+#
+class Chain < Processing::App
+  
+  attr_reader :gravity
+  
+  load_library :control_panel
+
+  def setup
+    smooth
+    fill 0
+    
+    # Inputs: spring1, spring2, mass, gravity
+    @gravity = 6.0
+    @mass    = 2.0
+    @s1      = Spring2d.new(width/2, height/2, @mass)
+    @s2      = Spring2d.new(width/2, height/2, @mass)
+    
+    # Control panel for changing gravity
+    control_panel do |c|
+      c.slider :gravity, 0..30
+    end
+  end
+  
+  def draw
+    background 204
+    @s1.update(mouse_x, mouse_y)
+    display(@s1, mouse_x, mouse_y)
+
+    @s2.update(@s1.x, @s1.y)
+    display(@s2, @s1.x, @s1.y)
+  end
+  
+  def display(spring, nx, ny)
+    no_stroke
+    ellipse(spring.x, spring.y, spring.diameter, spring.diameter)
+    stroke 255
+    line(spring.x, spring.y, nx, ny)
+  end
+
+end
+
+class Spring2d
+  
+  attr_reader :x, :y
+  
+  def initialize(xpos, ypos, mass)
+    @x         = xpos # The x-coordinate
+    @y         = ypos # The y-coordinate
+    @mass      = mass
+    @vx, @vy   = 0, 0 # The x- and y-axis velocities
+    @radius    = 20
+    @stiffness = 0.2
+    @damping   = 0.7
+  end
+
+  def update(target_x, target_y)
+    force_x = (target_x - self.x) * @stiffness
+    ax = force_x / @mass
+    @vx = @damping * (@vx + ax)
+    @x += @vx
+    
+    force_y = (target_y - self.y) * @stiffness
+    force_y += $app.gravity
+    ay = force_y / @mass
+    @vy = @damping * (@vy + ay)
+    @y += @vy
+  end
+  
+  def diameter
+    @radius * 2
+  end
+  
+end
+
+Chain.new(:width => 200, :height => 200, :title => "Chain", :full_screen => false)

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

@@ -0,0 +1,166 @@
+# 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 'ruby-processing'
+
+class MultipleParticleSystems < Processing::App
+  def setup
+    smooth
+    color_mode(RGB, 255, 255, 255, 100)
+    ellipse_mode(CENTER)
+
+    @particle_systems = []
+    @particle_systems.extend Runnable
+  end
+
+  def draw
+    background 0
+    @particle_systems.run
+  end
+
+  def mouse_pressed
+    @particle_systems << ParticleSystem.new(rand(21) + 5, Vector.new(mouse_x, mouse_y))
+  end
+
+  module Runnable
+    def run
+      self.reject! { |item| item.dead? }
+      self.each    { |item| item.run   }
+    end
+  end
+
+  class ParticleSystem < Array
+    include Runnable
+    alias_method :dead?, :empty?
+
+    def initialize(number, origin)
+      super()
+      @origin = origin
+      kind = rand < 0.5 ? Particle : CrazyParticle
+      number.times { self << kind.new(origin) }
+    end
+  end
+
+  class Particle
+    def initialize(origin)
+      @origin = origin
+      @velocity = Vector.new(rand * 2 - 1, rand * 2 - 2)
+      @acceleration = Vector.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
+      $app.stroke(255, @lifespan)
+      $app.fill(100, @lifespan)
+      $app.ellipse(@origin.x, @origin.y, @radius, @radius)
+    end
+
+    def render_velocity_vector
+      scale = 10
+      arrow_size = 4
+
+      $app.push_matrix
+
+      $app.translate(@origin.x, @origin.y)
+      $app.rotate(@velocity.heading)
+
+      length = @velocity.magnitude * scale
+
+      $app.line 0, 0, length, 0
+      $app.line length, 0, length - arrow_size, arrow_size / 2
+      $app.line length, 0, length - arrow_size, -arrow_size / 2
+
+      $app.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.magnitude / 10
+    end
+
+    def grow
+      @lifespan -= 0.8
+    end
+
+    def render_rotation_line
+      $app.push_matrix
+
+      $app.translate(@origin.x, @origin.y)
+      $app.rotate(@theta)
+
+      $app.stroke(255, @lifespan)
+
+      $app.line(0, 0, 25, 0)
+
+      $app.pop_matrix
+    end
+  end
+
+  class Vector
+    attr_accessor :x, :y
+
+    def initialize(x, y)
+      @x, @y = x, y
+    end
+
+    def +(other)
+      if other.is_a?(Numeric)
+        Vector.new(@x + other, @y + other)
+      elsif other.is_a?(Vector)
+        Vector.new(@x + other.x, @y + other.y)
+      else
+        self
+      end
+    end
+
+    def heading
+      -1 * Math::atan2(-@y, @x)
+    end
+
+    def magnitude
+      @x * @x + @y * @y
+    end
+  end
+end
+
+$app = MultipleParticleSystems.new :width => 640, :height => 340, :title => 'MultipleParticleSystems'

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

@@ -0,0 +1,113 @@
+# 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 'ruby-processing'
+
+class SimpleParticleSystem < Processing::App
+  def setup
+    smooth
+    color_mode(RGB, 255, 255, 255, 100)
+    ellipse_mode(CENTER)
+
+    @particles = []
+    @particles.extend Runnable
+  end
+
+  def draw
+    background 0
+    @particles.run
+    @particles << Particle.new(Vector.new(mouse_x, mouse_y))
+  end
+
+  module Runnable
+    def run
+      self.reject! { |particle| particle.dead? }
+      self.each    { |particle| particle.run   }
+    end
+  end
+
+  class Particle
+    def initialize(origin)
+      @origin = origin
+      @velocity = Vector.new(rand * 2 - 1, rand * 2 - 2)
+      @acceleration = Vector.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
+      $app.stroke(255, @lifespan)
+      $app.fill(100, @lifespan)
+      $app.ellipse(@origin.x, @origin.y, @radius, @radius)
+    end
+
+    def render_velocity_vector
+      scale = 10
+      arrow_size = 4
+
+      $app.push_matrix
+
+      $app.translate(@origin.x, @origin.y)
+      $app.rotate(@velocity.heading)
+
+      length = @velocity.magnitude * scale
+
+      $app.line 0,      0, length,              0
+      $app.line length, 0, length - arrow_size, arrow_size / 2
+      $app.line length, 0, length - arrow_size, -arrow_size / 2
+
+      $app.pop_matrix
+    end
+  end
+
+  class Vector
+    attr_accessor :x, :y
+
+    def initialize(x, y)
+      @x, @y = x, y
+    end
+
+    def +(other)
+      if other.is_a?(Numeric)
+        Vector.new(@x + other, @y + other)
+      elsif other.is_a?(Vector)
+        Vector.new(@x + other.x, @y + other.y)
+      else
+        self
+      end
+    end
+
+    def heading
+      -1 * Math::atan2(-@y, @x)
+    end
+
+    def magnitude
+      @x * @x + @y * @y
+    end
+  end
+end
+
+$app = SimpleParticleSystem.new :width => 640, :height => 340, :title => 'SimpleParticleSystem'