pbox2d 0.3.1-java → 0.4.0-java

data/examples/lib/surface.rb

@@ -0,0 +1,136 @@
+require 'forwardable'
+
+# The Nature of Code
+# PBox2D example
+# An uneven surface boundary
+class Surface
+  extend Forwardable
+  # We'll keep track of all of the surface points
+  def_delegators(:@app, :box2d, :width, :height, :begin_shape,
+                 :end_shape, :fill, :stroke, :stroke_weight,
+                 :vertex, :map1d, :noise)
+  attr_reader :surface, :body, :y
+
+  def initialize(app)
+    @app = app
+    @surface = []
+    # This is what box2d uses to put the surface in its world
+    chain = 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 + map1d(noise(xoff), (0..1.0), (-80..80))
+      else
+        @y = 100 + x * 1.1 + map1d(noise(xoff), (0..1.0), (-80..80))
+      end
+      # Store the vertex in screen coordinates
+      surface << 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.processing_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 = 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)
+    begin_shape
+    vertex(width, 0)          # extra vertices so we can fill sky
+    surface.map { |v| vertex(v.x, v.y) }     # the mountain range
+    vertex(0, 0)              # extra vertices so we can fill sky
+    end_shape
+  end
+end
+
+# Using forwardable again
+class Particle
+  extend Forwardable
+  def_delegators(:@app, :box2d, :push_matrix, :pop_matrix, :rotate,
+                 :translate, :fill, :stroke, :stroke_weight, :noise,
+                 :map1d, :ellipse, :line)
+  # We need to keep track of a Body
+
+  attr_reader :body, :x, :y, :r
+
+  # Constructor
+  def initialize(app, x, y, r)
+    @app, @x, @y, @r = app, 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.body_coord(body)
+    # Is it off the bottom of the screen?
+    return false unless pos.y > box2d.height + r * 2
+    kill_body
+    true
+  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(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 = BodyDef.new
+    bd.position = box2d.processing_to_world(x, y)
+    bd.type = BodyType::DYNAMIC
+    @body = box2d.create_body(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.create_fixture(fd)
+    # Give it a random initial velocity (and angular velocity)
+    body.set_linear_velocity(Vec2.new(rand(-10..10), rand(5..10)))
+    body.set_angular_velocity(rand(-10..10))
+  end
+end

data/examples/liquid_fun_test.rb

@@ -0,0 +1,42 @@
+# The Nature of Code
+# Daniel Shiffman
+# http://natureofcode.com
+# Basic example of falling rectangles
+
+require 'pbox2d'
+require_relative 'lib/boundary'
+require_relative 'lib/box'
+
+attr_reader :boxes, :boundaries, :box2d
+
+def setup
+  size(640, 360, P2D)
+  @box2d = Box2D.new(self)
+  box2d.init_options(gravity: [0, -10])
+  box2d.create_world
+  @boundaries = []
+  @boxes = []
+  box2d.world.set_particle_radius(0.15)
+  box2d.world.set_particle_damping(0.2)
+  boundaries << Boundary.new(self, width / 4, height - 5, width / 2 - 50, 10)
+  boundaries << Boundary.new(self, 3 * width / 4, height - 50, width / 2 - 50, 10)
+end
+
+def mouse_pressed
+  boxes << Box.new(box2d, mouse_x, mouse_y)
+end
+
+def draw
+  background(255)
+  boundaries.each(&:display)
+  pos_buffer = box2d.world.particle_position_buffer
+  return if pos_buffer.nil?
+  stroke(0)
+  stroke_weight(2)
+  pos_buffer.each do |buf|
+    pos = box2d.world_to_processing(buf)
+    point(pos.x, pos.y)
+  end
+  fill(0)
+  text(format('f.p.s %d', frame_rate.to_i), 10, 60)
+end

data/examples/liquidy.rb

@@ -0,0 +1,36 @@
+require 'pbox2d'
+require_relative 'lib/particle_system'
+attr_reader :box2d, :boundaries, :systems
+
+def setup
+  size(400, 300)
+  @box2d = Box2D.new(self)
+  box2d.init_options(gravity: [0, -20])
+  box2d.create_world
+  # to set a custom gravity otherwise
+  # box2d.gravity([0, -20])
+  # Create Arrays
+  @systems = []
+  @boundaries = []
+  # Add a bunch of fixed boundaries
+  boundaries << Boundary.new(self, 50, 100, 5, -0.3)
+  boundaries << Boundary.new(self, 250, 175, 5, 0.5)
+end
+
+def draw
+  background(255)
+  # Run all the particle systems
+  if systems.size > 0
+    systems.each do |system|
+      system.run
+      system.add_particles(self, rand(0..2))
+    end
+  end
+  # Display all the boundaries
+  boundaries.each(&:display)
+end
+
+def mouse_pressed
+  # Add a new Particle System whenever the mouse is clicked
+  systems << ParticleSystem.new(self, 0, mouse_x, mouse_y)
+end

data/examples/polygons.rb

@@ -0,0 +1,39 @@
+# Basic example of falling rectangles
+require 'pbox2d'
+require_relative 'lib/custom_shape'
+
+attr_reader :box2d, :boundaries, :polygons
+
+def setup
+  size(640, 360)
+  smooth
+  # 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 Arrays
+  @polygons = []
+  @boundaries = []
+  # Add a bunch of fixed boundaries
+  boundaries << Boundary.new(self, width / 4, height - 5, width / 2 - 50, 10, 0)
+  boundaries << Boundary.new(self, 3 * width / 4, height - 50, width / 2 - 50, 10, 0)
+  boundaries << Boundary.new(self, width - 5, height / 2, 10, height, 0)
+  boundaries << Boundary.new(self, 5, height / 2, 10, height, 0)
+end
+
+def draw
+  background(255)
+  # Display all the boundaries
+  boundaries.each(&:display)
+  # Display all the polygons
+  polygons.each(&:display)
+  # polygons that leave the screen, we delete them
+  # (note they have to be deleted from both the box2d world and our list
+  polygons.reject!(&:done)
+end
+
+def mouse_pressed
+  polygons << CustomShape.new(self, mouse_x, mouse_y)
+end

data/examples/quick_test.rb

@@ -0,0 +1,141 @@
+require 'pbox2d'
+
+# A list we'll use to track fixed objects
+attr_reader :box2d, :boundaries, :boxes
+
+java_alias :background_int, :background, [Java::int]
+java_alias :stroke_int, :stroke, [Java::int]
+
+def setup
+  size(400,300)
+  stroke_int(0)  # set stroke this way to avoid overload warnings
+  srand(5)
+  # Initialize box2d physics and create the world
+  @box2d = Box2D.new(self)
+  puts box2d.version # print out version of pbox2d gem in use
+  box2d.init_options(scale: 10, gravity: [0, -20.0])
+  box2d.create_world
+  # Set a custom gravity
+  # box2d.gravity(0, -20)
+  # Create ArrayLists
+  @boxes = []
+  @boundaries = []
+  # Add a bunch of fixed boundaries
+  boundaries << Boundary.new(self, width / 4, height - 5, width / 2 - 50, 10)
+  boundaries << Boundary.new(self, 3 * width / 4, height - 50, width / 2 - 50, 10)
+end
+
+def draw
+  background_int(255) # set background this way to avoid overload warnings
+  # Boxes fall from the top every so often
+  boxes << Box.new(self, width / 2, 30) if rand < 0.99
+  boundaries.each(&:display)
+  boxes.each(&:display)
+  # Boxes that leave the screen, we delete them note they have to be deleted
+  # from both the box2d world and locally
+  boxes.reject!(&:done)
+  exit if frame_count >= 908
+end
+
+class Boundary
+  extend Forwardable
+  def_delegators(:@app, :box2d, :fill, :rect, :rect_mode)
+  # A boundary is a simple rectangle with x, y, width, and height
+  attr_reader :x, :y, :w, :h, :b
+
+  def initialize(app, x ,y, w, h)
+    @app, @x ,@y, @w, @h = app, x ,y, w, h
+    # Create the body
+    bd = BodyDef.new
+    bd.position.set(box2d.processing_to_world(x, y))
+    @b = box2d.create_body(bd)
+    # Figure out the box2d coordinates
+    box2d_w = box2d.scale_to_world(w / 2)
+    box2d_h = box2d.scale_to_world(h / 2)
+    # Define the polygon
+    sd = PolygonShape.new
+    sd.setAsBox(box2d_w, box2d_h)
+    fd = FixtureDef.new
+    fd.shape = sd
+    fd.density = 0
+    fd.friction = 0.3
+    fd.restitution = 0.5
+    b.createFixture(fd)
+  end
+
+  # Draw the boundary, if it were at an angle we'd have to do something fancier
+  def display
+    fill(0)
+    rect_mode(Java::ProcessingCore::PConstants::CENTER)
+    rect(x, y, w, h)
+  end
+end
+
+# A rectangular box
+class Box
+  extend Forwardable
+  def_delegators(:@app, :box2d, :rect_mode, :rect,
+                 :push_matrix, :pop_matrix, :fill, :rotate,
+                 :stroke, :stroke_weight, :translate)
+  # We need to keep track of a Body and a width and height
+  attr_reader :body, :w, :h
+
+  # Constructor
+  def initialize(app, x, y)
+    @w = rand(4..16)
+    @h = rand(4..16)
+    @app = app
+    # Add the box to the box2d world
+    make_body(Vec2.new(x, y), w, h)
+  end
+
+  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 + w * h)
+    box2d.destroy_body(body)
+    true
+  end
+
+  # Drawing the box
+  def display
+    # We look at each body and get its screen position
+    pos = box2d.body_coord(body)
+    # Get its angle of rotation
+    a = body.angle
+    rect_mode(Java::ProcessingCore::PConstants::CENTER)
+    push_matrix
+    translate(pos.x, pos.y)
+    rotate(-a)
+    fill(175)
+    rect(0, 0, w, h)
+    pop_matrix
+  end
+
+  # This function adds the rectangle to the box2d world
+  def make_body(center, w, h)
+    # Define a polygon (this is what we use for a rectangle)
+    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)
+    # Define a fixture
+    fd = FixtureDef.new
+    fd.shape = sd
+    # Parameters that affect physics
+    fd.density = 1
+    fd.friction = 0.3
+    fd.restitution = 0.5
+    # Define the body and make it from the shape
+    bd = BodyDef.new
+    bd.type = BodyType::DYNAMIC
+    bd.position.set(box2d.processing_to_world(center))
+    cs = CircleShape.new
+    @body = box2d.create_body(bd)
+    body.create_fixture(fd)
+    # Give it some initial random velocity
+    body.setLinearVelocity(Vec2.new(rand(-5.0..5), rand(2.0..5)))
+    body.setAngularVelocity(rand(-5.0..5))
+  end
+end

data/examples/revolute_joint/box.rb

@@ -0,0 +1,68 @@
+# The Nature of Code
+# Daniel Shiffman
+# http://natureofcode.com
+require 'forwardable'
+
+# A rectangular box
+class Box
+  extend Forwardable
+  def_delegators(:@app, :push_matrix, :pop_matrix, :fill, :rotate, :box2d,
+                 :stroke_weight, :translate, :rect_mode, :stroke, :rect)
+  # We need to keep track of a Body and a width and height
+  attr_reader :body, :w, :h
+
+  # Constructor
+  def initialize(x, y, w, h, lock)
+    @w, @h = w, h
+    @app = $app
+    # Define and create the body
+    bd = BodyDef.new
+    bd.position.set(box2d.processing_to_world(Vec2.new(x, y)))
+    bd.type = lock ? BodyType::STATIC : BodyType::DYNAMIC
+
+    @body = box2d.createBody(bd)
+
+    # Define the shape -- a  (this is what we use for a rectangle)
+    sd = PolygonShape.new
+    box2dW = box2d.scale_to_world(w / 2)
+    box2dH = box2d.scale_to_world(h / 2)
+    sd.setAsBox(box2dW, box2dH)
+
+    # Define a fixture
+    fd = FixtureDef.new
+    fd.shape = sd
+    # Parameters that affect physics
+    fd.density = 1
+    fd.friction = 0.3
+    fd.restitution = 0.5
+
+    body.createFixture(fd)
+
+    # Give it some initial random velocity
+    body.setLinearVelocity(Vec2.new(rand(-5..5),rand(2..5)))
+    body.setAngularVelocity(rand(-5..5))
+  end
+
+  # This function removes the particle from the box2d world
+  def killBody
+    box2d.destroyBody(body)
+  end
+
+  # Drawing the box
+  def display
+    # We look at each body and get its screen position
+    pos = box2d.body_coord(body)
+    # Get its angle of rotation
+    a = body.getAngle
+
+    rect_mode(Java::ProcessingCore::PConstants::CENTER)
+    push_matrix
+    translate(pos.x,pos.y)
+    rotate(-a)
+    fill(127)
+    stroke(0)
+    stroke_weight(2)
+    rect(0,0,w,h)
+    pop_matrix
+  end
+end