ruby-processing 1.0.11 → 2.4.1

data/samples/processing_app/topics/lsystems/three_d_tree.rb

@@ -0,0 +1,108 @@
+########################################################
+# A 3D plant implemented using a
+# Lindenmayer System in ruby-processing by Martin Prout
+########################################################
+
+load_libraries :stochastic_grammar, :control_panel
+attr_reader :plant, :zoom, :rot_y, :panel
+
+def setup() 
+  size(800, 800, P3D)
+  camera(400.0, 500.0, 200.0, 0.0, -160.0, 0.0, 
+       0.0, 1.0, 0.0)
+  setup_panel
+  @plant = Plant.new
+  plant.create_grammar(5)
+  no_stroke()
+  @rot_y = 0
+end
+
+
+def setup_panel
+  control_panel do |c|
+    c.title = "Control:"
+    c.slider :zoom, 1..8, 3
+    c.slider :rot_y, -PI..PI, 0
+    c.button :reset
+    @panel = c
+  end
+end
+
+def reset
+  @rot_y = 0
+  @zoom = 1     
+end
+
+def draw() 
+  panel.set_visible true if self.visible
+  background(0) 
+  rotate_y rot_y
+  scale zoom
+  ambient_light(0, 255, 0)
+  directional_light(0, 255, 0, 0.0, -1.0, 0.0)
+  plant.render
+end
+
+
+############################
+# plant.rb
+###########################
+class Plant
+  include Processing::Proxy
+  
+  attr_reader :grammar, :axiom, :production, :premis, :rule, 
+  :theta, :scale_factor, :distance, :phi
+  
+  def initialize() 
+    @axiom = "F"
+    @grammar = StochasticGrammar.new(axiom)
+    @production = axiom
+    @premis = "F"
+    @rule = "F[&+F]F[->F][->F][&F]"
+    @scale_factor = 0.8
+    @distance = 8
+    @theta = radians(28)
+    @phi = radians(28) 
+    grammar.add_rule(premis, rule)
+    no_stroke()
+  end
+  
+  def render() 
+    production.each_char do |ch|
+      case(ch)
+      when "F"     
+        fill(0, 200, 0)
+        translate(0, distance/-2, 0)
+        box(distance/4 , distance, distance/4)
+        translate(0, distance/-2, 0)
+      when "-"
+        rotateX(-theta)
+      when "+"
+        rotateX(theta)
+      when "&"
+        rotateY(-phi % TWO_PI)
+      when ">"
+        rotateZ(phi % TWO_PI)
+      when "<"
+        rotateZ(-phi)
+      when "["
+        push_matrix
+        @distance = distance * scale_factor
+      when "]"
+        pop_matrix
+        @distance = distance / scale_factor
+      else
+        puts("character '#{ch}' not in grammar")
+      end
+    end
+  end
+
+  ##############################
+  # create grammar from axiom and
+  # rules (adjust scale)
+  ##############################
+  
+  def create_grammar(gen)
+    @production = @grammar.generate gen
+  end
+end

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

@@ -0,0 +1,40 @@
+#
+# Bounce. 
+# 
+# When the shape hits the edge of the window, it reverses its direction. 
+#
+
+RAD = 60       # Width of the shape
+X_SPEED = 2.8  # Speed of the shape
+Y_SPEED = 2.2  # Speed of the shape
+
+attr_reader :xpos, :ypos, :xdirection, :ydirection
+
+def setup 
+  size(640, 360)
+  no_stroke
+  frame_rate(30)
+  ellipse_mode(RADIUS)
+  # Set the starting position of the shape
+  @xpos = width/2
+  @ypos = height/2
+  @xdirection = 1  # Left or Right
+  @ydirection = 1  # Top to Bottom
+end
+
+def draw 
+  background(102)  
+  # Update the position of the shape
+  @xpos = xpos + ( X_SPEED * xdirection )
+  @ypos = ypos + ( Y_SPEED * ydirection )  
+  # Test to see if the shape exceeds the boundaries of the screen
+  # If it does, reverse its direction by multiplying by -1
+  unless (RAD ... width - RAD).cover? xpos 
+    @xdirection *= -1
+  end
+  unless (RAD ... height - RAD).cover? ypos 
+    @ydirection *= -1
+  end  
+  # Draw the shape
+  ellipse(xpos, ypos, RAD, RAD)
+end

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

@@ -0,0 +1,96 @@
+#
+# Bouncy Bubbles  
+# based on code from Keith Peters. 
+# 
+# Multiple-object collision.
+#
+
+SPRING = 0.05
+GRAVITY = 0.03
+FRICTION = -0.9
+NUM_BALLS = 12
+
+attr_reader :balls, :id
+
+def setup
+  size(640, 360)  
+  @balls = []
+  (0 ... NUM_BALLS).each do |i|
+    balls << Ball.new(rand(width), rand(height), rand(30 .. 70), i, balls)
+  end
+  noStroke
+  fill(255, 204)
+end
+
+def draw
+  background(0)
+  (0 ... NUM_BALLS).each do |i| 
+    balls[i].collide 
+    balls[i].move 
+    balls[i].display
+  end
+end
+
+class Ball
+  attr_accessor :vx, :vy
+  attr_reader :x, :y, :diameter, :others, :id, :width, :height
+  
+  def initialize(xin, yin, din, idin, oin)
+    @x = xin
+    @y = yin
+    @diameter = din
+    @id = idin
+    @vx = 0
+    @vy = 0
+    @others = oin
+    @width = $app.width
+    @height = $app.height
+  end 
+  
+  def collide
+    ((id + 1) ... NUM_BALLS).each do |i|
+      dx = others[i].x - x
+      dy = others[i].y - y
+      sq_dist = dx*dx + dy*dy
+      min_dist = (others[i].diameter/2 + diameter/2)
+      sq_min_dist = min_dist * min_dist
+      if (sq_dist < sq_min_dist)  
+        angle = atan2(dy, dx)
+        target_x = x + cos(angle) * min_dist
+        target_y = y + sin(angle) * min_dist
+        ax = (target_x- others[i].x) * SPRING
+        ay = (target_y - others[i].y) * SPRING
+        @vx -= ax
+        @vy -= ay
+        others[i].vx += ax
+        others[i].vy += ay
+      end
+      
+    end
+    
+    def move
+      @vy += GRAVITY
+      @x += vx
+      @y += vy
+      if (x + diameter/2 > width)
+        @x = width - diameter/2
+        @vx *= FRICTION         
+      elsif (x - diameter/2 < 0)
+        @x = diameter/2
+        @vx *= FRICTION
+      end
+      
+      if (y + diameter/2 > height)
+        @y = height - diameter/2
+        @vy *= FRICTION 
+      elsif (y - diameter/2 < 0)
+        @y = diameter/2
+        @vy *= FRICTION
+      end
+    end
+    
+    def display
+      ellipse(x, y, diameter, diameter)
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+#
+# Brownian motion. 
+# 
+# Recording random movement as a continuous line. 
+#
+
+NUM = 2000
+RANGE = 6
+
+attr_accessor :ax, :ay 
+
+def setup   
+  size(640, 360)
+  @ax = Array.new(NUM, width/2)
+  @ay = Array.new(NUM, height/2)
+  frame_rate(30)
+end
+
+def draw   
+  background(51)  
+  # Shift all elements 1 place to the left
+  (1 ... NUM).each do |i|
+    ax[i-1] = ax[i]
+    ay[i-1] = ay[i]
+  end  
+  # Put a new value at the end of the array
+  ax[NUM-1] += rand(-RANGE .. RANGE)
+  ay[NUM-1] += rand(-RANGE .. RANGE)
+  
+  # Constrain all points to the screen
+  ax[NUM-1] = constrain(ax[NUM-1], 0, width)
+  ay[NUM-1] = constrain(ay[NUM-1], 0, height)
+  
+  # Draw a line connecting the points
+  (1 ... NUM).each do |i|
+    val = i.to_f / NUM * 204.0 + 51
+    stroke(val)
+    line(ax[i-1], ay[i-1], ax[i], ay[i])
+  end
+end

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

@@ -0,0 +1,185 @@
+# Based on http://processing.org/learning/topics/circlecollision.html
+# by Joe Holt
+
+
+
+# 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, 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 }
+  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)
+    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
+  
+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
+  end
+end
+
+