ruby-processing 1.0.11 → 2.4.1

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

@@ -0,0 +1,2 @@
+-Xmn128m -Xms256m -Xmx256m -Djruby.ji.objectProxyCache=false -XX:CompileCommand=dontinline,org.jruby.runtime.invokedynamic.InvokeDynamicSupport::invocationFallback -XX:+OptimizeStringConcat 
+

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

@@ -0,0 +1,111 @@
+# Drawolver: draw 2D & revolve 3D
+
+# Example to show how to use the VecMath library.
+# Also the Array is extended to yield one_of_each 
+# pair of pts. See the drawolver library. Also features the use each_cons, 
+# possibly a rare use for this ruby Enumerable method?
+# 2010-03-22 - fjenett (last revised by monkstone 2013-09-13)
+load_library :vecmath
+import 'vecmath'
+attr_reader :drawing_mode, :points, :rot_x, :rot_y, :vertices
+
+module ExtendedArray
+  # send one item from each array, expects array to be 2D:
+  # array [[1,2,3], [a,b,c]] sends
+  # [1,a] , [2,b] , [3,c]
+  def one_of_each( &block )
+    i = 0
+    one = self[0]
+    two = self[1]
+    mi = one.length > two.length ? two.length : one.length
+    while i < mi do
+      yield( one[i], two[i] )
+      i += 1
+    end
+  end
+end
+
+
+def setup 
+  size 1024, 768, P3D
+  frame_rate 30 
+  reset_scene
+end
+
+def draw  
+  background 0    
+  if (!drawing_mode)      
+    translate(width/2, height/2)
+    rotate_x rot_x
+    rotate_y rot_y
+    @rot_x += 0.01
+    @rot_y += 0.02
+    translate(-width/2, -height/2)
+  end 
+  no_fill
+  stroke 255
+  points.each_cons(2) { |ps, pe| line ps.x, ps.y, pe.x, pe.y}
+
+  if (!drawing_mode)    
+    stroke 125
+    fill 120
+    lights 
+    ambient_light 120, 120, 120
+    vertices.each_cons(2) do |r1, r2|
+      begin_shape(TRIANGLE_STRIP)
+      ext_array = [r1,r2].extend ExtendedArray # extend an instance of Array
+      ext_array.one_of_each do |v1, v2|          
+        vertex v1.x, v1.y, v1.z
+        vertex v2.x, v2.y, v2.z
+      end
+      end_shape 
+    end
+  end 
+end
+
+def reset_scene 
+  @drawing_mode = true
+  @points = []
+  @rot_x = 0.0
+  @rot_y = 0.0
+end
+
+def mouse_pressed
+  reset_scene
+  points << Vec3D.new(mouse_x, mouse_y)
+end
+
+def mouse_dragged
+  points << Vec3D.new(mouse_x, mouse_y)
+end
+
+def mouse_released
+  points << Vec3D.new(mouse_x, mouse_y)
+  recalculate_shape
+end
+
+def recalculate_shape  
+  @vertices = []
+  points.each_cons(2) do |ps, pe|   
+    b = points.last - points.first
+    len = b.mag
+    b.normalize!   
+    a = ps - points.first   
+    dot = a.dot b   
+    b = b * dot   
+    normal = points.first + b    
+    c = ps - normal
+    nlen = c.mag    
+    vertices << []    
+    (0..TAU).step(PI/15) do |ang|     
+      e = normal + c * cos(ang)
+      e.z = c.mag * sin(ang)      
+      vertices.last << e
+    end
+  end
+  @drawing_mode = false
+end
+
+
+
+

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

@@ -0,0 +1,33 @@
+#
+# Flocking 
+# by Daniel Shiffman.  
+# 
+# An implementation of Craig Reynold's Boids program to simulate
+# the flocking behavior of birds. Each boid steers itself based on 
+# rules of avoidance, alignment, and coherence.
+# 
+# Click the mouse to add a new boid.
+#
+load_library :vecmath # load_library required by flock library 
+load_library :flock
+
+attr_reader :flock
+
+def setup
+  size(640, 360)
+  @flock = Flock.new
+  # Add an initial set of boids into the system
+  150.times do
+    flock << Boid.new(width/2, height/2)
+  end
+end
+
+def draw
+  background(50)
+  flock.run
+end
+
+# Add a new boid into the System
+def mouse_pressed
+  flock << Boid.new(mouse_x, mouse_y)
+end

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

@@ -0,0 +1,65 @@
+########################################################
+# A 3D Hilbert fractal implemented using a
+# Lindenmayer System in ruby-processing by Martin Prout
+# Demonstrates arcball rotation hold down z, y or z key
+# to constrain to that axis of rotation. Otherwise get
+# intuitive rotation with dragged mouse.
+########################################################
+
+load_libraries :hilbert, :vecmath
+import 'vecmath'
+attr_reader :hilbert, :arcball
+
+def setup
+  size 1024, 768, P3D
+  @arcball = ArcBall.new(width/2.0, height/2.0, min(width - 20, height - 20) * 0.5)
+  @hilbert = Hilbert.new(height/2, 3)
+  no_stroke
+end
+
+def draw
+  background 0
+  translate(width/2.0, height/2.0) 
+  update
+  lights
+  define_lights
+  ambient(40)
+  specular(15)
+  hilbert.render
+end
+
+def update
+  theta, x, y, z = arcball.update
+  rotate(theta, x, y, z)
+end
+
+def mouse_pressed
+  arcball.mouse_pressed(mouse_x, mouse_y)
+end
+
+def mouse_dragged
+  arcball.mouse_dragged(mouse_x, mouse_y)
+end
+
+def define_lights
+  ambient(20, 20, 20)
+  ambient_light(60, 60, 60)
+  point_light(30, 30, 30, 0, 0, 0)
+  directional_light(40, 40, 50, 1, 0, 0)
+  spot_light(30, 30, 30, 0, 40, 200, 0, -0.5, 0.5, PI / 2, 2)
+end
+
+def key_pressed                
+  case(key)
+when 'x'
+  arcball.select_axis(X)
+when 'y'
+  arcball.select_axis(Y)
+when 'z'
+  arcball.select_axis(Z)
+end
+end
+
+def key_released
+  arcball.select_axis(-1)
+end

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

@@ -0,0 +1,214 @@
+# The Flock (a list of Boid objects)
+
+class Flock 
+  extend Enumerable
+  
+  attr_reader :boids
+  
+  def initialize
+    @boids = []	  
+  end
+
+  def each &block
+    boids.each &block	  
+  end
+  
+  def << obj
+    boids << obj
+  end
+
+  def run
+    self.each do |bird|
+      bird.run(self)  # Passing the entire list of boids to each boid individually
+    end
+  end
+  
+end
+
+# The Boid class
+
+class Boid
+  include Processing::Proxy
+  import 'vecmath'
+  attr_reader :location, :velocity, :acceleration, :r, :maxforce, :maxspeed
+  
+  def initialize(x, y)
+    @acceleration = Vec2D.new
+    @velocity = Vec2D.new(rand(-1.0 .. 1), rand(-1.0 .. 1))
+    @location = Vec2D.new(x, y)
+    @r = 2.0
+    @maxspeed = 2
+    @maxforce = 0.03
+  end
+  
+  def run(boids)
+    flock(boids)
+    update
+    borders
+    render
+  end
+  
+  def apply_force(force)
+    # We could add mass here if we want A = F / M
+    @acceleration += force
+  end
+  
+  # We accumulate a new acceleration each time based on three rules
+  def flock boids
+    sep = separate(boids)   # Separation
+    ali = align(boids)      # Alignment
+    coh = cohesion(boids)   # Cohesion
+    # Arbitrarily weight these forces
+    sep *= 1.5
+    ali *= 1.0
+    coh *= 1.0
+    # Add the force vectors to acceleration
+    apply_force(sep)
+    apply_force(ali)
+    apply_force(coh)
+  end
+  
+  # Method to update location
+  def update
+    # Update velocity
+    @velocity += acceleration
+    # Limit speed
+    if velocity.mag_squared > maxspeed**2
+      velocity.set_mag(maxspeed)
+    end
+    @location += velocity
+    # Reset accelertion to 0 each cycle
+    @acceleration *= 0
+  end
+  
+  # A method that calculates and applies a steering force towards a target
+  # STEER = DESIRED MINUS VELOCITY
+  def seek(target)
+    desired = target - location  # A vector pointing from the location to the target
+    # Normalize desired and scale to maximum speed
+    desired.normalize!
+    desired *= maxspeed
+    # Steering = Desired minus Velocity
+    steer = desired - velocity
+    if steer.mag_squared > maxforce**2 # Limit to maximum steering force
+      steer.set_mag(maxforce)
+    end  
+    return steer
+  end
+
+  def render
+    # Draw a triangle rotated in the direction of velocity
+    theta = velocity.heading + Math::PI/2.0
+    fill(200,100)
+    stroke(255)
+    push_matrix
+    translate(location.x,location.y)
+    rotate(theta)
+    begin_shape(TRIANGLES)
+    vertex(0, -r*2)
+    vertex(-r, r*2)
+    vertex(r, r*2)
+    end_shape
+    pop_matrix
+  end
+
+  # Wraparound
+  def borders
+    if (location.x < -r) 
+      location.x = $app.width+r
+    end
+    if (location.y < -r) 
+      location.y = $app.height+r
+    end
+    if (location.x > $app.width+r)
+      location.x = -r
+    end
+    if (location.y > $app.height+r)
+      location.y = -r
+    end
+  end
+          
+  # Separation
+  # Method checks for nearby boids and steers away
+  def separate boids
+    desiredseparation = 25.0
+    steer = Vec2D.new
+    count = 0
+    # For every boid in the system, check if it's too close
+    boids.each do |other|
+      d = Vec2D.dist(location, other.location)
+      # If the distance is greater than 0 and less than an arbitrary amount (0 when you are yourself)
+      if ((d > 0) && (d < desiredseparation))
+        # Calculate vector pointing away from neighbor
+        diff = location - other.location
+        diff.normalize!
+        diff /= d        # Weight by distance
+        steer += diff
+        count += 1            # Keep track of how many
+      end
+    end
+    # Average -- divide by how many
+    if (count > 0)
+      steer /= count.to_f
+    end
+    
+    # As long as the vector is greater than 0
+    if (steer.mag > 0)
+      # Implement Reynolds: Steering = Desired - Velocity
+      steer.normalize!
+      steer *= maxspeed
+      steer -= velocity
+      if steer.mag_squared > maxforce**2
+        steer.set_mag(maxforce)
+      end
+    end
+    return steer
+  end
+    
+  # Alignment
+  # For every nearby boid in the system, calculate the average velocity
+  def align boids
+    neighbordist = 50
+    sum = Vec2D.new
+    count = 0
+    boids.each do |other|
+      d = Vec2D.dist(location, other.location)
+      if ((d > 0) && (d < neighbordist))
+        sum += other.velocity
+        count += 1
+      end
+    end
+    if (count > 0)
+      sum /= count.to_f
+      sum.normalize!
+      sum *= maxspeed
+      steer = sum - velocity
+      if steer.mag_squared > maxforce**2
+        steer.set_mag(maxforce)
+      end
+      return steer
+    else
+      return Vec2D.new
+    end
+  end
+    
+  # Cohesion
+  # For the average location (i.e. center) of all nearby boids, calculate steering vector towards that location
+  def cohesion boids
+    neighbordist = 50
+    sum = Vec2D.new   # Start with empty vector to accumulate all locations
+    count = 0
+    boids.each do |other|
+      d = Vec2D.dist(location, other.location)
+      if ((d > 0) && (d < neighbordist))
+        sum += other.location # Add location
+        count += 1
+      end
+    end
+    sum /= count unless (count == 0)        # avoid div by zero
+    return (count > 0)? seek(sum) : Vec2D.new 
+  end
+end
+
+
+

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

@@ -0,0 +1,84 @@
+############################
+# Simple lsystem grammar
+############################
+class Grammar
+  def initialize(axiom, rules)
+    @axiom = axiom
+    @rules = rules
+  end
+
+  def expand(production, iterations, &block)
+    production.each_char do |token|
+      if @rules.has_key?(token) && iterations > 0 
+        expand(@rules[token], iterations - 1, &block)
+      else
+        yield token
+      end
+    end
+  end
+
+  def each gen
+    expand(@axiom, gen) {|token| yield token }
+  end
+
+  def generate gen
+    output = []
+    each(gen) { |token| output << token }
+    output
+  end
+
+end
+
+
+############################
+# Hilbert Curves
+###########################
+class Hilbert
+  include Processing::Proxy
+  ADJUSTMENT = [0,  0.5,  1.5,  3.5,  7.5, 15]
+  attr_reader :grammar, :axiom, :production, :premis, :rule,
+  :theta, :distance, :phi, :gen
+
+  def initialize(len, gen = 1)
+    @axiom = "X"                                           # AXIOM
+    @rule = {"X" => "^<XF^<XFX-F^>>XFX&F+>>XFX-F>X->"}     # RULE
+    @gen = gen
+    @grammar = Grammar.new(axiom, rule) 
+    @production = grammar.generate gen
+    @distance = len/(pow(2, gen) - 1)
+    @theta = Math::PI/180 * 90
+    @phi = Math::PI/180 * 90  
+  end
+
+  def render()    
+    translate( -distance * ADJUSTMENT[gen], distance *  ADJUSTMENT[gen], -distance * ADJUSTMENT[gen])
+    fill(0, 75, 152)
+    light_specular(204, 204, 204)
+    specular(255, 255, 255)
+    shininess(1.0)
+    production.each do |ch|
+      case(ch)
+      when "F"
+        translate(0, distance/-2, 0)
+        box(distance/9 , distance, distance/9)
+        translate(0, distance/-2, 0)
+      when "+"
+        rotateX(-theta)
+      when "-"
+        rotateX(theta)
+      when ">"
+        rotateY(theta)
+      when "<"
+        rotateY(-theta)
+      when "&"
+        rotateZ(-phi)
+      when "^"
+        rotateZ(phi)
+      when "X"
+      else
+        puts("character '#{ch}' not in grammar")
+      end
+    end
+  end
+
+end