ruby-processing 2.6.3 → 2.6.4

data/samples/processing_app/topics/motion/reflection1.rb

@@ -1,108 +0,0 @@
-#
-# Non-orthogonal Reflection 
-# by Ira Greenberg. 
-# 
-# Based on the equation (R = 2N(N*L)-L) where R is the 
-# reflection vector, N is the normal, and L is the incident
-# vector.
-#
-load_library :vecmath
-
-attr_reader :base1, :base2, :base_length, :coords, :position, :radius
-attr_reader :direction, :speed, :velocity, :incidence 
-
-def setup
-  size(640, 360)
-  @radius = 6
-  @speed = 3.5
-  fill(128)
-  @base1 = Vec2D.new(0, height - 150)
-  @base2 = Vec2D.new(width, height)
-  @coords = create_ground
-  # start ellipse at middle top of screen
-  @position = Vec2D.new(width/2, 0)  
-  # set initial random direction
-  @direction = Vec2D.new(rand(-1.0..1), rand(-1.0..1))
-  @velocity = Vec2D.new
-end
-
-def draw
-  # draw background
-  fill(0, 12)
-  no_stroke
-  rect(0, 0, width, height)
-  
-  # draw base
-  fill(200)
-  quad(base1.x, base1.y, base2.x, base2.y, base2.x, height, 0, height)
-  
-  # calculate base top normal
-  base_delta = base2 - base1
-  base_delta.normalize!
-  normal = Vec2D.new(-base_delta.y, base_delta.x)  
-  # draw ellipse
-  no_stroke
-  fill(255)
-  ellipse(position.x, position.y, radius * 2, radius * 2)
-  
-  # set ellipse velocity
-  @velocity.x, @velocity.y = direction.x, direction.y
-  @velocity *= speed
-  
-  # move ellipse
-  @position += velocity
-  
-  # normalized incidence vector
-  @incidence = direction * -1
-  
-  # detect and handle collision
-  coords.each do |coord|
-    # check distance between ellipse and base top coordinates
-    if (Vec2D.dist_squared(position, coord) < radius * radius)
-      
-      # calculate dot product of incident vector and base top normal 
-      dot = incidence.dot(normal)
-      
-      # assign reflection vector to direction vector
-      direction.x, direction.y = 2*normal.x*dot - incidence.x, 2*normal.y*dot - incidence.y      
-      # draw base top normal at collision point
-      stroke(255, 128, 0)
-      line(position.x, position.y, position.x - normal.x*100, position.y - normal.y*100)
-     end 
-  end
-  
-  # detect boundary collision
-  # right
-  if (position.x > width - radius)
-    @position.x = width - radius
-    @direction.x *= -1
-  end
-  # left 
-  if (position.x < radius)
-    @position.x = radius
-    @direction.x *= -1
-  end
-  # top
-  if (position.y < radius)
-    @position.y = radius
-    @direction.y *= -1
-    # randomize base top
-    @base1.y = rand(height - 100..height)
-    @base2.y = rand(height - 100..height)
-    @coords = create_ground
-  end
-end
-
-def create_ground
-  # calculate length of base top
-  @base_length = Vec2D.dist(base1, base2)
-  # fill base top coordinate array
-  coords = []
-  (0 ... base_length.ceil).each do |i|
-     coords << Vec2D.new(
-     base1.x + ((base2.x - base1.x) / base_length) * i,
-     base1.y + ((base2.y - base1.y) / base_length) * i)
-  end
-  return coords
-end
-

data/samples/processing_app/topics/motion/reflection2.rb

@@ -1,122 +0,0 @@
-#
-# Non-orthogonal Collision with Multiple Segments 
-# by Ira Greenberg. 
-# 
-# Based on Keith Peter's Solution in
-# Foundation Actionscript Animation: Making Things Move!
-
-
-load_library 'ground'
-
-GRAVITY = Vect.new(0, 0.05)
-DAMPING = 0.8
-SEGS = 40
-attr_accessor :orb, :velocity
-attr_reader :ground, :peakHeights
-
-def setup
-  size(640, 360)
-  @orb = Orb.new(50.0, 50.0, 3.0)
-  @velocity = Vect.new(0.5, 0.0)
-  # Initialize ground peak heights 
-  @peakHeights = []
-  (SEGS + 1).times do
-    @peakHeights << rand(height - 40.0..height - 30.0)
-  end
-  @ground = []  
-  
-  # Float value required for segment width 
-  # calculations so the ground spans the entire 
-  # display window, regardless of segment number.
-  
-  SEGS.times do |i|
-    @ground << Ground.new(width.to_f/SEGS*i, peakHeights[i], width.to_f/SEGS*(i+1), peakHeights[i+1])
-  end
-end
-
-
-def draw
-  # Background
-  no_stroke
-  fill(0, 0, 40, 15)
-  rect(0, 0, width, height)
-  
-  # Move orb
-  velocity.add(GRAVITY)
-  orb.move(velocity)
-  
-  # Draw ground
-  fill(127, 80, 70)
-  begin_shape
-  ground.each do |seg|
-    vertex(seg.x1, seg.y1)
-    vertex(seg.x2, seg.y2)
-  end
-  vertex(ground[SEGS - 1].x2, height)
-  vertex(ground[0].x1, height)
-  end_shape(CLOSE)
-  
-  # Draw orb
-  no_stroke
-  fill(200)
-  ellipse(orb.x, orb.y, orb.r * 2, orb.r * 2)
-  
-  # Collision detection
-  check_wall_collision
-  ground.each do |seg|
-    check_ground_collision(seg)
-  end
-end
-
-
-def check_wall_collision
-  if (orb.x > width-orb.r)
-    orb.x = width-orb.r
-    velocity.x *= -DAMPING
-    
-  elsif (orb.x < orb.r)
-    orb.x = orb.r
-    velocity.x *= -DAMPING
-  end
-end
-
-
-def check_ground_collision(ground_segment)
-  
-  # Get difference between orb and ground
-  dx = orb.x - ground_segment.x
-  dy = orb.y - ground_segment.y
-  
-  # Precalculate trig values
-  cosine = cos(ground_segment.rot)
-  sine = sin(ground_segment.rot)
-  
-  #  Rotate ground and velocity to allow 
-  # orthogonal collision calculations
-  ground_x_temp = cosine * dx + sine * dy
-  ground_y_temp = cosine * dy - sine * dx
-  velocity_x_temp = cosine * velocity.x + sine * velocity.y
-  velocity_y_temp = cosine * velocity.y - sine * velocity.x
-  
-  # collision - check for surface 
-  # collision and also that orb is within 
-  # left/rights bounds of ground segment
-  if (ground_y_temp + orb.r) > EPSILON * 5 
-    if (orb.x > ground_segment.x1) && (orb.x < ground_segment.x2)
-      # keep orb from going into ground
-      ground_y_temp = -orb.r 
-      # bounce and slow down orb
-      velocity_y_temp *= -DAMPING
-    end
-  end
-  
-  # Reset ground, velocity and orb
-  dx = cosine * ground_x_temp - sine * ground_y_temp
-  dy = cosine * ground_y_temp + sine * ground_x_temp
-  @velocity.x = cosine * velocity_x_temp - sine * velocity_y_temp
-  @velocity.y = cosine * velocity_y_temp + sine * velocity_x_temp
-  @orb.x = ground_segment.x + dx
-  @orb.y = ground_segment.y + dy
-end
-
-

data/samples/processing_app/topics/ruby_hook/hooky.rb

@@ -1,26 +0,0 @@
-# Hooky class demonstrates how to use the post_initialize hook,
-# available since ruby-processing-2.6.2, to additional attribute
-# in this case :background as an array of int (splat to color)
-# Not sure how clever it is to have multiple sketch instances.
-
-class Hooky < Processing::App
-  attr_reader :back
-
-  def setup
-    size 200, 200
-    background(*back)
-  end
-
-  def post_initialize(args)
-    @back = (args[:background])
-  end
-end
-
-red = [200, 0, 0]
-green = [0, 200, 0]
-blue = [0, 0, 200]
-colors = [red, green, blue]
-
-colors.each_with_index do |col, i|
-  Hooky.new(x: i * 90, y: i * 90, title: "Hooky #{i}", background: col)
-end

data/samples/processing_app/topics/ruby_hook/subclass.rb

@@ -1,75 +0,0 @@
-# An example demonstrating the use of a hook to decouple subclasses in
-# ruby-processing. The base class here is Spin, and we have included
-# post_initialize as the hook (it does nothing in the base class). SpinArm
-# and SpinSpots both subclass Spin, but only SpinSpots requires the hook to
-# change the initialization. Note the use the hook means the subclass does
-# not need to call super
-
-def setup
-  size 640, 360
-  @arm = SpinArm.new(x: width / 2, y: height / 2, s: 0.01)
-  @spots = SpinSpots.new(x: width / 2, y: height / 2, s: -0.02, d: 90.0)
-end
-
-def draw
-  background 204
-  @arm.display
-  @spots.display
-end
-
-class Spin
-
-  attr_accessor :x, :y, :speed
-  attr_accessor :angle
-
-  def initialize(args = {})
-    @x, @y = args[:x], args[:y]
-    @speed = args[:s]
-    @angle = args[:angle] || 0.0
-    post_initialize(args)  # this is the hook
-  end
-
-  def update
-    @angle += speed
-  end
-
-  def post_initialize(_args)
-    nil
-  end
-
-end
-
-class SpinArm < Spin # inherit from (or "extend") class Spin
-  # NB: initialize inherited from Spin class
-
-  def display
-    stroke_weight 1
-    stroke 0
-    push_matrix
-    translate x, y
-    update
-    rotate angle
-    line 0, 0, 165, 0
-    pop_matrix
-  end
-end
-
-
-class SpinSpots < Spin
-  attr_accessor :dim
-
-  def post_initialize(args)
-    @dim = args[:d]
-  end
-
-  def display
-    no_stroke
-    push_matrix
-    translate x, y
-    update
-    rotate angle
-    ellipse(-dim / 2, 0, dim, dim)
-    ellipse(dim / 2, 0, dim, dim)
-    pop_matrix
-  end
-end

data/samples/processing_app/topics/shaders/README

@@ -1 +0,0 @@
-Recently I needed to use an external jruby to get some sketches to run OK (otherwise I got method missing errors see external_library/fisica). I thought I may be able to get rid of the included jruby-complete, until I tried to run the shader examples in this folder. I got java lang null pointer exception for these sketches and a few others (notably planets.rb in the demo folder). Needeless to say these sketches run OK using the included jruby-complete!!!

data/samples/processing_app/topics/shaders/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/topics/shaders/blur_filter.rb

@@ -1,25 +0,0 @@
-#
-# Blur Filter
-# 
-# Change the default shader to apply a simple, custom blur filter.
-# 
-# Press the mouse to switch between the custom and default shader.
-#
-
-attr_reader :blur
-
-def setup
-  size(640, 360, P2D)
-  @blur = load_shader('blur.glsl') 
-  stroke(255, 0, 0)
-  rectMode(CENTER)
-end
-
-def draw
-  filter(blur)  
-  rect(mouse_x, mouse_y, 150, 150) 
-  ellipse(mouse_x, mouse_y, 100, 100)
-end
-
-
-

data/samples/processing_app/topics/shaders/bw_shader.rb

@@ -1,40 +0,0 @@
-# Texture from Jason Liebig's FLICKR collection of vintage labels and wrappers:
-# http://www.flickr.com/photos/jasonliebigstuff/3739263136/in/photostream/
-
-attr_reader :label, :can, :angle, :bw_shader
-
-def setup
-  size(640, 360, P3D)  
-  @label = load_image('lachoy.jpg')
-  @can = create_can(100, 200, 32, label)
-  @bw_shader = load_shader('bwfrag.glsl')
-  @angle = 0
-end
-
-def draw    
-  background(0)  
-  shader(bw_shader)    
-  translate(width/2, height/2)
-  rotate_y(angle)  
-  shape(can)  
-  @angle += 0.01
-end
-
-def create_can(r, h, detail, tex)
-  texture_mode(NORMAL)
-  sh = create_shape
-  sh.begin_shape(QUAD_STRIP)
-  sh.no_stroke
-  sh.texture(tex)
-  (0..detail).each do |i|
-    angle = TAU / detail
-    x = sin(i * angle)
-    z = cos(i * angle)
-    u = i.to_f / detail
-    sh.normal(x, 0, z)
-    sh.vertex(x * r, -h/2, z * r, u, 0)
-    sh.vertex(x * r, +h/2, z * r, u, 1)    
-  end
-  sh.end_shape 
-  return sh
-end

data/samples/processing_app/topics/shaders/conway.rb

@@ -1,26 +0,0 @@
-# GLSL version of Conway's game of life, ported from GLSL sandbox:
-# http://glsl.heroku.com/e/207.3
-# Exemplifies the use of the ppixels uniform in the shader, that gives
-# access to the pixels of the previous frame.
-attr_accessor :pg, :conway
-
-def setup
-  size(400, 400, P3D)    
-  @pg = createGraphics(400, 400, P2D)
-  pg.no_smooth
-  @conway = load_shader('data/conway.glsl')
-  conway.set('resolution', width.to_f, height.to_f)  
-end
-
-def draw
-  conway.set('time', millis / 1000.0)  
-  xm = map(mouse_x, 0, width, 0, 1)       # NB: processings map function
-  ym = map(mouse_y, 0, height, 1, 0)
-  conway.set('mouse', xm, ym) 
-  pg.begin_draw
-  pg.background(0)
-  pg.shader(conway)
-  pg.rect(0, 0, pg.width, pg.height)  
-  pg.end_draw  
-  image(pg, 0, 0, width, height)  
-end