ruby-processing 2.4.4 → 2.5.0

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
+  
+  
+  
+  
+

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

@@ -0,0 +1,154 @@
+# The Nature of Code
+# <http:#www.shiffman.net/teaching/nature>
+# Spring 2010
+# PBox2D example
+
+# An uneven surface boundary
+module SB
+  
+  include_package 'org.jbox2d.collision.shapes'
+  include_package 'org.jbox2d.common'  
+  include_package 'org.jbox2d.dynamics'
+  java_import 'pbox2d.PBox2D'
+  
+  
+  
+  class Surface
+    # We'll keep track of all of the surface points
+    attr_reader :surface, :body, :box2d, :y, :width, :height
+    
+    
+    def initialize b2d
+      @box2d = b2d
+      @surface = []
+      @width, @height = $app.width, $app.height
+      # This is what box2d uses to put the surface in its world
+      chain = SB::ChainShape.new
+      
+      # Perlin noise argument
+      xoff = 0.0
+      
+      # This has to go backwards so that the objects  bounce off the top of the surface
+      # This "edgechain" will only work in one direction!
+      (width + 10).step(-10, -5) do |x| 
+        # Doing some stuff with perlin noise to calculate a surface that points down on one side
+        # and up on the other
+        
+        if (x > width/2)
+          @y = 100 + (width - x)*1.1 + map(noise(xoff),0,1,-80,80)
+        else
+          @y = 100 + x*1.1 + map(noise(xoff),0,1,-80,80)
+        end
+        
+        # Store the vertex in screen coordinates
+        surface << SB::Vec2.new(x, y)
+        
+        # Move through perlin noise
+        xoff += 0.1
+        
+      end
+      
+      # Build an array of vertices in Box2D coordinates
+      # from the ArrayList we made
+      vertices = []
+      surface.each do |surf|        
+        vertices << box2d.coord_pixels_to_world(surf)
+      end
+     # Create the chain!
+      chain.createChain(vertices, vertices.length)
+      # The edge chain is now attached to a body via a fixture
+      bd = SB::BodyDef.new
+      bd.position.set(0.0, 0.0)
+      @body = box2d.createBody(bd)
+      # Shortcut, we could define a fixture if we
+      # want to specify frictions, restitution, etc.
+      body.createFixture(chain, 1)      
+    end
+    
+    # A simple function to just draw the edge chain as a series of vertex points
+    def display
+      stroke_weight(2)
+      stroke(0)
+      fill(135, 206, 250)
+      beginShape
+        vertex(width, 0)      # extra vertices so we can fill sky
+        surface.each do |v|
+          vertex(v[0], v[1])    # the mountain range
+        end
+        vertex(0, 0)          # extra vertices so we can fill sky
+      endShape
+    end    
+  end
+  
+  class Particle
+    # We need to keep track of a Body
+    
+    attr_reader :body, :box2d, :x, :y, :r 
+    
+    # Constructor
+    def initialize(b2d, x, y, r)
+      @box2d, @x, @y, @r = b2d, x, y, r
+      # This function puts the particle in the Box2d world
+      make_body(x, y, r)
+    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
+      pos = box2d.get_body_pixel_coord(body)
+      # Is it off the bottom of the screen?
+      if (pos[1] > $app.height + r * 2)
+        kill_body
+        return true
+      end
+        return false
+    end
+    
+    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
+      push_matrix
+      translate(pos[0],  pos[1])
+      rotate(-a)
+      fill(175)
+      stroke(0)
+      stroke_weight(1)
+      ellipse(0,0,r*2,r*2)
+      # Let's add a line so we can see the rotation
+      line(0,0,r,0)
+      pop_matrix
+    end
+    
+    # This function adds the rectangle to the box2d world
+    def make_body(x, y, r)
+      # Define and create the body
+      bd = SB::BodyDef.new      
+      bd.position = box2d.coord_pixels_to_world(x,y) 
+      bd.type = SB::BodyType::DYNAMIC
+      @body = box2d.world.create_body(bd)
+      # Make the body's shape a circle
+      cs = SB::CircleShape.new
+      cs.m_radius = box2d.scalar_pixels_to_world(r)      
+      fd = SB::FixtureDef.new      
+      fd.shape = cs
+      # Parameters that affect physics
+      fd.density = 1
+      fd.friction = 0.01
+      fd.restitution = 0.3      
+      # Attach fixture to body
+      body.create_fixture(fd)      
+      # Give it a random initial velocity (and angular velocity)
+      body.set_linear_velocity(SB::Vec2.new(rand(-10 .. 10), rand(5 .. 10)))
+      body.set_angular_velocity(rand(-10 .. 10))      
+    end      
+  end    
+end  
+  
+  
+

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

@@ -0,0 +1,58 @@
+# The Nature of Code
+# <http:#www.shiffman.net/teaching/nature>
+# Spring 2011
+# PBox2D example
+
+# Box2D particle system example
+
+load_library :pbox2d
+load_library :particle_system
+
+# module PS is a wrapper for java imports, and Boundary and Particle classes
+include PS     
+
+attr_reader :box2d, :boundaries, :systems
+
+def setup
+  size(400,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 ArrayLists	
+  @systems = []
+  @boundaries = []  
+  # Add a bunch of fixed boundaries
+  boundaries << Boundary.new(box2d, 50, 100, 300, 5, -0.3)
+  boundaries << Boundary.new(box2d, 250, 175, 300, 5, 0.5)  
+end
+
+def draw
+  background(255)  
+  # We must always step through time!
+  box2d.step  
+  # Run all the particle systems
+  if systems.size > 0
+    systems.each do |system|
+      system.run 
+      system.add_particles(box2d, rand(0 .. 2)) 
+    end
+  end  
+  # Display all the boundaries
+  boundaries.each do |wall|
+    wall.display
+  end
+end
+
+
+def mouse_pressed
+  # Add a new Particle System whenever the mouse is clicked
+  systems << ParticleSystem.new(box2d, 0, mouse_x, mouse_y)
+end
+
+
+
+
+

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

@@ -0,0 +1,58 @@
+# The Nature of Code
+# <http://www.shiffman.net/teaching/nature>
+# Spring 2011
+# PBox2D example
+
+# Basic example of falling rectangles
+load_library :pbox2d
+load_library :custom_shape
+
+# module B2D is a wrapper for java imports, and Boundary and CustomShape classes
+include B2D     
+
+attr_reader :box2d, :boundaries, :polygons
+
+def setup
+  size(640,360)
+  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 Arrays	
+  @polygons = []
+  @boundaries = []  
+  # Add a bunch of fixed boundaries
+  boundaries << Boundary.new(box2d, width / 4, height - 5, width/2 - 50, 10, 0)
+  boundaries << Boundary.new(box2d, 3*width / 4, height - 50, width/2 - 50, 10, 0)
+  boundaries << Boundary.new(box2d, width - 5,height / 2, 10, height, 0)
+  boundaries << Boundary.new(box2d, 5, height / 2, 10, height, 0)
+end
+
+def draw
+  background(255)  
+  # We must always step through time!
+  box2d.step  
+  # Display all the boundaries
+  boundaries.each do |wall|
+    wall.display
+  end
+  
+  # Display all the polygons
+  polygons.each do |cs|
+    cs.display
+  end
+  
+  # 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
+end
+
+def mouse_pressed  
+  polygons << CustomShape.new(box2d, mouse_x, mouse_y)
+end