pbox2d 0.3.1-java → 0.4.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 804efe16e11649eda15f47f166687f533b01bb13
-  data.tar.gz: 21eacf2bd1015bc7a5029d95a6e5a9cc4d3a50ef
+  metadata.gz: 81258910255ac53b8912a7f3f837b9bf02a07272
+  data.tar.gz: f90863528fb8b5bf7b181d83242e827d76c10b69
 SHA512:
-  metadata.gz: a703df8b21385e2d880141d34d2ac8b5ed6d9566512b694ff05c0720ab3c948fb0ea3e7e128dc49eee8be87b6824e14b7ca95ac5f9387763733994bdb43f7f79
-  data.tar.gz: 01e4749137f5f863d8d7327a45dd231eca1becf2591661ca0b49973aa257aa1283019a7754a223ac069bea54cf0726ede70f47948b649a18db9b92773c2efa65
+  metadata.gz: 1cb053c08445179dfcd209feb78e86cca4dd057012e76c92c73e86a207eba663fcbd2aaa8ecbefaa7324f6093f747b1253a4cf6a76688c7638b0054ee08199d1
+  data.tar.gz: 3cb3b8ce51b0f8f1bf9ff9c3a42b801b6ce2d7316cca6a80a3e6df3d909d4c8956f3086beae37007c752cf56aa67863f7466cf5e56639261cf067f1fb4c015c6

data/README.md

@@ -1,9 +1,11 @@
 ### Using JBox2D in ruby-processing
 
-Here we demonstrate how to use JBox2D library as a rubygem. This approach could be an exemplar of how to use other processing/java libraries with ruby-processing  
+Here we demonstrate how to use JBox2D library as a rubygem. This approach could be an exemplar of how to use other processing/java libraries with both ruby-processing and JRubyArt.
 ![liquidy](http://4.bp.blogspot.com/-dwnDQZVugwo/VFXrDxGOy4I/AAAAAAAAEgo/irsZxW_WLOA/s400/liquidy.png)
 
 
+[![Gem Version](https://badge.fury.io/rb/pbox2d.svg)](http://badge.fury.io/rb/pbox2d)
+
 ### Web Links
 
 [JBox2D Home][]
@@ -40,7 +42,7 @@ Like really easy, but if you have to use rvm or rbenv you will also know what to
 
 ### To use
 
-You need to `require 'pbox2d'` in the the usual way (to require a gem). Now you should create a new instance of Box2D. However as in the included [example][] you must also `include ContactListener` interface (by [jruby magic][], including the interface as a module implements the java interface) if you wish to create your own jbox2d listener. 
+You need to `require 'pbox2d'` in the the usual way (to require a gem). Now you should create a new instance of Box2D. However as in this included [example][] you may also need to `include ContactListener` interface (by [jruby magic][], including the interface as a module implements the java interface) if you wish to create your own jbox2d listener. 
 ```ruby
 @box2d = Box2D.new(self)
 box2d.init_options(gravity: [0, -20]) # this is new since version 0.2.0

data/Rakefile

@@ -22,11 +22,11 @@ EOF
   s.authors = ['Martin Prout']
   s.email = 'martin_p@lineone.net'
   s.homepage = 'https://github.com/ruby-processing/jbox2d'
-  s.files = %w(LICENSE.md README.md Rakefile) + FileList['lib/**/*.rb', 'example/**/*.rb']
+  s.files = %w(LICENSE.md README.md Rakefile) + FileList['lib/**/*.rb', 'examples/**/*.rb']
   s.files << 'lib/box2d.jar'
   s.files << 'lib/jbox2d-library-2.2.1-ds.jar' 
   s.require_path = 'lib'
-  s.add_dependency "ruby-processing", "~> 2.6.4"
+  s.add_dependency 'ruby-processing', '~> 2.6', '>= 2.6.4'
   s.add_development_dependency "rake", "~> 10.3"
   s.add_development_dependency "rake-compiler", "~> 0.9"
   s.platform='java'

data/examples/bumpy_surface_noise.rb

@@ -0,0 +1,41 @@
+# The Nature of Code
+# PBox2D example
+# An uneven surface
+
+require 'pbox2d'
+require_relative 'lib/surface'
+
+attr_reader :surface, :box2d, :particles
+
+def setup
+  size(500, 300)
+  smooth 4
+  # Initialize box2d physics and create the world
+  @box2d = Box2D.new(self)
+  box2d.init_options(gravity: [0, -20])
+  box2d.create_world
+  # to later set a custom gravity
+  # box2d.gravity([0, -20])
+  # Create the empty list
+  @particles = []
+  # Create the surface
+  @surface = 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 surface
+  surface.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("framerate: #{frame_rate.to_i}", 12, 16)
+end

data/examples/distance_joint/boundary.rb

@@ -0,0 +1,39 @@
+# The Nature of Code
+# Daniel Shiffman
+# http://natureofcode.com
+require 'forwardable'
+
+# 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.createFixture(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(Java::ProcessingCore::PConstants::CENTER)
+    rect(x, y, w, h)
+  end
+end

data/examples/distance_joint/distance_joint.rb

@@ -0,0 +1,38 @@
+# 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
+
+require 'pbox2d'
+require_relative 'boundary'
+require_relative 'pair'
+require_relative 'particle'
+
+attr_reader :box2d, :boundaries, :pairs
+
+def setup
+  size(640, 360)
+  # Initialize box2d physics and create the world
+  @box2d = Box2D.new(self)
+  box2d.create_world
+  @pairs = []
+  @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)
+  pairs.each(&:display)
+  # Display all the boundaries
+  boundaries.each(&:display)
+  fill(0)
+  text('Click mouse to add connected particles.', 10, 20)
+end
+
+def mouse_pressed
+   pairs << Pair.new(mouse_x, mouse_y)
+end

data/examples/distance_joint/pair.rb

@@ -0,0 +1,41 @@
+# The Nature of Code
+# Daniel Shiffman
+# http://natureofcode.com
+require 'forwardable'
+
+# Series of Particles connected with distance joints
+class Pair
+  extend Forwardable
+  def_delegators(:@app, :box2d, :stroke, :line, :stroke_weight)
+  attr_reader :p1, :p2, :len
+  # 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.  Note we aren't storing a reference to the joint ourselves anywhere!
+    # We might need to someday, but for now it's ok
+    box2d.world.create_joint(djd)
+  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
+

data/examples/distance_joint/particle.rb

@@ -0,0 +1,75 @@
+# The Nature of Code
+# Daniel Shiffman
+# http://natureofcode.com
+require 'forwardable'
+
+# 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
+
+

data/examples/lib/boundary.rb

@@ -0,0 +1,30 @@
+require 'forwardable'
+
+# The boundary class is used to create fixtures
+class Boundary
+  extend Forwardable
+  def_delegators(:@app, :fill, :stroke, :rect, :rect_mode, :box2d)
+  attr_reader :x, :y, :w, :h, :b
+  def initialize(app, x, y, w, h)
+    @app, @x, @y, @w, @h = app, x, y, w, h
+    sd = PolygonShape.new
+    box2d_w = box2d.scale_to_world(w / 2)
+    box2d_h = box2d.scale_to_world(h / 2)
+    sd.setAsBox(box2d_w, box2d_h)
+    # Create the body
+    bd = BodyDef.new
+    bd.type = BodyType::STATIC
+    bd.position.set(box2d.processing_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, if it were at an angle we'd have to do something fancier
+  def display
+    fill(0)
+    stroke(0)
+    rect_mode(Java::ProcessingCore::PConstants::CENTER)
+    rect(x, y, w, h)
+  end
+end

data/examples/lib/box.rb

@@ -0,0 +1,15 @@
+# A Box class, note how to access class ParticleGroupDef in jruby
+# which is currently not on an included path for pbox2d
+class Box
+  attr_accessor :pg
+  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 = Java::OrgJbox2dParticle::ParticleGroupDef.new
+    pd.shape = shape
+    @pg = b2d.world.create_particle_group(pd)
+  end
+end

data/examples/lib/particle_system.rb

@@ -0,0 +1,154 @@
+require 'forwardable'
+
+module Runnable
+  def run
+    reject!(&:done)
+    each(&:display)
+  end
+end
+
+class ParticleSystem
+  include Enumerable, Runnable
+  extend Forwardable
+  def_delegators(:@particles, :each, :reject!, :<<, :empty?)
+  def_delegator(:@particles, :empty?, :dead?)
+
+  attr_reader :x, :y
+
+  def initialize(app, num, x, y)
+    @particles = []          # Initialize the Array
+    @x, @y = x, y            # Store the origin point
+    num.times do
+      self << Particle.new(app, x, y)
+    end
+  end
+
+  def add_particles(app, n)
+    n.times do
+      self << Particle.new(app, x, y)
+    end
+  end
+end
+
+# A Particle
+require 'pbox2d'
+
+class Particle
+  extend Forwardable
+  def_delegators(:@app, :box2d, :begin_shape, :end_shape,
+                 :vertex, :translate, :rotate, :stroke,
+                 :fill, :no_fill, :stroke_weight)
+  TRAIL_SIZE = 6
+  # We need to keep track of a Body
+
+  attr_reader :trail, :body
+
+  # Constructor
+  def initialize(app, x, y)
+    @app = app
+    @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(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.body_coord(body)
+    # Is it off the bottom of the screen?
+    return false unless pos.y > box2d.height + 20
+    kill_body
+    true
+  end
+
+  # Drawing the box
+  def display
+    # We look at each body and get its screen position
+    pos = box2d.body_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
+    no_fill
+    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(x, y, r)
+    # Define and create the body
+    bd = BodyDef.new
+    bd.type = BodyType::DYNAMIC
+    bd.position.set(box2d.processing_to_world(x, y))
+    @body = box2d.create_body(bd)
+    # Give it some initial random velocity
+    body.set_linear_velocity(Vec2.new(rand(-1.0..1), rand(-1.0..1)))
+    # Make the body's shape a circle
+    cs = CircleShape.new
+    cs.m_radius = box2d.scale_to_world(r)
+    fd = 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
+
+class Boundary
+  extend Forwardable
+  def_delegators(:@app, :box2d, :push_matrix, :pop_matrix, :stroke, :width,
+                 :vertex, :translate, :rotate, :rect_mode, :rect,
+                 :fill, :no_fill, :stroke_weight)
+  attr_reader :b, :x, :y, :h
+
+  def initialize(app, x, y, h, a)
+    @app, @x, @y, @h = app, x, y, h
+    # Define the polygon
+    sd = PolygonShape.new
+    # Figure out the box2d coordinates
+    box2d_w = box2d.scale_to_world(width / 2)
+    box2d_h = box2d.scale_to_world(h / 2)
+    # We're just a box
+    sd.set_as_box(box2d_w, box2d_h)
+    # Create the body
+    bd = BodyDef.new
+    bd.type = BodyType::STATIC
+    bd.angle = a
+    bd.position.set(box2d.processing_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(Java::ProcessingCore::PConstants::CENTER)
+    a = b.get_angle
+    push_matrix
+    translate(x, y)
+    rotate(-a)
+    rect(0, 0, width, h)
+    pop_matrix
+  end
+end