ruby-processing 1.0.11 → 2.4.1

data/samples/processing_app/library/pdf/large_page.rb

@@ -0,0 +1,25 @@
+# One Frame. 
+# 
+# Large Page. 
+# 
+# Saves one frame as a PDF with a size larger
+# than the screen. When PDF is used as the renderer
+# (the third parameter of size) the display window 
+# does not open. The file is saved to the sketch folder.
+
+load_libraries 'pdf'
+include_package 'processing.pdf'
+
+def setup
+    size(2000, 2000, PDF, "Line.pdf")  
+end
+
+def draw
+  background(255)
+  stroke(0, 20)
+  strokeWeight(20.0);
+  line(200, 0, width/2, height)  
+  exit  # Quit the program
+end
+
+

data/samples/processing_app/library/pdf/many_frames.rb

@@ -0,0 +1,33 @@
+# Multiple Frames. 
+# 
+# Saves one PDF document of many frames drawn to the screen.
+# Starts the file when the mouse is pressed and end the file
+# when the mouse is released.
+
+
+load_library 'pdf'
+include_package 'processing.pdf'
+
+def setup
+  size(600, 600)
+  frame_rate(24)
+  background(255)
+end
+
+def draw
+  stroke(0, 20)
+  stroke_weight(20.0)
+  line(mouse_x, 0, width-mouse_y, height)
+end
+
+
+def mouse_pressed
+  begin_record(PDF, "Lines.pdf"); 
+  background(255);
+end
+
+def mouse_released
+  end_record
+  background(255)
+end
+

data/samples/processing_app/library/pdf/many_pages.rb

@@ -0,0 +1,31 @@
+# Many Pages. 
+# 
+# Saves a new page into a PDF file each loop through draw().
+# Pressing the mouse finishes writing the file and exits the program.
+#
+
+load_library 'pdf'
+include_package 'processing.pdf'
+
+attr_reader :pdf
+
+def setup
+  size(600, 600)
+  frame_rate(4)
+  @pdf = begin_record(PDF, "Lines.pdf")
+  begin_record(pdf)
+end
+
+def draw
+  background(255) 
+  stroke(0, 20)
+  stroke_weight(20.0)
+  line(mouse_x, 0, width - mouse_y, height)
+  pdf.nextPage
+end
+
+def mouse_pressed
+  end_record
+  exit
+end
+

data/samples/processing_app/library/pdf/many_pdfs.rb

@@ -0,0 +1,37 @@
+# Many PDFs. 
+# 
+# Saves one PDF file each each frame while the mouse is pressed.
+# When the mouse is released, the PDF creation stops.
+#
+
+load_library 'pdf'
+include_package 'processing.pdf'
+
+attr_reader :pdf, :save_pdf
+
+def setup
+  size(600, 600)
+  frameRate(24)
+  @save_pdf = false
+end
+
+def draw
+  begin_record(PDF, "lines#{frame_count}.pdf") unless !save_pdf
+  background(255) 
+  stroke(0, 20)
+  stroke_weight(20.0)
+  line(mouse_x, 0, width-mouse_y, height)
+  end_record unless !save_pdf
+end
+
+def mouse_pressed
+  @save_pdf = true
+end
+
+def mouse_released
+  @save_pdf = false
+end
+
+
+
+

data/samples/processing_app/library/pdf/one_frame.rb

@@ -0,0 +1,19 @@
+# One Frame. 
+# 
+# Saves one PDF with the contents of the display window.
+# Because this example uses beginRecord, the image is shown
+# on the display window and is saved to the file.  
+
+load_library 'pdf'
+include_package 'processing.pdf'
+
+def setup
+  size(600, 600)    
+  begin_record(PDF, "line.pdf")     
+  background(255)
+  stroke(0, 20)
+  strokeWeight(20.0)
+  line(200, 0, 400, height)    
+  end_record
+end
+

data/samples/processing_app/library/vecmath/README.txt

@@ -0,0 +1,2 @@
+The particle_system_pshape.rb needs to be run with the --nojruby flag.
+The smoke_particle_system.rb needs to be run with the --nojruby flag.

data/samples/processing_app/library/vecmath/acceleration_with_vectors.rb

@@ -0,0 +1,75 @@
+#
+# Acceleration with Vectors 
+# by Daniel Shiffman.
+# PVector was used in the original (instead of Vec2D)
+# 
+# Demonstration of the basics of motion with vector.
+# A "Mover" object stores location, velocity, and acceleration as vectors
+# The motion is controlled by affecting the acceleration (in this case towards the mouse)
+#
+# For more examples of simulating motion and physics with vectors, see 
+# Simulate/ForcesWithVectors, Simulate/GravitationalAttraction3D
+#
+
+load_library 'vecmath'
+# A Mover object
+attr_reader :mover
+
+def setup
+  size(640,360)
+  @mover = Mover.new(width, height)
+end
+
+def draw
+  background(0)
+  
+  # Update the location
+  mover.update
+  # Display the Mover
+  mover.display
+end
+
+####
+# The Mover class
+####
+
+class Mover	
+  # The Mover tracks location, velocity, and acceleration 
+  attr_reader :location, :velocity, :acceleration,
+  # The Mover's maximum speed
+  :topspeed
+  
+  def initialize(width, height)
+    # Start in the center
+    @location = Vec2D.new(width / 2, height / 2)
+    @velocity = Vec2D.new
+    @topspeed = 5
+  end
+  
+  def update
+    
+    # Compute a vector that points from location to mouse
+    mouse = Vec2D.new(mouse_x, mouse_y)
+    @acceleration = mouse - location
+    # Set magnitude of acceleration
+    acceleration.set_mag(0.2)
+    
+    # Velocity changes according to acceleration vector
+    @velocity += acceleration
+    # Limit the velocity to topspeed, PVector has a limit function 
+    if velocity.mag_squared > topspeed**2
+      velocity.set_mag topspeed
+    end
+    # Location changes by velocity vector
+    @location += velocity
+  end
+  
+  def display
+    stroke(255)
+    stroke_weight(2)
+    fill(127)
+    ellipse(location.x, location.y, 48, 48)
+  end
+  
+end
+

data/samples/processing_app/library/vecmath/bouncing_ball.rb

@@ -0,0 +1,51 @@
+#
+# Bouncing Ball with Vectors 
+# by Daniel Shiffman.  
+# PVector was used in the original (instead of Vec2D)
+#
+# Demonstration of using vectors to control motion of body
+# This example is not object-oriented
+# See AccelerationWithVectors for an example of how to simulate motion using vectors in an object
+#
+load_library :vecmath
+
+attr_reader :loc,  # Location of shape
+            :velocity,  # Velocity of shape
+            :gravity   # Gravity acts at the shape's acceleration
+
+def setup
+  size(640,360)
+  smooth 4
+  @loc = Vec2D.new(100,100)
+  @velocity = Vec2D.new(1.5,2.1)
+  @gravity = Vec2D.new(0,0.2)
+
+end
+
+def draw
+  background(0)
+  
+  # Add velocity to the location.
+  @loc += velocity
+  # Add gravity to velocity
+  @velocity += gravity
+  
+  # Bounce off edges
+if ((loc.x > width) || (loc.x < 0))
+    velocity.x *= -1
+  end
+if (loc.y > height)
+    # We're reducing velocity ever so slightly 
+    # when it hits the bottom of the window
+    velocity.y *= -0.95 
+    loc.y = height
+  end
+
+  # Display circle at location vector
+  stroke(255)
+  stroke_weight(2)
+  fill(127)
+  ellipse(loc.x,loc.y,48,48)
+end
+
+

data/samples/processing_app/library/vecmath/circle_collision.rb

@@ -0,0 +1,174 @@
+# Based on http://processing.org/learning/topics/circlecollision.html
+# by Joe Holt
+load_library :vecmath
+
+
+# This inner class demonstrates the use of Ruby-Processing's emulation of
+# Java inner classes. The Balls are able to call Processing::App methods.
+class Ball
+  attr_accessor :x, :y, :r, :m, :vec
+  def initialize(r = 0.0, vec = nil, x = 0.0, y = 0.0)
+    @x, @y, @r = x, y, r
+    @m = r * 0.1
+    @vec = vec
+  end
+  
+  def move
+    @x += @vec.x
+    @y += @vec.y
+  end
+  
+  def draw
+    r = @r * 2
+    ellipse @x, @y, r, r
+    @px, @py = @x, @y
+  end
+  
+  def erase
+    r = @r * 2
+    rect @px, @py, r, r
+  end
+end
+
+
+def setup
+  size 400, 400
+  no_stroke
+  frame_rate 30
+  rect_mode RADIUS    
+  @balls = []
+  5.times { @balls << Ball.new(10, Vec2D.new(2.15, -1.35), *empty_space(15)) }
+  2.times { @balls << Ball.new(40, Vec2D.new(-1.65, 0.42), *empty_space(45)) }    
+  @frame_time = nil
+  @frame_count = 0
+end
+
+
+def draw
+  t = Time.now
+  fps = 1.0 / (t - @frame_time) if @frame_time
+  @frame_time = t
+  @frame_count += 1
+  
+  # erase previous screen
+  if @frame_count == 1
+    background 51
+  else
+    fill 51
+    @balls.each { |ball| ball.erase }
+  end
+  
+  # move the balls 
+  fill 240
+  @balls.each do |ball|
+    ball.move
+    ball.draw
+    check_boundary_collision ball
+  end
+  check_object_collisions
+end
+
+
+def empty_space(r)
+  x = y = nil
+  while !x || !empty_space?(x, y, r) do
+    x = rand(width - 3 * r) + r
+    y = rand(height - 3 * r) + r
+  end
+  return x, y
+end
+
+
+def empty_space?(x, y, r)
+  @balls.each do |ball|
+    vx = x - ball.x
+    vy = y - ball.y
+    mag = sqrt(vx * vx + vy * vy)
+    return false if mag < r + ball.r
+  end
+  return true
+end
+
+
+def check_object_collisions
+  
+  (0...(@balls.length)).each do |ia|
+    ((ia+1)...(@balls.length)).each do |ib|
+      
+      ba = @balls[ia]
+      bb = @balls[ib]
+      
+      # get distances between the balls components
+      bVect = Vec2D.new( bb.x - ba.x, bb.y - ba.y)      
+      # calculate magnitude of the vector separating the balls
+      bVectMag = bVect.mag
+      next if bVectMag >= ba.r + bb.r
+      # get angle of bVect
+      theta  = atan2(bVect.y, bVect.x)
+      # precalculate trig values
+      sine = sin(theta)
+      cosine = cos(theta)
+      
+      # bTemp will hold rotated ball positions. You just
+      # need to worry about bTemp[1] position
+      bTemp = [Ball.new, Ball.new]
+      # bb's position is relative to ba's
+      # so you can use the vector between them (bVect) as the 
+      # reference point in the rotation expressions.
+      # bTemp[0].x and bTemp[0].y will initialize
+      # automatically to 0.0, which is what you want
+      # since bb will rotate around ba
+      bTemp[1].x  = cosine * bVect.x + sine * bVect.y
+      bTemp[1].y  = cosine * bVect.y - sine * bVect.x
+      
+      # rotate Temporary velocities
+      vTemp = [Vec2D.new, Vec2D.new]
+      vTemp[0].x  = cosine * ba.vec.x + sine * ba.vec.y
+      vTemp[0].y  = cosine * ba.vec.y - sine * ba.vec.x
+      vTemp[1].x  = cosine * bb.vec.x + sine * bb.vec.y
+      vTemp[1].y  = cosine * bb.vec.y - sine * bb.vec.x
+      
+      # Now that velocities are rotated, you can use 1D
+      # conservation of momentum equations to calculate 
+      # the final velocity along the x-axis.
+      vFinal = [Vec2D.new, Vec2D.new]
+      # final rotated velocity for ba
+      vFinal[0].x = ((ba.m - bb.m) * vTemp[0].x + 2 * bb.m * vTemp[1].x) / (ba.m + bb.m)
+      vFinal[0].y = vTemp[0].y
+      # final rotated velocity for ba
+      vFinal[1].x = ((bb.m - ba.m) * vTemp[1].x + 2 * ba.m * vTemp[0].x) / (ba.m + bb.m)
+      vFinal[1].y = vTemp[1].y      
+
+      # Rotate ball positions and velocities back
+      # Reverse signs in trig expressions to rotate 
+      # in the opposite direction
+      # rotate balls
+      bFinal = [Ball.new, Ball.new]
+      bFinal[0].x = cosine * bTemp[0].x - sine * bTemp[0].y
+      bFinal[0].y = cosine * bTemp[0].y + sine * bTemp[0].x
+      bFinal[1].x = cosine * bTemp[1].x - sine * bTemp[1].y
+      bFinal[1].y = cosine * bTemp[1].y + sine * bTemp[1].x
+      
+      # update balls to screen position
+      bb.x = ba.x + bFinal[1].x
+      bb.y = ba.y + bFinal[1].y
+      ba.x = ba.x + bFinal[0].x
+      ba.y = ba.y + bFinal[0].y
+      
+      # update velocities
+      ba.vec.x = cosine * vFinal[0].x - sine * vFinal[0].y
+      ba.vec.y = cosine * vFinal[0].y + sine * vFinal[0].x
+      bb.vec.x = cosine * vFinal[1].x - sine * vFinal[1].y
+      bb.vec.y = cosine * vFinal[1].y + sine * vFinal[1].x
+    end
+  end
+  
+end
+
+# reverse ball velocity if at sketch boundary
+def check_boundary_collision(ball)  
+  ball.vec.x *= -1 unless (ball.r .. width - ball.r).include? ball.x 
+  ball.vec.y *= -1 unless (ball.r .. height - ball.r).include? ball.y 
+end
+
+