ruby-processing 2.4.4 → 2.5.0

data/samples/contributed/quadraticvertex.rb

@@ -2,8 +2,8 @@
 # Part of a series of articles on Processing 2.
 # Blog post here:
 # http://vormplus.be/blog/article/drawing-shapes-with-quadratic-vertices
-# translated for ruby-processing by Martin Prout 
-# Note how to specify fill and background using hexadecimal string for color, 
+# translated for ruby-processing by Martin Prout
+# Note how to specify fill and background using hexadecimal string for color,
 # this is different from vanilla processing
 #
 
@@ -16,14 +16,14 @@ def setup
   @hide = false
   control_panel do |c|
     c.title = "controller"
-    c.menu(:detail, ['4', '5', '6', '7', '8', '9', '10' ], '7')
+    c.menu(:detail, %w(4 5 6 7 8 9 10), '7')
     c.button :toggle_debug
     c.button :save_image
     @panel = c
   end
-  
+
   @debug = false
-  @save_one = false  
+  @save_one = false
   smooth 8
 end
 
@@ -33,45 +33,45 @@ def draw
     @hide = true
   end
   background color('#BDF018')
-  translate width / 2, height / 2 
-  @step_angle = TWO_PI / (detail.to_i - 1)
+  translate width / 2, height / 2
+  @step_angle = TAU / (detail.to_i - 1)
   fill color('#ffffff')
   no_stroke
   @cr = map(mouse_x, 0, width, 20, 200)
   begin_shape
-  detail.to_i.times do |i|  
-    if (i == 0) 
-      vertex cos_x(i), sin_y(i) 
-    else 
+  detail.to_i.times do |i|
+    if (i == 0)
+      vertex cos_x(i), sin_y(i)
+    else
       quadratic_vertex cos_cx(i), sin_cy(i), cos_x(i), sin_y(i)
     end
   end
   end_shape(CLOSE)
-  
-  if (debug)    
+
+  if (debug)
     # draw lines between points
     stroke_weight(1)
     no_fill
     stroke(0)
-    
+
     begin_shape
-    detail.to_i.times do |i|          
-      vertex cos_cx(i), sin_cy(i) unless i == 0          
-      vertex cos_x(i), sin_y(i) 
+    detail.to_i.times do |i|
+      vertex cos_cx(i), sin_cy(i) unless i == 0
+      vertex cos_x(i), sin_y(i)
     end
     end_shape CLOSE
-    
+
     # draw points
-    stroke_weight 8    
-    detail.to_i.times do |i|  
-      stroke 0 
-      point cos_x(i), sin_y(i)      
-      stroke 255, 0, 0 
-      point cos_cx(i), sin_cy(i) 
+    stroke_weight 8
+    detail.to_i.times do |i|
+      stroke 0
+      point cos_x(i), sin_y(i)
+      stroke 255, 0, 0
+      point cos_cx(i), sin_cy(i)
     end
   end
-  
-  if (save_one) 
+
+  if save_one
     save_frame("images/quadraticvertex-#####.png")
     @save_one = false
   end

data/samples/external_library/java_processing/custom/landscape.rb

@@ -23,7 +23,9 @@ class Landscape
   def calculate(nn)
     val = ->(curr, nn, x, y){curr * 0.95 + 0.05 *  (nn.feed_forward([x, y]) * 280.0 - 140.0)} 
     @z = (0 ... cols).map{|i|
-      (0 ... rows).map{|j| val.call(z[i][j], nn, i * 1.0/ cols, j * 1.0/cols)}      
+      (0 ... rows).map{|j| 
+        val.call(z[i][j], nn, i * 1.0/ cols, j * 1.0/cols)
+      }      
     }   
   end
   
@@ -49,10 +51,10 @@ class Landscape
           vertex(scl, scl, z[x+1][y+1])
           fill(z[x][y+1]+127, 220)
           vertex(0, scl, z[x][y+1])
-        end_shape
-        pop_matrix
+          end_shape
+          pop_matrix
+        end
       end
     end
   end
-end
 

data/samples/external_library/java_processing/hemesh/twin_iso.rb

@@ -1,71 +1,69 @@
-load_libraries :hemesh, :vbo
-
-include MS # module MS imports necessary java classes and contains ruby MeshToVBO class
-
-RES = 20
-
-attr_reader :mesh_ret, :inv_mesh_ret, :render
-
-def setup
-  size(800, 800, P3D)
-  smooth(8)
-  values = []               # build a multi-dimensional array in ruby
-  (0 .. RES).each do |i|    # the inclusive range is intentional here
-    valu = []
-    (0 .. RES).each do |j|
-      val = []
-      (0 .. RES).each do |k|
-        val << 2.1 * noise(0.35 * i, 0.35 * j, 0.35 * k)
-      end
-      valu << val
-    end
-    values << valu
-  end
-  
-  creator = HEC_IsoSurface.new
-  creator.set_resolution(RES,RES, RES) # number of cells in x,y,z direction
-  creator.set_size(400.0/RES, 400.0/RES, 400.0/RES) # cell size
-  
-  # JRuby requires a bit of help to determine correct 'java args', particulary with 
-  # overloaded arrays args as seen below. Note we are saying we have an 'array' of  
-  # 'float array' here, where the values can also be double[][][].
-  java_values = values.to_java(Java::float[][]) # pre-coerce values to java
-  creator.set_values(java_values)               # the grid points
-  
-  creator.set_isolevel(1)   # isolevel to mesh
-  creator.set_invert(false) # invert mesh
-  creator.set_boundary(100) # value of isoFunction outside grid
-  # use creator.clear_boundary to set boundary values to "no value".
-  # A boundary value of "no value" results in an open mesh
-  
-  mesh = HE_Mesh.new(creator)
-  # mesh.modify(HEM_Smooth.new.set_iterations(10).setAutoRescale(true))
-  creator.set_invert(true)
-  
-  inv_mesh = HE_Mesh.new(creator)
-  inv_mesh.modify(HEM_Smooth.new.set_iterations(10).set_auto_rescale(true))
-  @render = MeshToVBO.new(self)
-  no_stroke
-  # no color args produces a default light grey fill
-  @mesh_ret = render.meshToVBO(mesh, color(200, 0, 0))
-  @inv_mesh_ret = render.meshToVBO(inv_mesh, color(0, 0, 200))
-end
-
-def draw
-  background(120)
-  lights
-  define_lights
-  translate(400, 400)
-  rotate_y(mouse_x.to_f / width * TWO_PI)  # use TWO_PI until processing-2.0b9
-  rotate_x(mouse_y.to_f / height * TWO_PI) # then we can use TAU
-  shape(inv_mesh_ret)
-  shape(mesh_ret)
-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
+load_libraries :hemesh, :vbo, :vecmath
+
+include MS # module MS imports necessary java classes and contains ruby MeshToVBO class
+
+RES = 20
+
+attr_reader :mesh_ret, :inv_mesh_ret, :render
+
+def setup
+  size(800, 800, P3D)
+  ArcBall.init(self)
+  smooth(8)
+  values = []               # build a multi-dimensional array in ruby
+  (0 .. RES).each do |i|    # the inclusive range is intentional here
+    valu = []
+    (0 .. RES).each do |j|
+      val = []
+      (0 .. RES).each do |k|
+        val << 2.1 * noise(0.35 * i, 0.35 * j, 0.35 * k)
+      end
+      valu << val
+    end
+    values << valu
+  end
+  
+  creator = HEC_IsoSurface.new
+  creator.set_resolution(RES,RES, RES) # number of cells in x,y,z direction
+  creator.set_size(400.0/RES, 400.0/RES, 400.0/RES) # cell size
+  
+  # JRuby requires a bit of help to determine correct 'java args', particulary with 
+  # overloaded arrays args as seen below. Note we are saying we have an 'array' of  
+  # 'float array' here, where the values can also be double[][][].
+  java_values = values.to_java(Java::float[][]) # pre-coerce values to java
+  creator.set_values(java_values)               # the grid points
+  
+  creator.set_isolevel(1)   # isolevel to mesh
+  creator.set_invert(false) # invert mesh
+  creator.set_boundary(100) # value of isoFunction outside grid
+  # use creator.clear_boundary to set boundary values to "no value".
+  # A boundary value of "no value" results in an open mesh
+  
+  mesh = HE_Mesh.new(creator)
+  # mesh.modify(HEM_Smooth.new.set_iterations(10).setAutoRescale(true))
+  creator.set_invert(true)
+  
+  inv_mesh = HE_Mesh.new(creator)
+  inv_mesh.modify(HEM_Smooth.new.set_iterations(10).set_auto_rescale(true))
+  @render = MeshToVBO.new(self)
+  no_stroke
+  # no color args produces a default light grey fill
+  @mesh_ret = render.meshToVBO(mesh, color(200, 0, 0))
+  @inv_mesh_ret = render.meshToVBO(inv_mesh, color(0, 0, 200))
+end
+
+def draw
+  background(120)
+  lights
+  define_lights
+  shape(inv_mesh_ret)
+  shape(mesh_ret)
+end
+
+def define_lights
+  ambient(80, 80, 80)
+  ambient_light(80, 80, 80)
+  point_light(30, 30, 30, 0, 0, 1)
+  directional_light(40, 40, 50, 0, 0, 1)
+  spot_light(30, 30, 30, 0, 40, 200, 0, -0.5, 0.5, PI / 2, 2)
+end

data/samples/external_library/java_processing/pbox2d/bumpy_surface_noise.rb

@@ -0,0 +1,57 @@
+# The Nature of Code
+# <http:#www.shiffman.net/teaching/nature>
+# Spring 2010
+# PBox2D example
+
+# An uneven surface
+
+load_library :jbox2d
+load_library :surface
+
+include SB
+
+attr_reader :surface, :box2d, :particles
+
+def setup
+  size(500,300)
+  smooth
+  
+  # Initialize box2d physics and create the world
+  @box2d = Processing::Box2d::Box2d.new(self)
+  box2d.create_world
+  # We are setting a custom gravity
+  box2d.set_gravity(0, -20)
+  
+  # Create the empty list
+  @particles = []
+  # Create the surface
+  @surface = Surface.new(box2d)
+end
+
+def draw
+  # If the mouse is pressed, we make new particles
+  
+  
+  # We must always step through time!
+  box2d.step
+  
+  background(138, 66, 54)  
+  # Draw the surface
+  surface.display
+  # NB question mark is reqd to call mouse_pressed value, else method gets called.
+  particles << Particle.new(box2d, mouse_x, mouse_y, rand(2.0 .. 6)) if mouse_pressed?    
+  # Draw all particles
+  particles.each do |p|
+    p.display
+  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  
+  # Just drawing the framerate to see how many particles it can handle
+  fill(0)
+  text("framerate: #{frame_rate.to_i}", 12, 16)
+end

data/samples/external_library/java_processing/pbox2d/contact_test.rb

@@ -0,0 +1,23 @@
+load_library 'jbox2d'
+require 'jruby/core_ext'
+class JContactListener
+  include org.jbox2d.callbacks.ContactListener
+
+  def initialize()
+  end
+  java_signature "void beginContact(org.jbox2d.dynamics.contacts.Contact c)"
+  def begin_contact(c)
+  end
+  java_signature "void endContact(org.jbox2d.dynamics.contacts.Contact c)"
+  def end_contact(c)
+  end
+  java_signature "void beginContact(org.jbox2d.dynamics.contacts.Contact,org.jbox2d.callbacks.ContactImpulse )"
+  def pre_solve(c, ci)
+  end
+  java_signature "void beginContact(org.jbox2d.dynamics.contacts.Contact,org.jbox2d.callbacks.ContactImpulse )"
+  def post_solve(c, ci)
+  end 
+end
+
+
+

data/samples/external_library/java_processing/pbox2d/data/java_args.txt

@@ -0,0 +1,2 @@
+-XX:CompileCommand=dontinline,org.jruby.runtime.invokedynamic.InvokeDynamicSupport::invocationFallback 
+

data/samples/external_library/java_processing/pbox2d/library/custom_shape/custom_shape.rb

@@ -0,0 +1,158 @@
+module B2D
+  include_package 'pbox2d'
+  include_package 'org.jbox2d.collision.shapes'
+  include_package 'org.jbox2d.common'
+  include_package 'org.jbox2d.dynamics'
+  java_import 'pbox2d.PBox2D'
+  
+  
+  # The Nature of Code
+  # <http://www.shiffman.net/teaching/nature>
+  # Spring 2011
+  # PBox2D example
+  # A rectangular box
+  
+  class CustomShape
+
+    # We need to keep track of a Body and a width and height
+    attr_reader :body, :box2d
+    
+    # Constructor
+    def initialize(b2d, x, y)
+      # Add the box to the box2d world
+      @box2d = b2d  
+      make_body(B2D::Vec2.new(x, y))          
+    end
+    
+    # This function removes the particle from the box2d world
+    def kill_body!
+      box2d.destroy_body(body)
+    end
+    
+    # Is the particle ready for deletion?
+    def done
+      # Let's find the screen position of the particle
+      pos = box2d.get_body_pixel_coord(body)
+      # Is it off the bottom of the screen?
+      if (pos.y > $app.height)
+        kill_body!
+        return true
+      end
+      return false
+    end
+    
+    # Drawing the box
+    def display
+      # We look at each body and get its screen position
+      pos = box2d.get_body_pixel_coord(body)
+      # Get its angle of rotation
+      a = body.get_angle
+      
+      f = body.get_fixture_list
+      ps = f.get_shape
+      
+      
+      rect_mode(CENTER)
+      push_matrix
+      translate(pos.x, pos.y)
+      rotate(-a)
+      fill(175)
+      stroke(0)
+      begin_shape
+        # For every vertex, convert to pixel vector
+        ps.get_vertex_count.times do |i|
+          v = box2d.vector_world_to_pixels(ps.get_vertex(i))
+          vertex(v.x, v.y)
+        end
+      end_shape(CLOSE)
+      pop_matrix
+    end
+    
+    # This function adds the rectangle to the box2d world
+    def make_body(center)
+      
+      # Define a polygon (this is what we use for a rectangle)
+      sd = B2D::PolygonShape.new
+      
+      vertices = []
+      vertices << box2d.vector_pixels_to_world(B2D::Vec2.new(-15, 25))
+      vertices << box2d.vector_pixels_to_world(B2D::Vec2.new(15, 0))
+      vertices << box2d.vector_pixels_to_world(B2D::Vec2.new(20, -15))
+      vertices << box2d.vector_pixels_to_world(B2D::Vec2.new(-10, -10))
+      sd.set(vertices.to_java(Java::OrgJbox2dCommon::Vec2), vertices.length)
+      
+      # Define the body and make it from the shape
+      bd = B2D::BodyDef.new
+      bd.type = B2D::BodyType::DYNAMIC
+      bd.position.set(box2d.coord_pixels_to_world(center))
+      @body = box2d.create_body(bd)
+      
+      body.create_fixture(sd, 1.0)
+      
+      
+      # Give it some initial random velocity
+      body.set_linear_velocity(Vec2.new(rand(-5 .. 5), rand(2 .. 5)))
+      body.set_angular_velocity(rand(-5 .. 5))
+    end
+  end
+  
+  # The Nature of Code
+  # <http://www.shiffman.net/teaching/nature>
+  # Spring 2012
+  # PBox2D example
+  
+  # A fixed boundary class (now incorporates angle)
+  
+  
+  
+  class Boundary
+    
+    attr_reader :box2d, :b, :x, :y, :w, :h #, :a
+    
+    def initialize(b2d, x, y, w, h, a)
+      @box2d = b2d
+      @x = x
+      @y = y
+      @w = w
+      @h = h
+
+      # Define the polygon
+      sd = B2D::PolygonShape.new
+
+      # Figure out the box2d coordinates
+      box2dW = box2d.scalar_pixels_to_world(w/2)
+      box2dH = box2d.scalar_pixels_to_world(h/2)
+      # We're just a box
+      sd.set_as_box(box2dW, box2dH)
+      
+      
+      # Create the body
+      bd = B2D::BodyDef.new
+      bd.type = B2D::BodyType::STATIC
+      bd.angle = a
+      bd.position.set(box2d.coord_pixels_to_world(x,y))
+      @b = box2d.create_body(bd)
+      
+      # Attached the shape to the body using a Fixture
+      b.create_fixture(sd,1)
+    end
+    
+    # Draw the boundary, it doesn't move so we don't have to ask the Body for location
+    def display
+      fill(0)
+      stroke(0)
+      stroke_weight(1)
+      rect_mode(CENTER)
+      a = b.get_angle
+      push_matrix
+      translate(x,y)
+      rotate(-a)
+      rect(0,0,w,h)
+      pop_matrix
+    end
+    
+  end
+end
+  
+  
+