pbox2d 0.4.2-java → 0.5.0-java

data/pom.xml

@@ -0,0 +1,146 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>org.ruby-processing</groupId>
+  <artifactId>box2d</artifactId>
+  <version>0.5.0-SNAPSHOT</version>
+  <packaging>jar</packaging>
+  <description>
+    jbox2d-library for JRubyArt
+  </description>
+
+  <parent>
+    <groupId>org.sonatype.oss</groupId>
+    <artifactId>oss-parent</artifactId>
+    <version>7</version>
+  </parent>
+
+  <issueManagement>
+    <system>Github</system>
+    <url>https://github.com/ruby-processing/jbox2d/issues</url>
+  </issueManagement>
+
+  <scm>
+    <connection>scm:git:git://github.com/ruby-processing/jbox2d.git</connection>
+    <developerConnection>scm:git:git@github.com:ruby-processing/jbox2d.git</developerConnection>
+    <url>https://github.com/ruby-processing/jbox2d</url>
+  </scm>
+
+  <licenses>
+    <license>
+      <name>Simplified BSD License</name>
+      <url>http://www.opensource.org/licenses/bsd-license.php</url>
+    </license>
+  </licenses>
+
+  <developers>
+    <developer>
+      <id>monkstone</id>
+      <name>Martin Prout</name>
+      <email>martin_p@lineone.net</email>
+    </developer>
+  </developers>
+
+  <dependencies>
+    <dependency>
+      <groupId>org.jbox2d</groupId>
+      <artifactId>jbox2d-library</artifactId>
+      <version>2.3.1-SNAPSHOT</version>
+    </dependency>
+    <dependency>
+      <groupId>org.processing</groupId>
+      <artifactId>core</artifactId>
+      <scope>system</scope>
+      <version>3.0.1</version>
+      <systemPath>${processing.home}/core/library/core.jar</systemPath>
+    </dependency>
+  </dependencies>
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <maven.compiler.source>1.8</maven.compiler.source>
+    <maven.compiler.target>1.8</maven.compiler.target>
+    <!-- for Mac developers, non Archlinux and Windows can probably figure it out
+    <processing.home>/Applications/Processing.app/Contents/Java</processing.home> 
+    -->
+    <processing.home>/usr/share/processing</processing.home>
+  </properties>
+  <build>
+    <sourceDirectory>src</sourceDirectory>
+    <finalName>box2d</finalName>
+    <extensions>
+      <extension>
+        <groupId>org.apache.maven.wagon</groupId>
+        <artifactId>wagon-webdav-jackrabbit</artifactId>
+        <version>2.1</version>
+      </extension>
+    </extensions>
+    <plugins>
+      <plugin>
+        <artifactId>maven-source-plugin</artifactId>
+        <version>2.2.1</version>
+        <executions>
+          <execution>
+            <id>attach-sources</id>
+            <goals>
+              <goal>jar</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <artifactId>maven-javadoc-plugin</artifactId>
+        <version>2.9</version>
+        <executions>
+          <execution>
+            <id>attach-javadocs</id>
+            <goals>
+              <goal>jar</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.1</version>
+        <configuration>
+          <source>1.8</source>
+          <target>1.8</target>
+        </configuration>
+      </plugin>
+      <plugin>
+        <artifactId>maven-jar-plugin</artifactId>
+        <version>2.4</version>
+        <configuration>
+          <archive>
+            <manifestFile>MANIFEST.MF</manifestFile>
+          </archive>
+        </configuration>
+      </plugin>
+      <plugin>
+        <artifactId>maven-resources-plugin</artifactId>
+        <version>2.6</version>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-dependency-plugin</artifactId>
+        <version>2.10</version>
+        <executions>
+          <execution>
+            <id>default-cli</id>
+            <configuration>
+              <artifactItems>
+                <artifactItem>
+                  <groupId>org.jbox2d</groupId>
+                  <artifactId>jbox2d-library</artifactId>
+                  <version>2.3.1-SNAPSHOT</version>
+                  <type>jar</type>
+                  <outputDirectory>lib</outputDirectory>
+                </artifactItem>
+              </artifactItems>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
+</project>

data/src/processing/box2d/Box2DProcessing.java

@@ -0,0 +1,319 @@
+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);
+            }
+        }
+    }
+}

data/src/processing/box2d/Options.java

@@ -0,0 +1,52 @@
+package processing.box2d;
+
+/**
+ * 
+ * @author Martin Prout
+ */
+public class Options {
+
+    /**
+     * Continuous physics
+     */
+    public final boolean continuous;
+
+    /**
+     * Warm start
+     */
+    public final boolean warm;
+
+    /**
+     * gravity as an array of float
+     */
+    public final float[] gravity;
+
+    /**
+     * Factor to scale between physics world and sketch
+     */
+    public final float scaleFactor;
+
+    /**
+     *
+     * @param scaleFactor float
+     * @param gravity float[]
+     * @param warmStart boolean
+     * @param continuousPhysics boolean
+     */
+    public Options(float scaleFactor, float[] gravity, boolean warmStart, boolean continuousPhysics) {
+        this.scaleFactor = scaleFactor;
+        this.gravity = gravity;
+        this.warm = warmStart;
+        this.continuous = continuousPhysics;        
+    }
+
+    /**
+     * Default Options constructor
+     */
+    public Options() {
+        this.scaleFactor = 10f;
+        this.gravity = new float[]{0, -10f};
+        this.warm = true;
+        this.continuous = true;
+    }
+}

data/src/processing/box2d/Step.java

@@ -0,0 +1,44 @@
+package processing.box2d;
+
+/**
+ *
+ * @author Martin Prout
+ */
+public class Step {
+
+    /**
+     * time of step typically set to once per draw loop
+     */
+    public float timeStep;
+
+    /**
+     * No of velocity iterations
+     */
+    public int velIters;
+
+    /**
+     * No of position iterations
+     */
+    public int posIters;
+
+    /**
+     *
+     * @param timeStep float
+     * @param velIterations int
+     * @param posIterations int
+     */
+    public Step(float timeStep, int velIterations, int posIterations) {
+        this.timeStep = timeStep;
+        this.velIters = velIterations;
+        this.posIters = posIterations;
+    }
+
+    /**
+     * Step constructor with defaults
+     */
+    public Step() {
+        this.timeStep = 1.0f / 60;
+        this.velIters = 8;
+        this.posIters = 10;
+    }
+}