expand pbox2d examples

Author: monkstone

external_library/gem/pbox2d/bumpy_surface_noise.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env jruby -v -W2
+require 'propane'
+require 'pbox2d'
+require_relative 'lib/surface'
+
+# The Nature of Code
+# PBox2D example
+# An uneven surface
+class BumpySurfaceNoise < Propane::App
+  attr_reader :srface, :box2d, :particles
+
+  def setup
+    sketch_title 'Bumpy Surface Noise'
+    # Initialize box2d physics and create the world
+    @box2d = WorldBuilder.build(app: self, gravity: [0, -20])
+    # to later set a custom gravity
+    # box2d.gravity([0, -20])
+    # Create the empty list
+    @particles = []
+    # Create the srface
+    @srface = Surface.new(self)
+  end
+
+  def draw
+    # If the mouse is pressed, we make new particles
+    # We must always step through time!
+    background(138, 66, 54)
+    # Draw the srface
+    srface.display
+    # NB ? reqd to call mouse_pressed value, else method gets called.
+    particles << Particle.new(self, mouse_x, mouse_y, rand(2.0..6)) if mouse_pressed?
+    # Draw all particles
+    particles.each(&:display)
+    # Particles that leave the screen, we delete them
+    # (note they have to be deleted from both the box2d world and our list
+    particles.reject!(&:done)
+    # Just drawing the framerate to see how many particles it can handle
+    fill(0)
+    text(format('framerate: %d', frame_rate), 12, 16)
+  end
+
+  def settings
+    size(500, 300)
+    smooth 4
+  end
+end
+
+BumpySurfaceNoise.new

external_library/gem/pbox2d/collision_listening.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env jruby -v -W2
+require 'propane'
+require 'pbox2d'
+require 'forwardable'
+require_relative 'lib/custom_listener'
+require_relative 'lib/particle'
+require_relative 'lib/boundary'
+
+# Holder for vector values
+Vect = Struct.new(:x, :y)
+# The sketch class
+class CollisionListening < Propane::App
+  attr_reader :box2d, :particles, :wall
+
+  def setup
+    sketch_title 'Collision Listening'
+    @box2d = WorldBuilder.build(app: self)
+    box2d.add_listener(CustomListener.new)
+    @particles = []
+    @wall = Boundary.new(box2d, Vect.new(width / 2, height - 5), Vect.new(width, 10))
+  end
+
+  def draw
+    background(255)
+    particles << Particle.new(self, rand(width), 20, rand(4..8)) if rand < 0.1
+    particles.each(&:display)
+    particles.reject!(&:done)
+    wall.display
+  end
+
+  def settings
+    size 400, 400
+  end
+end
+
+CollisionListening.new

external_library/gem/pbox2d/distance_joint/boundary.rb

@@ -0,0 +1,40 @@
+# The Nature of Code
+# Daniel Shiffman
+# http://natureofcode.com
+
+CENTER ||= Java::ProcessingCore::PConstants::CENTER
+
+# A fixed boundary class
+class Boundary
+  extend Forwardable
+  def_delegators(:@app, :box2d, :rect_mode, :rect, :fill, :stroke)
+  # A boundary is a simple rectangle with x, y, width, and height
+  attr_reader :x, :y, :w, :h
+
+  def initialize(x, y, w, h)
+    @x, @y, @w, @h = x, y, w, h
+    @app = $app
+    # Define the polygon
+    sd = PolygonShape.new
+    # Figure out the box2d coordinates
+    box2dw = box2d.scale_to_world(w / 2)
+    box2dh = box2d.scale_to_world(h / 2)
+    # We're just a box
+    sd.setAsBox(box2dw, box2dh)
+    # Create the body
+    bd = BodyDef.new
+    bd.type = BodyType::STATIC
+    bd.position.set(box2d.processing_to_world(x, y))
+    b = box2d.createBody(bd)
+    # Attached the shape to the body using a Fixture
+    b.create_fixture(sd, 1)
+  end
+
+  # Draw the boundary, if it were at an angle we'd have to do something fancier
+  def display
+    fill(0)
+    stroke(0)
+    rect_mode(CENTER)
+    rect(x, y, w, h)
+  end
+end

external_library/gem/pbox2d/distance_joint/distance_joint.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env jruby -v -W2
+require 'propane'
+require 'pbox2d'
+require 'forwardable'
+require_relative 'boundary'
+require_relative 'pair'
+require_relative 'particle'
+require_relative 'particle_system'
+
+# The Nature of Code
+# Daniel Shiffman
+# http://natureofcode.com
+
+# Example demonstrating distance joints
+# A bridge is formed by connected a series of particles with joints
+class DistanceJoint < Propane::App
+
+  attr_reader :box2d, :boundaries, :system
+
+  def settings
+    size(640, 360)
+  end
+
+  def setup
+    sketch_title 'Distance Joint'
+    # Initialize box2d physics and create the world
+    @box2d = WorldBuilder.build(app: self)
+    @system = ParticleSystem.new
+    @boundaries = []
+    # Add a bunch of fixed boundaries
+    boundaries << Boundary.new(width / 4, height - 5, width / 2 - 50, 10)
+    boundaries << Boundary.new(3 * width / 4, height - 50, width / 2 - 50, 10)
+  end
+
+  def draw
+    background(255)
+    system.run
+    # Display all the boundaries
+    boundaries.each(&:display)
+    fill(0)
+    text('Click mouse to add connected particles.', 10, 20)
+  end
+
+  def mouse_pressed
+    system.add_pair(mouse_x, mouse_y)
+  end
+end
+
+DistanceJoint.new

external_library/gem/pbox2d/distance_joint/pair.rb

@@ -0,0 +1,60 @@
+# The Nature of Code
+# Daniel Shiffman
+# http://natureofcode.com
+
+# Series of Particles connected with distance joints
+class Pair
+  extend Forwardable
+  def_delegators(:@app, :box2d, :stroke, :line, :stroke_weight)
+  attr_reader :p1, :p2, :len, :joint
+  # Chain constructor
+  def initialize(x, y)
+    @app = $app
+    @len = 32
+    @p1 = Particle.new(x, y)
+    @p2 = Particle.new(x + rand(-1..1.0), y + rand(-1..1.0))
+    djd = DistanceJointDef.new
+    # Connection between previous particle and this one
+    djd.bodyA = p1.body
+    djd.bodyB = p2.body
+    # Equilibrium length
+    djd.length = box2d.scale_to_world(len)
+    # These properties affect how springy the joint is
+    djd.frequencyHz = 3     # Try a value less than 5 (0 for no elasticity)
+    djd.dampingRatio = 0.1  # Ranges between 0 and 1 (1 for no springiness)
+    # Make the joint.
+    @joint = box2d.world.create_joint(djd)
+  end
+
+  def kill_bodies
+    box2d.world.destroy_joint(joint)
+    @joint = nil
+    box2d.destroy_body(p1.body)
+    box2d.destroy_body(p2.body)
+  end
+
+  # Is the pair ready for deletion?
+  def done?
+    # Let's find the screen position of the particle
+    pos1 = box2d.body_coord(p1.body)
+    pos2 = box2d.body_coord(p2.body)
+    # Is it off the screen?
+    if (0..@app.width).include?(pos1.x) || (0..@app.width).include?(pos2.x)
+      if (0..@app.height).include?(pos1.y) || (0..@app.height).include?(pos2.y)
+        return false
+      end
+    end
+    kill_bodies
+    true
+  end
+
+  def display
+    pos1 = box2d.body_coord(p1.body)
+    pos2 = box2d.body_coord(p2.body)
+    stroke(0)
+    stroke_weight(2)
+    line(pos1.x, pos1.y, pos2.x, pos2.y)
+    p1.display
+    p2.display
+  end
+end

external_library/gem/pbox2d/distance_joint/particle.rb

@@ -0,0 +1,72 @@
+# The Nature of Code
+# Daniel Shiffman
+# http://natureofcode.com
+
+# A circular particle
+class Particle
+  extend Forwardable
+  def_delegators(:@app, :fill, :stroke, :stroke_weight, :box2d, :height, :line,
+                 :push_matrix, :pop_matrix, :ellipse, :rotate, :translate)
+  # We need to keep track of a Body and a radius
+  attr_reader :body, :r
+
+  def initialize(x, y)
+    @r = 8
+    @app = $app
+    # Define a body
+    bd = BodyDef.new
+    # Set its position
+    bd.position = box2d.processing_to_world(x, y)
+    bd.type = BodyType::DYNAMIC
+    @body = box2d.world.createBody(bd)
+
+    # Make the body's shape a circle
+    cs = CircleShape.new
+    cs.m_radius = box2d.scale_to_world(r)
+
+    fd = 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.createFixture(fd)
+    body.setLinearVelocity(Vec2.new(rand(-5..5), rand(2..5)))
+  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.body_coord(body)
+    # Is it off the bottom of the screen?
+    if pos.y > height + r * 2
+      kill_body
+      return true
+    end
+    false
+  end
+
+  def display
+    # We look at each body and get its screen position
+    pos = box2d.body_coord(body)
+    # Get its angle of rotation
+    a = body.get_angle
+    push_matrix
+    translate(pos.x, pos.y)
+    rotate(a)
+    fill(127)
+    stroke(0)
+    stroke_weight(2)
+    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
+end

external_library/gem/pbox2d/distance_joint/particle_system.rb

@@ -0,0 +1,22 @@
+# run system with a single command
+module Runnable
+  def run
+    reject!(&:done?)
+    each(&:display)
+  end
+end
+
+# A custom enumerable class, it is so easy in ruby
+class ParticleSystem
+  include Enumerable, Runnable
+  extend Forwardable
+  def_delegators(:@pairs, :each, :reject!, :<<)
+  
+  def initialize
+    @pairs = []
+  end
+  
+  def add_pair(x, y)
+    self << Pair.new(x, y)
+  end
+end

external_library/gem/pbox2d/library/particles/lib/boundary.rb renamed to external_library/gem/pbox2d/lib/boundary.rb

@@ -1,8 +1,7 @@
-# Re-usable Boundary class
 class Boundary
   include Propane::Proxy
   attr_reader :box2d, :b, :pos, :size, :a
-
+  
   def initialize(b2d, pos, sz, a = 0)
     @box2d, @pos, @size, @a = b2d, pos, sz, a
     # Define the polygon
@@ -22,7 +21,7 @@ def initialize(b2d, pos, sz, a = 0)
     b.create_fixture(sd, 1)
   end
 
-  # Draw the boundary, it doesn't move so we don't ask for location
+  # Draw the boundary, it doesn't move so we don't have to ask the Body for location
   def display
     fill(0)
     stroke(0)
@@ -32,7 +31,7 @@ def display
     push_matrix
     translate(pos.x, pos.y)
     rotate(-a)
-    rect(0, 0, size.x, size.y)
+    rect(0, 0, size.x,size.y)
     pop_matrix
   end
 end

external_library/gem/pbox2d/lib/box.rb

@@ -0,0 +1,16 @@
+# A Box class, note how to access class ParticleGroupDef in jruby
+# which is imported to PB module to avoid namespace clashes
+class Box
+  def initialize(b2d, x, y)
+    w = rand(1..3)
+    h = rand(1..3)
+    shape = PolygonShape.new
+    pos = b2d.processing_to_world(x, y)
+    shape.setAsBox(w, h, pos, 0)
+    pd = PB::ParticleGroupDef.new
+    pd.shape = shape
+    b2d.world.create_particle_group(pd)
+  end
+end
+
+