pbox2d 0.9.1-java → 1.0.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a73dd0d1fe00250537080b3fd9a8adba5ce18e4b
-  data.tar.gz: 585d07c27d97c01cc0cd3514571317b6a2b5b8ab
+  metadata.gz: e0aed216a0450186a793eb195a8e9c5ec017e63a
+  data.tar.gz: f00273168b47d8cfce2601ac2956525497aa8f66
 SHA512:
-  metadata.gz: 58f57f93c0ebbed00ecfd76f42ce6bedcba5bcf050888ebaa910c8bdea2d1ecef5b580ac14ee2a98f9abccb3f0fc46cfe673ca22714b7031684e3c3f13305146
-  data.tar.gz: 0b4e7789ff8fa34053811b79cb4e69e74b23aa0829b0143bcb92b70e667a32fc7bf6dbc9f7f7b2f43b50a50a0c24d541728e0247a89a73f33e8eeb7f34024503
+  metadata.gz: 68efe632c0ea5cca8e9e01a3176ef1cae1e43462bd3b7dce965fde7b6cd20dcc40ba525609d3198e9fd6613f92020eabf1d91a62536580b43fec1a5fdc903ca6
+  data.tar.gz: 4074f71a4a852abd9eeb3a8bcce7047a48c4b3ebb86719a7d89b27d3a9fdf5f23c9145cc83bec3f4d66b33c1b99a8ebcc1aaa6d506ab7e80344912aae83e1906

data/.travis.yml

@@ -1,12 +1,8 @@
 language: ruby
 sudo: false
-addons:
-  apt:
-    packages:
-      -oracle-java8-installer
 
 rvm: 
-  - jruby-9.0.5.0
+  - jruby-9.1.6.0
 jdk:
   - oraclejdk8
 os:

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+### v1.0.0
+
+Specify github pages as home, update to latest jruby-9.1.8.0 and processing-3.3
+
 ### v0.9.1
 
 Update maven artifacts

data/README.md

@@ -3,9 +3,11 @@
 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 (now using a maven build).
 ![liquidy](http://4.bp.blogspot.com/-dwnDQZVugwo/VFXrDxGOy4I/AAAAAAAAEgo/irsZxW_WLOA/s400/liquidy.png)
 
-
+![Travis CI](https://travis-ci.org/ruby-processing/jbox2d.svg)
 [![Gem Version](https://badge.fury.io/rb/pbox2d.svg)](http://badge.fury.io/rb/pbox2d)
 
+Build fails because latest processing is not available from maven central.
+
 ### Web Links
 
 [JBox2D Home][]
@@ -14,8 +16,7 @@ Here we demonstrate how to use JBox2D library as a rubygem. This approach could
 
 [Box2D for processing on github][]
 
-Downloads including examples [zip][] and [tar][]
-
+Downloads including examples [zip][]
 [Wiki][]
 
 ### Licensing
@@ -30,7 +31,7 @@ Copyright (c) 2014 Daniel Shiffman
  
 This gem was created by Martin Prout
 
-Copyright (c) 2015/16 Martin Prout
+Copyright (c) 2015/17 Martin Prout
 
 ### To compile
 
@@ -60,6 +61,5 @@ 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.9.1.zip
-[tar]:https://github.com/ruby-processing/jbox2d/archive/0.9.1.tar.gz
+[zip]:https://github.com/ruby-processing/jbox2d/archive/master.zip
 [Wiki]:https://github.com/ruby-processing/jbox2d/wiki

data/docs/.gitignore

@@ -0,0 +1,6 @@
+
+*~
+_site
+.sass-cache
+.jekyll-metadata
+Gemfile.lock

data/docs/_classes/pbox2d.md

@@ -0,0 +1,375 @@
+---
+layout: page
+title: "PBox2D"
+permalink: /classes/pbox2d/
+---
+
+The PBox2D class is a simple wrapper to help integrate the JBox2D world with ruby implementations of processing (_JRubyArt and propane_). Use the [WorldBuilder][world_builder] in your sketch setup to create an instance of this class.
+
+```ruby
+# Ruby version of java wrapper allows us to have more
+# rubified interface, also needed for add_listener
+class Box2D < Java::ProcessingBox2d::Box2DProcessing
+  field_accessor :world # allow access to protected variable
+
+  def init_options(args = {})
+    args = defaults.merge(args)
+    set_options(args[:scale],
+                args[:gravity].to_java(Java::float),
+                args[:warm],
+                args[:continuous]
+               )
+  end
+
+  def step_options(args = {})
+    default_step.merge(args)
+    set_step(args[:time_step], args[:velocity_iter], args[:position_iter])
+  end
+
+  def defaults
+    { scale: 10.0, gravity: [0, -10], warm: true, continuous: true }
+  end
+
+  def default_step
+    { time_step: 1.0 / 60, velocity_iter: 8, position_iter: 10 }
+  end
+
+  def gravity(args)
+    change_gravity(args.to_java(Java::float))
+  end
+
+  def add_listener(listener)
+    # in combination with field accessor we can access protected world
+    world.setContactListener(listener)
+  end
+
+  def version
+    format('pbox2d version %s', Pbox2d::VERSION)
+  end
+end
+```
+
+The java class
+```java
+
+package processing.box2d;
+
+import org.jbox2d.common.Transform;
+import org.jbox2d.common.Vec2;
+import org.jbox2d.dynamics.Body;
+import org.jbox2d.dynamics.BodyDef;
+import org.jbox2d.dynamics.World;
+import org.jbox2d.dynamics.joints.Joint;
+import org.jbox2d.dynamics.joints.JointDef;
+
+import processing.core.PApplet;
+
+/**
+ * Loosely based on Box2D-for-processing by Dan Shiffman
+ *
+ * @author Martin Prout
+ */
+public abstract class Box2DProcessing {
+
+    private final PApplet parent;
+    private Options options;
+    private Step stepO;
+    private final float height;
+    private final float width;
+    /**
+     * The Box2D world (we might need public access for our ContactListener)
+     */
+    protected World world;
+
+    /**
+     * Scale between processing sketch and physics world
+     */
+    private float scaleFactor;// = 10.0f;
+
+    /**
+     * Adjust for processing.org unfathomable choice of y-axis direction
+     */
+    private final float yFlip;// = -1.0f; //flip y coordinate
+
+    /**
+     * Controls access to processing pre loop (via reflection)
+     */
+    private boolean isActive = false;
+
+    private Body groundBody;
+
+    /**
+     *
+     * @param p PApplet
+     */
+    public Box2DProcessing(PApplet p) {
+        parent = p;
+        height = p.height;
+        width = p.width;
+        yFlip = -1;
+        setActive(true);
+    }
+
+    /**
+     * Abstract method implement on ruby side
+     *
+     * @param listener Custom Listener, Sketch?
+     */
+    public abstract void addListener(org.jbox2d.callbacks.ContactListener listener);
+
+    /**
+     *
+     * @param scale float
+     * @param gravity float[]
+     * @param warmStart boolean
+     * @param continuous boolean
+     */
+    protected void setOptions(float scale, float[] gravity, boolean warmStart, boolean continuous) {
+        options = new Options(scale, gravity, warmStart, continuous);
+    }
+
+    /**
+     *
+     * @param timeStep float
+     * @param velocity int
+     * @param position int
+     */
+    protected void setStep(float timeStep, int velocity, int position) {
+        stepO = new Step(timeStep, velocity, position);
+    }
+
+    /**
+     * This is the all important physics "step" function Says to move ahead one
+     * unit in time Default
+     */
+    protected void step() {
+        if (stepO == null) {
+            stepO = new Step();
+        }
+        world.step(stepO.timeStep, stepO.velIters, stepO.posIters);
+        world.clearForces();
+    }
+
+    /**
+     * Create a world
+     */
+    public void createWorld() {
+        if (options == null) {
+            options = new Options();
+        }
+        Vec2 gravity = new Vec2(options.gravity[0], options.gravity[1]);
+        scaleFactor = options.scaleFactor;
+        world = new World(gravity);
+        world.setWarmStarting(options.warm);
+        world.setContinuousPhysics(options.continuous);
+        BodyDef bodyDef = new BodyDef();
+        groundBody = world.createBody(bodyDef);
+    }
+
+    /**
+     *
+     * @return Body
+     */
+    public Body groundBody() {
+        return groundBody;
+    }
+
+    /**
+     * Set the gravity (this can change in real-time)
+     *
+     * @param gravity float[]
+     */
+    protected void changeGravity(float[] gravity) {
+        world.setGravity(new Vec2(gravity[0], gravity[1]));
+    }
+
+    /**
+     * Box2d has its own coordinate system and we have to move back and forth
+     * between them to convert from Box2d world to processing pixel space
+     *
+     * @param world Vec2
+     * @return Vec2
+     */
+    public Vec2 worldToProcessing(Vec2 world) {
+        return worldToProcessing(world.x, world.y);
+    }
+
+    /**
+     * Box2d has its own coordinate system and we have to move back and forth
+     * between them to convert from Box2d world to processing pixel space
+     * Note reverse Y mapping (processing poxy coord system again)
+     * @param worldX float
+     * @param worldY float
+     * @return Vec2
+     */
+    public Vec2 worldToProcessing(float worldX, float worldY) {
+        float pixelX = map(worldX, 0f, 1f, parent.width / 2, parent.width / 2 + scaleFactor);
+        float pixelY = map(worldY, 1f, 0f, parent.height / 2, parent.height / 2 + scaleFactor);
+        return new Vec2(pixelX, pixelY);
+    }
+
+    /**
+     * convert Coordinate from pixel space to box2d world
+     *
+     * @param screen Vec2
+     * @return Vec2
+     */
+    public Vec2 processingToWorld(Vec2 screen) {
+        return processingToWorld(screen.x, screen.y);
+    }
+
+    /**
+     * Note reverse Y mapping (processing poxy coord system again)
+     * @param pixelX float
+     * @param pixelY float
+     * @return Vec2
+     */
+    public Vec2 processingToWorld(float pixelX, float pixelY) {
+        float worldX = map(pixelX, parent.width / 2, parent.width / 2 + scaleFactor, 0f, 1f);
+        float worldY = map(pixelY, parent.height / 2, parent.height / 2 + scaleFactor, 1f, 0f);
+        return new Vec2(worldX, worldY);
+    }
+
+    /**
+     * Scale from processing to world
+     *
+     * @param val float
+     * @return float
+     */
+    public float scaleToWorld(float val) {
+        return val / scaleFactor;
+    }
+
+    /**
+     * Scale from world to processing
+     *
+     * @param val float
+     * @return float
+     */
+    public float scaleToProcessing(float val) {
+        return val * scaleFactor;
+    }
+
+    /**
+     * Vector scale between two worlds
+     *
+     * @param v Vec2
+     * @return Vec2
+     */
+    public Vec2 vectorToWorld(Vec2 v) {
+        Vec2 u = new Vec2(v.x / scaleFactor, v.y / scaleFactor);
+        u.y *= yFlip;
+        return u;
+    }
+
+    /**
+     * Translate from world coords to processing as a Vec2
+     *
+     * @param x float
+     * @param y float
+     * @return Vec
+     */
+    public Vec2 vectorToWorld(float x, float y) {
+        Vec2 u = new Vec2(x / scaleFactor, y / scaleFactor);
+        u.y *= yFlip;
+        return u;
+    }
+
+    /**
+     * Translate from world to processing as a Vec2
+     *
+     * @param v Vec
+     * @return Vec
+     */
+    public Vec2 vectorToProcessing(Vec2 v) {
+        Vec2 u = new Vec2(v.x * scaleFactor, v.y * scaleFactor);
+        u.y *= yFlip;
+        return u;
+    }
+
+    /**
+     * A common task we have to do a lot
+     *
+     * @param bd BodyDef
+     * @return Body
+     */
+    public Body createBody(BodyDef bd) {
+        return world.createBody(bd);
+    }
+
+    /**
+     * A common task we have to do a lot
+     *
+     * @param jd JointDef
+     * @return World
+     */
+    public Joint createJoint(JointDef jd) {
+        return world.createJoint(jd);
+    }
+
+    /**
+     *
+     * @param b Body
+     * @return body coord as Vec2
+     */
+    public Vec2 bodyCoord(Body b) {
+        Transform xf = b.getTransform();
+        return worldToProcessing(xf.p);
+    }
+
+    /**
+     *
+     * @param b Body
+     */
+    public void destroyBody(Body b) {
+        world.destroyBody(b);
+    }
+
+    /**
+     * Access the processing pre loop by java reflection
+     */
+    public void pre() {
+        step();
+    }
+
+    /**
+     * Recommended inclusion in a processing library
+     */
+    public void dispose() {
+        setActive(false);
+    }
+
+    /**
+     *
+     * @return height float
+     */
+    public float height() {
+        return height;
+    }
+
+    /**
+     *
+     * @return width float
+     */
+    public float width() {
+        return width;
+    }
+
+    private float map(float val, float startIn, float endIn, float startOut, float endOut) {
+        return startOut + (endOut - startOut) * ((val - startIn) / (endIn - startIn));
+    }
+
+    private void setActive(boolean active) {
+        if (active != isActive) {
+            isActive = active;
+            if (active) {
+                parent.registerMethod("dispose", this);
+                parent.registerMethod("pre", this);
+            } else {
+                parent.unregisterMethod("pre", this);
+            }
+        }
+    }
+}
+
+```