ruby-processing 2.4.3 → 2.4.4

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

@@ -1,184 +1,141 @@
 # 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
+  attr_accessor :position, :r, :m, :velocity
+  
+  def initialize(x = 0.0, y = 0.0, r = 0.0)
+    @position = Vec2D.new(x, y)
+    @r = r
     @m = r * 0.1
-    @vec = vec
-  end
+    @velocity = Vec2D.new(rand(-3.0 .. 3), rand(-3.0 .. 3))
+  end 
   
-  def move
-    @x += @vec.x
-    @y += @vec.y
+  def update
+    @position += velocity
   end
   
-  def draw
-    r = @r * 2
-    ellipse @x, @y, r, r
-    @px, @py = @x, @y
+  def check_boundary width, height 
+    if (position.x > width - r) 
+      position.x = width - r
+      velocity.x *= -1
+    elsif (position.x < r) 
+      position.x = r
+      velocity.x *= -1
+    elsif (position.y > height - r) 
+      position.y = height - r
+      velocity.y *= -1
+    elsif (position.y < r) 
+      position.y = r
+      velocity.y *= -1
+    end    
   end
   
-  def erase
-    r = @r * 2
-    rect @px, @py, r, r
+  def check_collision balls    
+    balls.each do |other_ball|
+      if !(other_ball.equal?(self))
+        # get distances between the balls components
+        difference = other_ball.position - position
+        
+        # calculate magnitude of the vector separating the balls
+        
+        dist_mag_squared = difference.mag_squared
+        
+        if dist_mag_squared < (r + other_ball.r) * (r + other_ball.r)
+          # get angle of difference
+          theta  = difference.heading
+          # precalculate trig values
+          sine = sin(theta)
+          cosine = cos(theta)
+          
+          # ball_array will hold rotated ball positions. You just
+          # need to worry about ball_array[1] position
+          ball_array = [Ball.new, Ball.new]
+          # other_ball's position is relative to ball's
+          # so you can use the vector between them (difference) as the 
+          # reference point in the rotation expressions.
+          # ball_array[0].x and ball_array[0].y will initialize
+          # automatically to 0.0, which is what you want
+          # since other_ball will rotate around ball
+          ball_array[1].position.x  = cosine * difference.x + sine * difference.y
+          ball_array[1].position.y  = cosine * difference.y - sine * difference.x
+          
+          # rotate Temporary velocities
+          velocity_array = [Vec2D.new, Vec2D.new]
+          velocity_array[0].x  = cosine * velocity.x + sine * velocity.y
+          velocity_array[0].y  = cosine * velocity.y - sine * velocity.x
+          velocity_array[1].x  = cosine * other_ball.velocity.x + sine * other_ball.velocity.y
+          velocity_array[1].y  = cosine * other_ball.velocity.y - sine * other_ball.velocity.x
+          
+          # Now that velocities are rotated, you can use 1D
+          # conservation of momentum equations to calculate 
+          # the final velocity along the x-axis.
+          final_velocities = [Vec2D.new, Vec2D.new]
+          # final rotated velocity for ball
+          final_velocities[0].x = ((m - other_ball.m) * velocity_array[0].x + 2 * other_ball.m * velocity_array[1].x) / (m + other_ball.m)
+          final_velocities[0].y = velocity_array[0].y
+          # final rotated velocity for ball
+          final_velocities[1].x = ((other_ball.m - m) * velocity_array[1].x + 2 * m * velocity_array[0].x) / (m + other_ball.m)
+          final_velocities[1].y = velocity_array[1].y
+          
+          # hack to avoid clumping
+          ball_array[0].position.x += final_velocities[0].x
+          ball_array[1].position.x += final_velocities[1].x
+          
+          # Rotate ball positions and velocities back
+          # Reverse signs in trig expressions to rotate 
+          # in the opposite direction
+          # rotate balls
+          final_positions = [Vec2D.new, Vec2D.new]
+          final_positions[0].x = cosine * ball_array[0].position.x - sine * ball_array[0].position.y
+          final_positions[0].y = cosine * ball_array[0].position.y + sine * ball_array[0].position.x
+          final_positions[1].x = cosine * ball_array[1].position.x - sine * ball_array[1].position.y
+          final_positions[1].y = cosine * ball_array[1].position.y + sine * ball_array[1].position.x
+          
+          # update balls to screen position
+          other_ball.position = position + final_positions[1]
+          @position += final_positions[0]
+          
+          # update velocities
+          velocity.x = cosine * final_velocities[0].x - sine * final_velocities[0].y
+          velocity.y = cosine * final_velocities[0].y + sine * final_velocities[0].x
+          other_ball.velocity.x = cosine * final_velocities[1].x - sine * final_velocities[1].y
+          other_ball.velocity.y = cosine * final_velocities[1].y + sine * final_velocities[1].x
+        end
+      end
+    end
   end
-end
-
-
-def setup
-  size 400, 400
-  no_stroke
-  frame_rate 30
-  rect_mode RADIUS    
-  @balls = []
-  5.times { @balls << Ball.new(10, PVector.new(2.15, -1.35), *empty_space(15)) }
-  2.times { @balls << Ball.new(40, PVector.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 }
+  def display
+    no_stroke
+    fill(204)
+    ellipse(position.x, position.y, r * 2, r * 2)
   end
   
-  # move the balls 
-  fill 240
-  @balls.each do |ball|
-    ball.move
-    ball.draw
-    check_boundary_collision ball
-  end
-  check_object_collisions
 end
 
+attr_reader :balls
 
-def empty_space(r)
-  x = y = nil
-  while !x || !empty_space?(x, y, r) do
-    x = rand(width)
-    y = rand(height)
-  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 = PVector.new
-      bVect.x = bb.x - ba.x
-      bVect.y = 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 = [PVector.new, PVector.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 = [PVector.new, PVector.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
-      
-      # hack to avoid clumping
-      bTemp[0].x += vFinal[0].x
-      bTemp[1].x += vFinal[1].x
-      
-      # 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
-  
+def setup
+  size 640, 360
+  @balls = [
+        Ball.new(100, 400, 20),
+        Ball.new(100, 100, 20),
+        Ball.new(200, 100, 20),
+        Ball.new(700, 400, 60)
+        ]
 end
 
 
-def check_boundary_collision(ball)
-  unless (ball.r ... width - ball.r).cover? ball.x 
-    ball.vec.x *= -1
-  end
-  unless (ball.r ... height - ball.r).cover? ball.y 
-    ball.vec.y *= -1
+def draw
+  background(51)  
+  balls.each do |b| 
+    b.update
+    b.display
+    b.check_boundary width, height
+    b.check_collision(balls)
   end
 end
 

data/samples/processing_app/topics/motion/library/cube/cube.rb

@@ -111,7 +111,7 @@ Boundary = Struct.new(:lower, :upper) do
 end
 
 # Leaner meaner substitute for vanilla processings
-# PVector class, provides only functionality we need
+# PVector class, provides only the functionality we need
 #
 Vect = Struct.new(:x, :y, :z) do
 

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

@@ -1,6 +1,6 @@
 #
 # Morph. 
-# 
+# see vecmath library for a variant using Vec2D instead of PVector 
 # Changing one shape into another by interpolating
 # vertices from one to another
 #

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

@@ -6,6 +6,7 @@
 # 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 
@@ -15,14 +16,14 @@ def setup
   @radius = 6
   @speed = 3.5
   fill(128)
-  @base1 = PVector.new(0, height - 150)
-  @base2 = PVector.new(width, height)
+  @base1 = Vec2D.new(0, height - 150)
+  @base2 = Vec2D.new(width, height)
   @coords = create_ground
   # start ellipse at middle top of screen
-  @position = PVector.new(width/2, 0)  
+  @position = Vec2D.new(width/2, 0)  
   # set initial random direction
-  @direction = PVector.random2D
-  @velocity = PVector.new
+  @direction = Vec2D.new(rand(-1.0 .. 1), rand(-1.0 .. 1))
+  @velocity = Vec2D.new
 end
 
 def draw
@@ -36,34 +37,34 @@ def draw
   quad(base1.x, base1.y, base2.x, base2.y, base2.x, height, 0, height)
   
   # calculate base top normal
-  base_delta = PVector.sub(base2, base1)
-  base_delta.normalize
-  normal = PVector.new(-base_delta.y, base_delta.x)  
+  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.set(direction)
-  @velocity.mult(speed)
+  @velocity.x, @velocity.y = direction.x, direction.y
+  @velocity *= speed
   
   # move ellipse
-  @position.add(velocity)
+  @position += velocity
   
   # normalized incidence vector
-  @incidence = PVector.mult(direction, -1)
+  @incidence = direction * -1
   
   # detect and handle collision
   coords.each do |coord|
     # check distance between ellipse and base top coordinates
-    if (PVector.dist(position, coord) < radius)
+    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.set(2*normal.x*dot - incidence.x, 2*normal.y*dot - incidence.y, 0)      
+      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)
@@ -94,11 +95,11 @@ end
 
 def create_ground
   # calculate length of base top
-  @base_length = PVector.dist(base1, base2)
+  @base_length = Vec2D.dist(base1, base2)
   # fill base top coordinate array
   coords = []
   (0 ... base_length.ceil).each do |i|
-     coords << PVector.new(
+     coords << Vec2D.new(
      base1.x + ((base2.x - base1.x) / base_length) * i,
      base1.y + ((base2.y - base1.y) / base_length) * i)
   end

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

@@ -1,7 +1,7 @@
 # GLSL version of Conway's game of life, ported from GLSL sandbox:
 # http://glsl.heroku.com/e/207.3
-# Exemplifies the use of the buffer uniform in the shader, that gives
-# access to the previous frame.
+# 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

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

@@ -9,7 +9,7 @@ precision highp float;
 uniform float time;
 uniform vec2 mouse;
 uniform vec2 resolution;
-uniform sampler2D buffer;
+uniform sampler2D ppixels;
 
 vec4 live = vec4(0.5,1.0,0.7,1.);
 vec4 dead = vec4(0.,0.,0.,1.);
@@ -28,15 +28,15 @@ void main( void ) {
 		}
 	} else {
 		float sum = 0.;
-		sum += texture2D(buffer, position + pixel * vec2(-1., -1.)).g;
-		sum += texture2D(buffer, position + pixel * vec2(-1., 0.)).g;
-		sum += texture2D(buffer, position + pixel * vec2(-1., 1.)).g;
-		sum += texture2D(buffer, position + pixel * vec2(1., -1.)).g;
-		sum += texture2D(buffer, position + pixel * vec2(1., 0.)).g;
-		sum += texture2D(buffer, position + pixel * vec2(1., 1.)).g;
-		sum += texture2D(buffer, position + pixel * vec2(0., -1.)).g;
-		sum += texture2D(buffer, position + pixel * vec2(0., 1.)).g;
-		vec4 me = texture2D(buffer, position);
+		sum += texture2D(ppixels, position + pixel * vec2(-1., -1.)).g;
+		sum += texture2D(ppixels, position + pixel * vec2(-1., 0.)).g;
+		sum += texture2D(ppixels, position + pixel * vec2(-1., 1.)).g;
+		sum += texture2D(ppixels, position + pixel * vec2(1., -1.)).g;
+		sum += texture2D(ppixels, position + pixel * vec2(1., 0.)).g;
+		sum += texture2D(ppixels, position + pixel * vec2(1., 1.)).g;
+		sum += texture2D(ppixels, position + pixel * vec2(0., -1.)).g;
+		sum += texture2D(ppixels, position + pixel * vec2(0., 1.)).g;
+		vec4 me = texture2D(ppixels, position);
 
 		if (me.g <= 0.1) {
 			if ((sum >= 2.9) && (sum <= 3.1)) {

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

@@ -11,6 +11,7 @@
 # 
 # Photographs by Folkert Gorter (@folkertgorter / http://superfamous.com/) made available under a CC Attribution 3.0 license.
 #
+load_library :vecmath
 
 DIM = 300 # the grid dimensions of the heightmap
 attr_reader :blur_factor # the blur for the displacement map (to make it smoother)
@@ -78,16 +79,16 @@ def create_plane(xsegs, ysegs)
       v = y / ysegs.to_f
 
       # generate positions for the vertices of each cell (-0.5 to center the shape around the origin)
-      positions << PVector.new(u - 0.5, v - 0.5, 0)
-      positions << PVector.new(u + usegsize - 0.5, v - 0.5, 0)
-      positions << PVector.new(u + usegsize - 0.5, v + vsegsize - 0.5, 0)
-      positions << PVector.new(u - 0.5, v +  vsegsize - 0.5, 0)
+      positions << Vec3D.new(u - 0.5, v - 0.5, 0)
+      positions << Vec3D.new(u + usegsize - 0.5, v - 0.5, 0)
+      positions << Vec3D.new(u + usegsize - 0.5, v + vsegsize - 0.5, 0)
+      positions << Vec3D.new(u - 0.5, v +  vsegsize - 0.5, 0)
 
       # generate texture coordinates for the vertices of each cell
-      tex_coords << PVector.new(u, v)
-      tex_coords << PVector.new(u + usegsize, v)
-      tex_coords << PVector.new(u + usegsize, v + vsegsize)
-      tex_coords << PVector.new(u, v + vsegsize)
+      tex_coords << Vec2D.new(u, v)
+      tex_coords << Vec2D.new(u + usegsize, v)
+      tex_coords << Vec2D.new(u + usegsize, v + vsegsize)
+      tex_coords << Vec2D.new(u, v + vsegsize)
     end
   end