ruby-processing 2.4.3 → 2.4.4

data/samples/contributed/drawolver.rb

@@ -1,33 +1,17 @@
 # Drawolver: draw 2D & revolve 3D
 
-# This example demonstrates the use of the `vecmath` library (a ruby-processing 
-# replacement for PVector). Also demonstrated is how to extend an instance of a
-# here an instance of a core ruby class. In this case the ruby Array class,  
-# is extended to yield one_of_each pair of pts (see ExtendedArray module). This
-# examples also includes a possibly rare use of the each_cons Enumerable method?
-# For simpler illustrations of `vecmath` usage see the library examples.
-# 2010-03-22 - fjenett (last revised by monkstone 2014-02-18)
+# Example to show how to use the VecMath library.
+# ruby replacement for PVector. Also features 
+# the use each_cons, possibly a rare use for this 
+# ruby Enumerable method?
+# 2010-03-22 - fjenett (last revised by monkstone 2014-03-21)
+# now uses 'zip' and 'each', in place of a custom Array object
+# with a 'one_of_each' method
 
 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 
@@ -55,8 +39,7 @@ def draw
     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|          
+      r1.zip(r2).each do |v1, v2|
         vertex v1.x, v1.y, v1.z
         vertex v2.x, v2.y, v2.z
       end
@@ -94,7 +77,7 @@ def recalculate_shape
     b.normalize!   
     a = ps - points.first   
     dot = a.dot b   
-    b *= dot   
+    b = b * dot   
     normal = points.first + b    
     c = ps - normal
     # nlen = c.mag    
@@ -108,3 +91,6 @@ def recalculate_shape
   @drawing_mode = false
 end
 
+
+
+

data/samples/contributed/elegant_ball.rb

@@ -0,0 +1,158 @@
+# elegant_ball.rb
+# After a vanilla processing sketch by
+# Ben Notorianni aka lazydog
+#
+
+load_library :vecmath
+
+def setup
+  size(800, 800, P3D)
+  color_mode(RGB, 1)
+end
+
+def draw
+  #background(0.25)
+  background(0)
+  # Move the origin so that the scene is centered on the screen.
+  translate(width/2, height/2, 0.0)
+  # Set up the lighting.
+  setup_lights
+  # Rotate the local coordinate system.
+  smooth_rotation(5.0, 6.7, 7.3)
+  # Draw the inner object.
+  no_stroke
+  fill(smooth_colour(10.0, 12.0, 7.0))
+  draw_icosahedron(5, 60.0, false)
+  # Rotate the local coordinate system again.
+  smooth_rotation(4.5, 3.7, 7.3)
+  # Draw the outer object.
+  stroke(0.2)
+  fill(smooth_colour(6.0, 9.2, 0.7))
+  draw_icosahedron(5, 200.0, true)
+end
+
+def setup_lights
+  ambient_light(0.025, 0.025, 0.025)
+  directional_light(0.2, 0.2, 0.2, -1, -1, -1)
+  spot_light(1.0, 1.0, 1.0, -200, 0, 300, 1, 0, -1, PI/4, 20)
+end
+
+##
+# Generate a vector whose components change smoothly over time in the range [ 0, 1 ].
+# Each component uses a Math.sin function to map the current time in milliseconds somewhere
+# in the range [ 0, 1 ].A 'speed' factor is specified for each component.
+#
+def smooth_vector(s1, s2, s3)
+  mills = millis * 0.00003
+  rot = ->(a){0.5 * Math.sin(mills * a) + 0.5}
+  Vec3D.new(rot.call(s1), rot.call(s2), rot.call(s3))
+end
+
+##
+# Generate a colour which smoothly changes over time.
+# The speed of each component is controlled by the parameters s1, s2 and s3.
+#
+def smooth_colour(s1, s2, s3)
+  v = smooth_vector(s1, s2, s3)
+  color(v.x, v.y, v.z)
+end
+
+##
+# Rotate the current coordinate system.
+# Uses smooth_vector to smoothly animate the rotation.
+#
+def smooth_rotation(s1, s2, s3)
+  r1 = smooth_vector(s1, s2, s3)
+  rotate_x(2.0 * PI * r1.x)
+  rotate_y(2.0 * PI * r1.y)
+  rotate_x(2.0 * PI * r1.z)
+end
+
+##
+# Draw an icosahedron defined by a radius r and recursive depth d.
+# Geometry data will be saved into dst. If spherical is true then the icosahedron
+# is projected onto the sphere with radius r.
+#
+def draw_icosahedron(depth, r, spherical)
+  # Calculate the vertex data for an icosahedron inscribed by a sphere radius 'r'.
+  # Use 4 Golden Ratio rectangles as the basis.
+  gr = (1.0 + Math.sqrt(5.0)) / 2.0
+  h = r / Math.sqrt(1.0 + gr * gr)
+  v =
+    [
+  Vec3D.new(0, -h, h*gr), Vec3D.new(0, -h, -h*gr), Vec3D.new(0, h, -h*gr), Vec3D.new(0, h, h*gr),
+  Vec3D.new(h, -h*gr, 0), Vec3D.new(h, h*gr, 0), Vec3D.new(-h, h*gr, 0), Vec3D.new(-h, -h*gr, 0),
+  Vec3D.new(-h*gr, 0, h), Vec3D.new(-h*gr, 0, -h), Vec3D.new(h*gr, 0, -h), Vec3D.new(h*gr, 0, h)
+  ]
+  
+  # Draw the 20 triangular faces of the icosahedron.
+  unless spherical then
+    r = 0.0
+  end
+  
+  begin_shape(TRIANGLES)
+    
+  draw_triangle(depth, r, v[0], v[7],v[4])
+  draw_triangle(depth, r, v[0], v[4], v[11])
+  draw_triangle(depth, r, v[0], v[11], v[3])
+  draw_triangle(depth, r, v[0], v[3], v[8])
+  draw_triangle(depth, r, v[0], v[8], v[7])
+  
+  draw_triangle(depth, r, v[1], v[4], v[7])
+  draw_triangle(depth, r, v[1], v[10], v[4])
+  draw_triangle(depth, r, v[10], v[11], v[4])
+  draw_triangle(depth, r, v[11], v[5], v[10])
+  draw_triangle(depth, r, v[5], v[3], v[11])
+  draw_triangle(depth, r, v[3], v[6], v[5])
+  draw_triangle(depth, r, v[6], v[8], v[3])
+  draw_triangle(depth, r, v[8], v[9], v[6])
+  draw_triangle(depth, r, v[9], v[7], v[8])
+  draw_triangle(depth, r, v[7], v[1], v[9])
+  
+  draw_triangle(depth, r, v[2], v[1], v[9])
+  draw_triangle(depth, r, v[2], v[10], v[1])
+  draw_triangle(depth, r, v[2], v[5], v[10])
+  draw_triangle(depth, r, v[2], v[6], v[5])
+  draw_triangle(depth, r, v[2], v[9], v[6])
+  
+  end_shape
+end
+
+##
+# Draw a triangle either immediately or subdivide it first.
+# If depth is 1 then draw the triangle otherwise subdivide first.
+#
+def draw_triangle(depth, r, p1, p2, p3)
+  
+  if (depth == 1) then
+    vertex(p1.x, p1.y, p1.z)
+    vertex(p2.x, p2.y, p2.z)
+    vertex(p3.x, p3.y, p3.z)
+  else
+    # Calculate the mid points of this triangle.
+    v1 = (p1 + p2) * 0.5
+    v2 = (p2 + p3) * 0.5
+    v3 = (p3 + p1) * 0.5
+    unless (r == 0.0) then
+      # Project the verticies out onto the sphere with radius r.
+      v1.normalize!
+      v1 *= r
+      v2.normalize!
+      v2 *= r
+      v3.normalize!
+      v3 *= r
+    end
+    ## Generate the next level of detail
+    depth -= 1
+    draw_triangle(depth, r, p1, v1, v3)
+    draw_triangle(depth, r, v1, p2, v2)
+    draw_triangle(depth, r, v2, p3, v3)
+    # Uncomment out the next line to include the central part of the triangle.
+    # draw_triangle(depth, r, v1, v2, v3)
+  end
+  
+end
+
+
+
+

data/samples/contributed/fern.rb

@@ -1,8 +1,11 @@
 # The Fern Fractal
 # by Luis Correia
+
+attr_reader :boundary
   
 def setup
   size 500, 500
+  @boundary = Boundary.new(0, width )
   no_loop
   puts "Be patient. This takes about 10 seconds to render."
 end
@@ -16,7 +19,7 @@ def draw
   max_iterations = 200000
   
   max_iterations.times do
-    r = rand(100.0)
+    r = rand(0 .. 100.0)
     if r <= 1
       x = 0.0
       y = 0.16 * y0
@@ -33,9 +36,19 @@ def draw
     
     i = height - (y * 45).to_i
     j = width / 2 + (x * 45).to_i
-    pixels[i * height + j] += 2560 if (i >=0 && i < height && j >= 0 && j < width)
+    pixels[i * height + j] += 2560 if (boundary.include?(i) && boundary.include?(j))
     x0, y0 = x, y
   end
   
   update_pixels
-end
+end
+
+# Abstract boundary checking to this
+# lightweight class
+#
+  
+Boundary = Struct.new(:lower, :upper) do
+  def include? x
+    (lower ... upper).cover? x
+  end
+end

data/samples/contributed/flight_patterns.rb

@@ -29,9 +29,6 @@ end
 
 def draw
   background 0.05
-  ambient_light 0.01, 0.01, 0.01
-  light_specular 0.4, 0.2, 0.2
-  point_light 1.0, 1.0, 1.0, mouse_x, mouse_y, width / 4.0
   @flocks.each_with_index do |flock, i|
     flock.goal mouse_x, mouse_y, 0, @flee
     flock.update(goal: 185, limit: 13.5)
@@ -44,8 +41,23 @@ def draw
       end
       push_matrix
       translate boid.x-r/2, boid.y-r/2, boid.z-r/2
-      @click ? sphere(r/2) : oval(0, 0, r, r)
+      if @click
+        lights_on
+        hint ENABLE_DEPTH_TEST
+        sphere(r/2) 
+      else
+        no_lights
+        hint DISABLE_DEPTH_TEST
+        oval(0, 0, r, r)
+      end
       pop_matrix
     end
   end
 end
+
+def lights_on
+  lights
+  ambient_light 0.01, 0.01, 0.01
+  light_specular 0.4, 0.2, 0.2
+  point_light 1.0, 1.0, 1.0, mouse_x, mouse_y, width / 4.0
+end

data/samples/external_library/java_processing/{pbox2d → box2d_processing}/bumpy_surface_noise.rb

@@ -1,12 +1,11 @@
 # The Nature of Code
-# <http:#www.shiffman.net/teaching/nature>
+# <http://www.shiffman.net/teaching/nature>
 # Spring 2010
 # PBox2D example
 
 # An uneven surface
 
-load_library :pbox2d
-load_library :surface
+load_libraries :box2d_processing, :surface
 
 include SB
 
@@ -17,7 +16,7 @@ def setup
   smooth
   
   # Initialize box2d physics and create the world
-  @box2d = PBox2D.new(self)
+  @box2d = SB::Box2DProcessing.new(self)
   box2d.create_world
   # We are setting a custom gravity
   box2d.set_gravity(0, -20)
@@ -46,11 +45,7 @@ def draw
   end  
   # Particles that leave the screen, we delete them
   # (note they have to be deleted from both the box2d world and our list
-  particles.each_with_index do |p, i|
-    if (p.done)
-      particles.delete_at(i)
-    end
-  end  
+  particles.reject! {|p| p.done}
   # Just drawing the framerate to see how many particles it can handle
   fill(0)
   text("framerate: #{frame_rate.to_i}", 12, 16)

data/samples/external_library/java_processing/{pbox2d → box2d_processing}/library/custom_shape/custom_shape.rb

@@ -3,7 +3,7 @@ module B2D
   include_package 'org.jbox2d.collision.shapes'
   include_package 'org.jbox2d.common'
   include_package 'org.jbox2d.dynamics'
-  java_import 'pbox2d.PBox2D'
+  include_package 'shiffman.box2d'
   
   
   # The Nature of Code

data/samples/external_library/java_processing/{pbox2d → box2d_processing}/library/particle_system/particle_system.rb

@@ -2,22 +2,22 @@ module PS
   include_package 'org.jbox2d.collision.shapes'
   include_package 'org.jbox2d.common'
   include_package 'org.jbox2d.dynamics'
-  java_import 'pbox2d.PBox2D'
-  
-  
+  include_package 'shiffman.box2d'
+
   # Box2D Particle System
   # <http://www.shiffman.net/teaching/nature>
   # Spring 2010
+  # translated to ruby-processing Martin Prout
   
   # A class to describe a group of Particles
-  # An ArrayList is used to manage the list of Particles 
+  # An Array is used to manage the list of Particles 
   
   class ParticleSystem
     
     attr_reader :particles, :x, :y
     
     def initialize(bd, num, x, y)
-      @particles = []          # Initialize the ArrayList
+      @particles = []          # Initialize the Array
       @x, @y = x, y            # Store the origin point  
       num.times do
         particles << PS::Particle.new(bd, x, y)
@@ -32,11 +32,8 @@ module PS
       # Particles that leave the screen, we delete them
       # (note they have to be deleted from both the box2d world and our list
       
-      particles.each_with_index do |p, i|
-        if (p.done)
-          particles.delete_at(i)
-        end
-      end
+      particles.reject! { |p| p.done}
+      
     end
     
     def add_particles(bd, n)

data/samples/external_library/java_processing/{pbox2d → box2d_processing}/library/surface/surface.rb

@@ -1,5 +1,5 @@
 # The Nature of Code
-# <http:#www.shiffman.net/teaching/nature>
+# <http://www.shiffman.net/teaching/nature>
 # Spring 2010
 # PBox2D example
 
@@ -9,7 +9,7 @@ module SB
   include_package 'org.jbox2d.collision.shapes'
   include_package 'org.jbox2d.common'  
   include_package 'org.jbox2d.dynamics'
-  java_import 'pbox2d.PBox2D'
+  include_package 'shiffman.box2d'
   
   
   

data/samples/external_library/java_processing/{pbox2d → box2d_processing}/liquidy.rb

@@ -1,14 +1,14 @@
 # The Nature of Code
 # <http:#www.shiffman.net/teaching/nature>
 # Spring 2011
-# PBox2D example
+# Updated to use the updated library
+# translated to ruby-processing 2 March 2014 by Martin Prout
+# Box2DProcessing example
 
-# Box2D particle system example
+load_libraries :box2d_processing, :particle_system
 
-load_library :pbox2d
-load_library :particle_system
 
-# module PS is a wrapper for java imports, and Boundary and Particle classes
+# module PS is a wrapper for java packages, and Boundary and Particle classes
 include PS     
 
 attr_reader :box2d, :boundaries, :systems
@@ -17,11 +17,11 @@ def setup
   size(400,300)
   smooth  
   # Initialize box2d physics and create the world
-  @box2d = PBox2D.new(self)
+  @box2d = PS::Box2DProcessing.new(self)
   box2d.create_world  
   # We are setting a custom gravity
   box2d.set_gravity(0, -20)  
-  # Create ArrayLists	
+  # Create Arrays	
   @systems = []
   @boundaries = []  
   # Add a bunch of fixed boundaries

data/samples/external_library/java_processing/{pbox2d → box2d_processing}/polygons.rb

@@ -1,11 +1,10 @@
 # The Nature of Code
 # <http://www.shiffman.net/teaching/nature>
 # Spring 2011
-# PBox2D example
+# Box2DProcessing example
 
 # Basic example of falling rectangles
-load_library :pbox2d
-load_library :custom_shape
+load_libraries :box2d_processing, :custom_shape
 
 # module B2D is a wrapper for java imports, and Boundary and CustomShape classes
 include B2D     
@@ -16,7 +15,7 @@ def setup
   size(640,360)
   smooth  
   # Initialize box2d physics and create the world
-  @box2d = PBox2D.new(self)
+  @box2d = B2D::Box2DProcessing.new(self)
   box2d.create_world
   # We are setting a custom gravity
   box2d.set_gravity(0, -20)  
@@ -46,11 +45,7 @@ def draw
   
   # polygons that leave the screen, we delete them
   # (note they have to be deleted from both the box2d world and our list
-  polygons.each_with_index do |polygon, i|   
-    if polygon.done
-      polygons.delete_at(i)
-    end
-  end
+  polygons.reject! { |p| p.done}
 end
 
 def mouse_pressed