revise physics

Author: monkstone

samples/external_library/ruby_gem/jbox2d/README.md

@@ -1,3 +1,7 @@
+### Source of Sketches
+
+These sketches have been translated from 'vanilla processing sketches' by Dan Shiffman.  The original sketches were designed to run with the Box2D-for-processing library which has a subtlely different interface from the pbox2d gem. There is probably scope for further refactoring of most of the sketches to make them more ruby-like (the mouse_joint example has perhaps travelled furthest from the original version). 
+
 ### java_args.txt
 
 The `data` folder contains java_args.txt, which currently silently enables the OpenGl-based pipeline using `-Dsun.java2d.opengl=true` add any other java args here, use `True` instead of `true` to get a message.

samples/external_library/ruby_gem/jbox2d/bumpy_surface_noise.rb

@@ -19,7 +19,7 @@ def setup
   # Create the empty list
   @particles = []
   # Create the surface
-  @surface = Surface.new(box2d)
+  @surface = Surface.new(self)
 end
 
 def draw
@@ -29,7 +29,7 @@ def draw
   # Draw the surface
   surface.display
   # NB ? 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?
+  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

samples/external_library/ruby_gem/jbox2d/collision_listening.rb

@@ -0,0 +1,23 @@
+require 'pbox2d'
+require_relative 'lib/custom_listener'
+require_relative 'lib/particle'
+require_relative 'lib/boundary'
+
+attr_reader :box2d, :particles, :wall
+
+def setup
+  size 400, 400
+  @box2d = Box2D.new(self)
+  box2d.create_world
+  box2d.add_listener(CustomListener.new)
+  @particles = []
+  @wall = Boundary.new(box2d, width / 2, height - 5, width, 10)
+end
+
+def draw
+  background(255)
+  particles << Particle.new(box2d, rand(width), 20, rand(4..8)) if rand < 0.1
+  particles.each{ |p| p.display(self) }
+  particles.reject!(&:done)
+  wall.display(self)
+end

samples/external_library/ruby_gem/jbox2d/data/java_args.txt

@@ -1 +1,2 @@
--Dsun.java2d.opengl=true
+-XX:CompileCommand=dontinline,org.jruby.runtime.invokedynamic.InvokeDynamicSupport::invocationFallback 
+

samples/external_library/ruby_gem/jbox2d/distance_joint/boundary.rb

@@ -1,32 +1,31 @@
 # 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)
+    box2dw = box2d.scale_to_world(w / 2)
+    box2dh = box2d.scale_to_world(h / 2)
     # We're just a box
-    sd.setAsBox(box2dW, box2dH)
+    sd.setAsBox(box2dw, box2dh)
     # Create the body
     bd = BodyDef.new
     bd.type = BodyType::STATIC
-    bd.position.set(box2d.processing_to_world(x,y))
+    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)
+    b.create_fixture(sd, 1)
   end
 
   # Draw the boundary, if it were at an angle we'd have to do something fancier

samples/external_library/ruby_gem/jbox2d/distance_joint/distance_joint.rb

@@ -2,22 +2,24 @@
 # Daniel Shiffman
 # http://natureofcode.com
 
-# Example demonstrating distance joints 
+# Example demonstrating distance joints
 # A bridge is formed by connected a series of particles with joints
 
 require 'pbox2d'
+require 'forwardable'
 require_relative 'boundary'
 require_relative 'pair'
 require_relative 'particle'
+require_relative 'particle_system'
 
-attr_reader :box2d, :boundaries, :pairs
+attr_reader :box2d, :boundaries, :system
 
 def setup
   size(640, 360)
   # Initialize box2d physics and create the world
   @box2d = Box2D.new(self)
   box2d.create_world
-  @pairs = []
+  @system = ParticleSystem.new
   @boundaries = []
   # Add a bunch of fixed boundaries
   boundaries << Boundary.new(width / 4, height - 5, width / 2 - 50, 10)
@@ -26,13 +28,13 @@ def setup
 
 def draw
   background(255)
-  pairs.each(&:display)
+  system.run
   # 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)
+  system.add_pair(mouse_x, mouse_y)
 end

samples/external_library/ruby_gem/jbox2d/distance_joint/pair.rb

@@ -1,13 +1,12 @@
 # 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
+  attr_reader :p1, :p2, :len, :joint
   # Chain constructor
   def initialize(x, y)
     @app = $app
@@ -19,13 +18,34 @@ def initialize(x, y)
     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.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)
+    # 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
@@ -38,4 +58,3 @@ def display
     p2.display
   end
 end
-

samples/external_library/ruby_gem/jbox2d/distance_joint/particle.rb

@@ -1,7 +1,6 @@
 # The Nature of Code
 # Daniel Shiffman
 # http://natureofcode.com
-require 'forwardable'
 
 # A circular particle
 class Particle
@@ -10,28 +9,28 @@ class Particle
                  :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.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)))
@@ -41,7 +40,7 @@ def initialize(x, y)
   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
@@ -71,5 +70,3 @@ def display
     pop_matrix
   end
 end
-
-

samples/external_library/ruby_gem/jbox2d/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

samples/external_library/ruby_gem/jbox2d/lib/boundary.rb

@@ -1,9 +1,12 @@
+require 'forwardable'
+
 # The boundary class is used to create fixtures
 class Boundary
-  include Processing::Proxy
-  attr_reader :box2d, :x, :y, :w, :h, :b
-  def initialize(b2d, x, y, w, h)
-    @box2d, @x, @y, @w, @h = b2d, x, y, w, h
+  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)
@@ -21,7 +24,7 @@ def initialize(b2d, x, y, w, h)
   def display
     fill(0)
     stroke(0)
-    rect_mode(CENTER)
+    rect_mode(Java::ProcessingCore::PConstants::CENTER)
     rect(x, y, w, h)
   end
 end