ruby-processing 2.6.3 → 2.6.4

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

@@ -1,25 +0,0 @@
-# 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

@@ -1,33 +0,0 @@
-# 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

@@ -1,31 +0,0 @@
-# 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

@@ -1,37 +0,0 @@
-# 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

@@ -1,19 +0,0 @@
-# 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/arcball/Rakefile

@@ -1,30 +0,0 @@
-# Simple demo Rakefile to autorun samples in current directory
-# adjust path to rp5 executable, and or opts as required
-
-SAMPLES_DIR = './'
-
-desc 'run demo'
-task default: [:demo]
-
-desc 'demo'
-task :demo do
-  samples_list.shuffle.each{ |sample| run_sample sample }
-end
-
-def samples_list
-  files = []
-  Dir.chdir(SAMPLES_DIR)
-  Dir.glob('*.rb').each do |file|
-    files << File.join(SAMPLES_DIR, file)
-  end
-  return files
-end
-
-def run_sample(sample_name)
-  puts "Running #{sample_name}...quit to run next sample"
-  open("|rp5 run #{sample_name}", 'r') do |io|
-    while l = io.gets
-      puts(l.chop)
-    end      
-  end
-end

data/samples/processing_app/library/vecmath/arcball/arcball_box.rb

@@ -1,23 +0,0 @@
-load_library :vecmath
-
-############################
-# Use mouse drag to rotate
-# the arcball. Use mousewheel
-# to zoom. Hold down x, y, z
-# to constrain rotation axis.
-############################
-
-def setup
-  size(600, 600, P3D)
-  smooth(8)
-  ArcBall.init(self, 300, 300)
-  fill 180
-end
-
-def draw
-  background(50)  
-  box(300, 300, 300)
-end
-
-
-

data/samples/processing_app/library/vecmath/arcball/arcball_radius.rb

@@ -1,23 +0,0 @@
-load_library :vecmath
-
-############################
-# Use mouse drag to rotate
-# the arcball. Use mousewheel
-# to zoom. Hold down x, y, z
-# to constrain rotation axis.
-############################
-
-def setup
-  size(600, 600, P3D)
-  smooth(8)
-  ArcBall.init(self, 300, 300, 250)
-  fill 180
-end
-
-def draw
-  background(50)  
-  box(300, 300, 300)
-end
-
-
-

data/samples/processing_app/library/vecmath/arcball/arcball_shape.rb

@@ -1,29 +0,0 @@
-load_library :vecmath
-
-attr_reader :my_cube
-
-def setup
-  size(600, 600, P3D)
-  smooth(8)
-  ArcBall.init(self)
-  @my_cube = create_shape(BOX, 400, 400, 400)
-  my_cube.set_fill(color(100, 10, 100))
-
-end
-
-def draw
-  background(50, 50, 100)
-  define_lights
-  lights
-  stroke(0)
-  shape(my_cube)
-end
-
-def define_lights
-  ambient(20, 20, 20)
-  ambient_light(50, 50, 50)
-  point_light(30, 30, 30, 200, -150, 0)
-  directional_light(0, 30, 50, 1, 0, 0)
-  spot_light(30, 30, 30, 0, 40, 200, 0, -0.5, -0.5, PI / 2, 2)
-end
-

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

@@ -1,2 +0,0 @@
-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/vec2d/Rakefile

@@ -1,30 +0,0 @@
-# Simple demo Rakefile to autorun samples in current directory
-# adjust path to rp5 executable, and or opts as required
-
-SAMPLES_DIR = './'
-
-desc 'run demo'
-task default: [:demo]
-
-desc 'demo'
-task :demo do
-  samples_list.shuffle.each{ |sample| run_sample sample }
-end
-
-def samples_list
-  files = []
-  Dir.chdir(SAMPLES_DIR)
-  Dir.glob('*.rb').each do |file|
-    files << File.join(SAMPLES_DIR, file)
-  end
-  return files
-end
-
-def run_sample(sample_name)
-  puts "Running #{sample_name}...quit to run next sample"
-  open("|rp5 --nojruby run #{sample_name}", 'r') do |io|
-    while l = io.gets
-      puts(l.chop)
-    end      
-  end
-end

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

@@ -1,74 +0,0 @@
-#
-# 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 
-    # here we supply a block that evaluates to a boolean to set
-    # the velocit conditionally
-    velocity.set_mag(topspeed) { velocity.mag > topspeed }
-    # 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/vec2d/bouncing_ball.rb

@@ -1,45 +0,0 @@
-#
-# 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
-RADIUS = 24
-
-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
-  velocity.x *= -1 unless (RADIUS..width - RADIUS).include?(loc.x)
-  if loc.y > (height - RADIUS)
-    # We're reducing velocity ever so slightly 
-    # when it hits the bottom of the window
-    velocity.y *= -0.95 
-    loc.y = height - RADIUS
-  end
-  # Display circle at location vector
-  stroke(255)
-  stroke_weight(2)
-  fill(127)
-  ellipse(loc.x, loc.y, RADIUS * 2, RADIUS * 2)
-end

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

@@ -1,169 +0,0 @@
-# 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 :position, :r, :m, :velocity, :current
-  def initialize(r = 0.0, velocity = nil, position = Vec2D.new)
-    @position, @velocity, @r = position, velocity, r
-    @m = r * 0.1
-  end
-  
-  def move
-    @position += velocity
-  end
-  
-  def draw
-    d = r * 2
-    ellipse position.x, position.y, d, d
-    @current = position.copy
-  end
-  
-  def erase
-    d = r * 2
-    rect current.x, current.y, d, d
-  end
-end
-
-attr_reader :balls
-
-
-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)
-  pos = nil
-  while !pos || !empty_space?(pos, r) do
-    pos = Vec2D.new(rand(r..width - r), rand(r..height - r))
-  end
-  return pos
-end
-
-
-def empty_space?(position, r)
-  balls.each do |ball|
-    return false if position.dist(ball.position) < 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 = bb.position - ba.position   
-      # 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].position.x  = cosine * bVect.x + sine * bVect.y
-      bTemp[1].position.y  = cosine * bVect.y - sine * bVect.x
-      
-      # rotate Temporary velocities
-      vTemp = [Vec2D.new, Vec2D.new]
-      vTemp[0].x  = cosine * ba.velocity.x + sine * ba.velocity.y
-      vTemp[0].y  = cosine * ba.velocity.y - sine * ba.velocity.x
-      vTemp[1].x  = cosine * bb.velocity.x + sine * bb.velocity.y
-      vTemp[1].y  = cosine * bb.velocity.y - sine * bb.velocity.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].position.x = cosine * bTemp[0].position.x - sine * bTemp[0].position.y
-      bFinal[0].position.y = cosine * bTemp[0].position.y + sine * bTemp[0].position.x
-      bFinal[1].position.x = cosine * bTemp[1].position.x - sine * bTemp[1].position.y
-      bFinal[1].position.y = cosine * bTemp[1].position.y + sine * bTemp[1].position.x
-      
-      # update balls to screen position
-      bb.position = ba.position + bFinal[1].position     
-      ba.position = ba.position + bFinal[0].position
-
-      
-      # update velocities
-      ba.velocity.x = cosine * vFinal[0].x - sine * vFinal[0].y
-      ba.velocity.y = cosine * vFinal[0].y + sine * vFinal[0].x
-      bb.velocity.x = cosine * vFinal[1].x - sine * vFinal[1].y
-      bb.velocity.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.velocity.x *= -1 unless (ball.r..width - ball.r).include? ball.position.x 
-  ball.velocity.y *= -1 unless (ball.r..height - ball.r).include? ball.position.y 
-end
-
-