ruby-processing 1.0.11 → 2.4.1

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 :pbox2d
+load_library :surface
+
+include SB
+
+attr_reader :surface, :box2d, :particles
+
+def setup
+  size(500,300)
+  smooth
+  
+  # Initialize box2d physics and create the world
+  @box2d = PBox2D.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
+  
+  
+

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

@@ -0,0 +1,212 @@
+module PS
+  include_package 'org.jbox2d.collision.shapes'
+  include_package 'org.jbox2d.common'
+  include_package 'org.jbox2d.dynamics'
+  java_import 'pbox2d.PBox2D'
+  
+  
+  # Box2D Particle System
+  # <http://www.shiffman.net/teaching/nature>
+  # Spring 2010
+  
+  # A class to describe a group of Particles
+  # An ArrayList 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
+      @x, @y = x, y            # Store the origin point  
+      num.times do
+        particles << PS::Particle.new(bd, x, y)
+      end
+    end
+    
+    def run
+      # Display all the 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
+    end
+    
+    def add_particles(bd, n)
+      n.times do
+        particles << PS::Particle.new(bd, x, y)
+      end
+    end
+    
+    # A method to test if the particle system still has particles
+    def dead  
+      particles.empty?
+    end
+    
+  end
+  
+  # The Nature of Code
+  # <http://www.shiffman.net/teaching/nature>
+  # Spring 2012
+  # PBox2D example
+  
+  # A Particle
+  
+  class Particle
+    TRAIL_SIZE = 6
+    # We need to keep track of a Body
+    
+    attr_reader :trail, :body, :box2d
+    
+    # Constructor
+    def initialize(b2d, x, y)
+      @box2d = b2d
+      @trail = Array.new(TRAIL_SIZE, [x, y])
+      
+      # Add the box to the box2d world
+      # Here's a little trick, let's make a tiny tiny radius
+      # This way we have collisions, but they don't overwhelm the system
+      make_body(PS::Vec2.new(x,y), 0.2)
+    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 + 20)
+        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)
+      
+      # Keep track of a history of screen positions in an array
+      (TRAIL_SIZE - 1).times do |i|
+        trail[i] = trail[i + 1]
+      end
+      trail[TRAIL_SIZE - 1] = [pos.x, pos.y]
+      
+      # Draw particle as a trail
+      begin_shape
+        noFill
+        stroke_weight(2)
+        stroke(0,150)
+        trail.each do |v|
+          vertex(v[0], v[1])
+        end
+      end_shape
+    end
+    
+    # This function adds the rectangle to the box2d world
+    def make_body(center, r)
+      # Define and create the body
+      bd = PS::BodyDef.new
+      bd.type = PS::BodyType::DYNAMIC
+      
+      bd.position.set(box2d.coord_pixels_to_world(center))
+      @body = box2d.create_body(bd)
+      
+      # Give it some initial random velocity
+      body.set_linear_velocity(PS::Vec2.new(rand(-1 .. 1), rand(-1 .. 1)))
+      
+      # Make the body's shape a circle
+      cs = PS::CircleShape.new
+      cs.m_radius = box2d.scalar_pixels_to_world(r)
+      
+      fd = PS::FixtureDef.new
+      fd.shape = cs
+      
+      fd.density = 1
+      fd.friction = 0  # Slippery when wet!
+      fd.restitution = 0.5
+      
+      # We could use this if we want to turn collisions off
+      #cd.filter.groupIndex = -10
+      
+      # Attach fixture to body
+      body.create_fixture(fd)
+      
+    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 = PS::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 = PS::BodyDef.new
+      bd.type = PS::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
+  
+  
+  
+  
+