pbox2d 0.4.2-java → 0.5.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1ff8899781cd0308635cb95b3f78b9e3789d345d
-  data.tar.gz: 37b9df883bb1730e4f7129aebe65acd7c8b6a86e
+  metadata.gz: 892dc4c6bb63dfa90f257605378cf40da48bed18
+  data.tar.gz: 58a5e3b1de46dad55499d945ca32f8bfc5dbe623
 SHA512:
-  metadata.gz: 9c6218dacd978b3c530fea1d4df318d6281c4e265a4140c9bc0a376487dbd9f76e1e8aedd28d06736b40d59c00da33421030e1ebe765431c102eeaeccccc26f1
-  data.tar.gz: 6ed60e48763528a00bdad9f0d6a93e49dfa8b5802d3acac0293bf49c13dd84161930f5bc37fad65efa4786acc5c536db3ce8ee5930131c89eaa6657fc822cb2d
+  metadata.gz: cc18b5cb955557edc6e2989591201cd8d397afe6317bf787816eafcf444b31d9f3a53412e9e65a872b0c52af1d906abd181545d43d5cf1b4348f11939d74b70d
+  data.tar.gz: 75b35aabdbe6c41bed94efeab684b5c533e8461106c488464c4a6bb74899eb83a860d0886ed77b78a6fe95c8a6f4a23985e5d5e31b04b9526d9898c839aca4f3

data/.gitignore

@@ -0,0 +1,15 @@
+*~
+*.jar
+*.gem
+*.swp
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/target/
+MANIFEST.MF

data/CHANGELOG.md

@@ -0,0 +1,37 @@
+### v0.5.0.pre
+
+Break compatability with ruby-processing. New build uses maven. Works with JRuby-9.0.3.0, processing-3.0.1 and jdk8.
+
+
+### v0.4.2
+
+Re-factor extension class, last release for ruby-processing (processing-2.2.1) getting read for JRubyArt version.
+
+### v0.4.1
+
+Favour explicit import of classes to package include.  Use forwardable in examples to make usable in both JRubyArt and ruby-processing, further to demonstrate alternative to including Processing::Proxy to get 'inner class' like access to processing methods, in own classes.
+
+### v0.3.1
+
+Need to be less specific about ruby-processing version
+
+### v0.3.0 (was v0.2.1 but bumped version because it features new functionality)
+
+Finally got ContactListener to work (currently best plan is to create your own CustomListener, see example test_contact)
+
+### v0.2.0
+
+Moving away from Shiffman Box2D design, to create a more ruby like interface added Step and Option classes to make it easier to initialize runtime and step options. On the ruby side options may/should be set with hash input. Gravity may still be set dynamically, but unless it is going to change it should be set via `init_options`. Unless `init_options` or `step_options` are set, defaults on java side are used.
+
+### v0.1.1
+
+Make common classes avaiable directly, expose sketch eight.
+
+### v0.1.0
+
+Now require 'pbox2d' matches gem name, refactor java methods by removing unnecessary get/set/pixel. Also prefer to world and to processing. Adjust examples, bump version to denote significant change.
+
+
+### v0.0.1
+
+First release, works but require name 'box2d' doesn't match gem name it is confusing

data/CONTRIBUTING.md

@@ -0,0 +1,30 @@
+## Contributing
+In the spirit of [free software][free-sw], **everyone** is encouraged to help improve this project.
+
+Here are some ways *you* can contribute:
+
+* by reporting bugs
+* by suggesting/implementing new features 
+* by writing or editing documentation
+* by contributing examples ( _show your creativity, or translate someone elses masterpiece_ )
+* by closing [issues][]
+* by supporting [Processing.org][], nothing to do with us but we rely on them
+
+## Submitting an Issue
+We use the [GitHub issue tracker][issues] to track bugs and features. Before
+submitting a bug report or feature request, check to make sure it hasn't
+already been submitted. When submitting a bug report, ideally include a [Gist][]
+that includes a stack trace and any details that may be necessary to reproduce
+the bug, including your gem version, Ruby version, and operating system.
+
+
+## Submitting a Pull Request
+1. [Fork the repository.][fork]
+2. [Submit a pull request.][pr]
+
+[free-sw]: http://www.fsf.org/licensing/essays/free-sw.html
+[issues]: https://github.com/ruby-processing/jbox2d/issues
+[gist]: https://gist.github.com/
+[fork]: http://help.github.com/fork-a-repo/
+[pr]: http://help.github.com/send-pull-requests/
+[processing.org]: http://processing.org/foundation/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in pbox2d.gemspec
+gemspec

data/LICENCE

@@ -0,0 +1,25 @@
+JBox2d binary licence
+
+Copyright (c) 2014, Daniel Murphy
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions and the following disclaimer in the documentation and/or
+  other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/LICENSE.md

@@ -31,6 +31,4 @@ recognized licences.....
 For my part I lean toward GPL3 but MIT is OK and matches ruby-processing and
 vanilla processing.
 
-Copyright (c) 2014, Martin Prout
-
-
+Copyright (c) 2014-2015, Martin Prout

data/README.md

@@ -30,7 +30,7 @@ Copyright (c) 2014 Daniel Shiffman
  
 This gem was created by Martin Prout
 
-Copyright (c) 2014-2015 Martin Prout
+Copyright (c) 2015 Martin Prout
 
 ### To compile
 
@@ -60,6 +60,6 @@ The other thing you should know is there is a mismatch between the physics world
 [Nature of Code book]:http://natureofcode.com/
 [Sandi Metz]:http://www.poodr.com/
 [this book]:http://www.crcpress.com/product/isbn/9781466565760
-[zip]:https://github.com/ruby-processing/jbox2d/archive/0.4.2.zip
-[tar]:https://github.com/ruby-processing/jbox2d/archive/0.4.2.tar.gz
+[zip]:https://github.com/ruby-processing/jbox2d/archive/0.5.0-pre.zip
+[tar]:https://github.com/ruby-processing/jbox2d/archive/0.5.0-pre.tar.gz
 [Wiki]:https://github.com/ruby-processing/jbox2d/wiki

data/Rakefile

@@ -2,100 +2,38 @@ require 'rubygems'
 require 'rake'
 require 'rake/clean'
 require 'rubygems/package_task'
-require 'rdoc/task'
 require 'rake/testtask'
-require 'rspec/core/rake_task'
-require_relative 'lib/pbox2d/version'
-
-spec = Gem::Specification.new do |s|
-  s.name = 'pbox2d'
-  s.version = Pbox2D::VERSION
-  s.has_rdoc = true
-  s.extra_rdoc_files = ['README.md', 'LICENSE.md']
-  s.summary = 'jbox2d wrapped in a gem for ruby-processing'
-  s.description = <<-EOF
-"An exemplar for how processing/java libraries can be made available
-for use in ruby-processing. In this example avoiding an overdose of java 
-reflection by letting jruby sugar implement an interface"
-EOF
-  s.license = 'MIT'
-  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', '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', '>= 2.6.4'
-  s.add_development_dependency "rake", "~> 10.3"
-  s.add_development_dependency "rake-compiler", "~> 0.9"
-  s.platform='java'
-  s.requirements << 'A decent graphics card'
-  s.requirements << 'java runtime >= 1.7+'
-  s.requirements << 'processing = 2.2.1+'
-end
-
-# -*- ruby -*-
-
-require 'java'
-require 'rake/javaextensiontask'
 
-# -*- encoding: utf-8 -*-
-require 'psych'
+require_relative 'lib/pbox2d/version'
 
-def copy_jars(name, dest)
-  conf = '~/.jruby_art/config.yml'
-  begin
-    path = File.expand_path(conf)
-    rp_config = (Psych.load_file(path))
-    source= "#{rp_config["PROCESSING_ROOT"]}/core/library/"    
-  rescue
-    raise "WARNING: you must set PROCESSING_ROOT in #{conf} compile"
+def create_manifest
+  title =  'Implementation-Title: box2d (pbox2d java extension for JRubyArt)'
+  version =  format('Implementation-Version: %s', Pbox2d::VERSION)   
+  file = File.open('MANIFEST.MF', 'w') do |f|
+    f.puts(title)
+    f.puts(version)
   end
-	body = proc {
-	  Dir["#{source}/core.jar"].each do |f|
-	    puts "Copying #{f} To #{dest}"
-	    FileUtils.cp f, dest
-	  end
-	}
-	Rake::Task.define_task(name, &body)	
 end
 
-copy_jars(:processing_jars, 'lib')
+task default: [:init, :compile, :gem]
 
-Rake::JavaExtensionTask.new('processing') do |ext|
-  jars = FileList['lib/*.jar']
-  ext.classpath = jars.map { |x| File.expand_path x}.join ':'
-  ext.name = 'box2d'
-  ext.debug = true
-  ext.lib_dir = 'lib'
-  ext.source_version='1.7'
-  ext.target_version='1.7'
+desc 'Create Manifest'
+task :init do
+  create_manifest
 end
 
-Gem::PackageTask.new(spec) do |p|
-  p.gem_spec = spec
-  p.need_tar = true
-  p.need_zip = true
+desc 'Compile'
+task :compile do
+  sh "mvn package"
+  sh "mvn dependency:copy"
+  sh "mv target/box2d.jar lib"
 end
 
-Rake::RDocTask.new do |rdoc|
-  files = ['README.md', 'LICENSE.md'] + FileList['lib/**/*.rb']
-  
-  rdoc.rdoc_files.add(files)
-  rdoc.main = "README.md" # page to start on
-  rdoc.title = "Box2D Docs"
-  rdoc.rdoc_dir = 'doc/rdoc' # rdoc output folder
-  rdoc.options << '--line-numbers'
+desc 'Build Gem'
+task :gem do
+  sh "gem build pbox2d.gemspec"
 end
 
 Rake::TestTask.new do |t|
   t.test_files = FileList['test/**/*.rb']
 end
-
-RSpec::Core::RakeTask.new do |spec|
-  spec.pattern = 'spec/*_spec.rb'
-  spec.rspec_opts = [Dir["lib"].to_a.join(':')]
-end
-
-

data/examples/README.md

@@ -0,0 +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.

data/examples/bumpy_surface_noise.rb

@@ -5,11 +5,10 @@
 require 'pbox2d'
 require_relative 'lib/surface'
 
-attr_reader :surface, :box2d, :particles
+attr_reader :srface, :box2d, :particles
 
 def setup
-  size(500, 300)
-  smooth 4
+  sketch_title 'Bumpy Surface Noise'  
   # Initialize box2d physics and create the world
   @box2d = Box2D.new(self)
   box2d.init_options(gravity: [0, -20])
@@ -18,16 +17,16 @@ def setup
   # box2d.gravity([0, -20])
   # Create the empty list
   @particles = []
-  # Create the surface
-  @surface = Surface.new(self)
+  # 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 surface
-  surface.display
+  # 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
@@ -39,3 +38,8 @@ def draw
   fill(0)
   text(format('framerate: %d', frame_rate), 12, 16)
 end
+
+def settings
+  size(500, 300)
+  smooth 4
+end

data/examples/collision_listening.rb

@@ -0,0 +1,30 @@
+require 'pbox2d'
+require 'forwardable'
+require_relative 'lib/custom_listener'
+require_relative 'lib/particle'
+require_relative 'lib/boundary'
+
+attr_reader :box2d, :particles, :wall
+
+Vect = Struct.new(:x, :y)
+
+def settings
+  size 400, 400
+end
+
+def setup
+  sketch_title 'Collision Listening'
+  @box2d = Box2D.new(self)
+  box2d.create_world
+  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

data/examples/data/java_args.txt

@@ -0,0 +1,2 @@
+-XX:CompileCommand=dontinline,org.jruby.runtime.invokedynamic.InvokeDynamicSupport::invocationFallback 
+

data/examples/distance_joint/distance_joint.rb

@@ -14,16 +14,19 @@ require_relative 'particle_system'
 
 attr_reader :box2d, :boundaries, :system
 
-def setup
+def settings
   size(640, 360)
+end
+
+def setup
   # Initialize box2d physics and create the world
   @box2d = Box2D.new(self)
   box2d.create_world
   @system = ParticleSystem.new
-  @boundaries = [
-    Boundary.new(width / 4, height - 5, width / 2 - 50, 10),
-    Boundary.new(3 * width / 4, height - 50, width / 2 - 50, 10)
-  ]
+  @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

data/examples/lib/boundary.rb

@@ -1,28 +1,37 @@
-# The boundary class is used to create fixtures
 class Boundary
-  extend Forwardable
-  def_delegators(:@app, :fill, :stroke, :rect, :rect_mode, :box2d)
-  attr_reader :pos, :size, :b, :x, :y, :w, :h
-  def initialize(app, x, y, w, h)
-    @app, @x, @y, @w, @h = app, x, y, w, h
+  include Processing::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
     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)
+    # Figure out the box2d coordinates
+    box2d_w = box2d.scale_to_world(size.x / 2)
+    box2d_h = box2d.scale_to_world(size.y / 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.position.set(box2d.processing_to_world(x, y))
+    bd.angle = a
+    bd.position.set(box2d.processing_to_world(pos.x, pos.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
+  # Draw the boundary, it doesn't move so we don't have to ask the Body for location
   def display
     fill(0)
     stroke(0)
-    rect_mode(Java::ProcessingCore::PConstants::CENTER)
-    rect(x, y, w, h)
+    stroke_weight(1)
+    rect_mode(CENTER)
+    a = b.get_angle
+    push_matrix
+    translate(pos.x, pos.y)
+    rotate(-a)
+    rect(0, 0, size.x,size.y)
+    pop_matrix
   end
 end

data/examples/lib/box.rb

@@ -1,6 +1,5 @@
 # A Box class, note how to access class ParticleGroupDef in jruby
-# which is imported into the PB module and not into global namespace
-# mainly because of probable name conflict with ParticleSystem
+# which is imported into PB module (not in global namespace)
 class Box
   attr_accessor :pg
   def initialize(b2d, x, y)

data/examples/lib/custom_listener.rb

@@ -0,0 +1,29 @@
+# A custom listener allows us to get the physics engine to
+# to call our code, on say contact (collisions)
+class CustomListener
+  include ContactListener
+
+  def begin_contact(cp)
+    # Get both fixtures
+    f1 = cp.getFixtureA
+    f2 = cp.getFixtureB
+    # Get both bodies
+    b1 = f1.getBody
+    b2 = f2.getBody
+    # Get our objects that reference these bodies
+    o1 = b1.getUserData
+    o2 = b2.getUserData
+    return unless [o1, o2].all? { |obj| obj.respond_to?(:change) }
+    o1.change
+    o2.change
+  end
+
+  def end_contact(_cp)
+  end
+
+  def pre_solve(_cp, _m)
+  end
+
+  def post_solve(_cp, _ci)
+  end
+end

data/examples/lib/custom_shape.rb

@@ -4,9 +4,9 @@ class CustomShape
   attr_reader :body, :box2d
 
   # Constructor
-  def initialize(app, x, y)
+  def initialize(b2d, x, y)
     # Add the box to the box2d world
-    @box2d = app.box2d
+    @box2d = b2d
     make_body(Vec2.new(x, y))
   end
 
@@ -69,4 +69,6 @@ class CustomShape
     body.set_linear_velocity(Vec2.new(rand(-5.0..5), rand(2.0..5)))
     body.set_angular_velocity(rand(-5.0..5))
   end
-end
+end
+
+

data/examples/lib/particle.rb

@@ -0,0 +1,77 @@
+# Note the particle class change method is use to change color to red
+# when two particles collide (no change just hitting boundary)
+class Particle
+  extend Forwardable
+  def_delegators(:@app, :box2d, :begin_shape, :color, :end_shape, :line, :pop_matrix,
+                 :ellipse, :translate, :rotate, :stroke, :push_matrix, :fill,
+                 :no_fill, :stroke_weight)
+  attr_accessor :body
+  attr_reader :radius, :col
+
+  def initialize(app, x, y, r)
+    @app, @x, @y, @radius = app, x, y, r
+    # This function puts the particle in the Box2d world
+    make_body(x, y, radius)
+    @col = color('#c0c0c0') # silvergrey
+    body.setUserData(self)
+  end
+
+  # This function removes the particle from the box2d world
+  def kill_body
+    box2d.destroy_body(body)
+  end
+
+  # Change color when hit
+  def change
+    @col = color('#cc0000') # red
+  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 + radius * 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(col)
+    stroke(0)
+    stroke_weight(1)
+    ellipse(0, 0, radius * 2, radius * 2)
+    # Let's add a line so we can see the rotation
+    line(0, 0, radius, 0)
+    pop_matrix
+  end
+
+  # Here's our function that adds the particle to the Box2D world
+  def make_body(x, y, r)
+    # Define a body
+    bd = BodyDef.new
+    # Set its position
+    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)
+    body.set_angular_velocity(rand(-10.0..10))
+  end
+end