org.jbox2d.callbacks.DebugDraw Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jbox2d-library Show documentation
Show all versions of jbox2d-library Show documentation
A 2D java physics engine, a port of the C++ Box2d engine. This is the core physics engine.
/*******************************************************************************
* Copyright (c) 2011, 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.
******************************************************************************/
/**
* Created at 4:35:29 AM Jul 15, 2010
*/
package org.jbox2d.callbacks;
import org.jbox2d.common.Color3f;
import org.jbox2d.common.IViewportTransform;
import org.jbox2d.common.Transform;
import org.jbox2d.common.Vec2;
// updated to rev 100
/**
* Implement this abstract class to allow JBox2d to
* automatically draw your physics for debugging purposes.
* Not intended to replace your own custom rendering
* routines!
* @author Daniel Murphy
*/
public abstract class DebugDraw {
public static final int e_shapeBit = 0x0001; ///< draw shapes
public static final int e_jointBit = 0x0002; ///< draw joint connections
public static final int e_aabbBit = 0x0004; ///< draw core (TOI) shapes
public static final int e_pairBit = 0x0008; ///< draw axis aligned bounding boxes
public static final int e_centerOfMassBit = 0x0010; ///< draw center of mass frame
public static final int e_dynamicTreeBit = 0x0020; ///< draw dynamic tree.
protected int m_drawFlags;
protected final IViewportTransform viewportTransform;
public DebugDraw(IViewportTransform viewport) {
m_drawFlags = 0;
viewportTransform = viewport;
}
public void setFlags(int flags) {
m_drawFlags = flags;
}
public int getFlags() {
return m_drawFlags;
}
public void appendFlags(int flags) {
m_drawFlags |= flags;
}
public void clearFlags(int flags) {
m_drawFlags &= ~flags;
}
/**
* Draw a closed polygon provided in CCW order. This implementation
* uses {@link #drawSegment(Vec2, Vec2, Color3f)} to draw each side of the
* polygon.
* @param vertices
* @param vertexCount
* @param color
*/
public void drawPolygon(Vec2[] vertices, int vertexCount, Color3f color){
if(vertexCount == 1){
drawSegment(vertices[0], vertices[0], color);
return;
}
for(int i=0; i 2){
drawSegment(vertices[vertexCount-1], vertices[0], color);
}
}
public abstract void drawPoint(Vec2 argPoint, float argRadiusOnScreen, Color3f argColor);
/**
* Draw a solid closed polygon provided in CCW order.
* @param vertices
* @param vertexCount
* @param color
*/
public abstract void drawSolidPolygon(Vec2[] vertices, int vertexCount, Color3f color);
/**
* Draw a circle.
* @param center
* @param radius
* @param color
*/
public abstract void drawCircle(Vec2 center, float radius, Color3f color);
/**
* Draw a solid circle.
* @param center
* @param radius
* @param axis
* @param color
*/
public abstract void drawSolidCircle(Vec2 center, float radius, Vec2 axis, Color3f color);
/**
* Draw a line segment.
* @param p1
* @param p2
* @param color
*/
public abstract void drawSegment(Vec2 p1, Vec2 p2, Color3f color);
/**
* Draw a transform. Choose your own length scale
* @param xf
*/
public abstract void drawTransform(Transform xf);
/**
* Draw a string.
* @param x
* @param y
* @param s
* @param color
*/
public abstract void drawString(float x, float y, String s, Color3f color);
public IViewportTransform getViewportTranform(){
return viewportTransform;
}
/**
* @param x
* @param y
* @param scale
* @see IViewportTransform#setCamera(float, float, float)
*/
public void setCamera(float x, float y, float scale){
viewportTransform.setCamera(x,y,scale);
}
/**
* @param argScreen
* @param argWorld
* @see org.jbox2d.common.IViewportTransform#getScreenToWorld(org.jbox2d.common.Vec2, org.jbox2d.common.Vec2)
*/
public void getScreenToWorldToOut(Vec2 argScreen, Vec2 argWorld) {
viewportTransform.getScreenToWorld(argScreen, argWorld);
}
/**
* @param argWorld
* @param argScreen
* @see org.jbox2d.common.IViewportTransform#getWorldToScreen(org.jbox2d.common.Vec2, org.jbox2d.common.Vec2)
*/
public void getWorldToScreenToOut(Vec2 argWorld, Vec2 argScreen) {
viewportTransform.getWorldToScreen(argWorld, argScreen);
}
/**
* Takes the world coordinates and puts the corresponding screen
* coordinates in argScreen.
* @param worldX
* @param worldY
* @param argScreen
*/
public void getWorldToScreenToOut(float worldX, float worldY, Vec2 argScreen){
argScreen.set(worldX,worldY);
viewportTransform.getWorldToScreen(argScreen, argScreen);
}
/**
* takes the world coordinate (argWorld) and returns
* the screen coordinates.
* @param argWorld
*/
public Vec2 getWorldToScreen(Vec2 argWorld){
Vec2 screen = new Vec2();
viewportTransform.getWorldToScreen( argWorld, screen);
return screen;
}
/**
* Takes the world coordinates and returns the screen
* coordinates.
* @param worldX
* @param worldY
*/
public Vec2 getWorldToScreen(float worldX, float worldY){
Vec2 argScreen = new Vec2(worldX, worldY);
viewportTransform.getWorldToScreen( argScreen, argScreen);
return argScreen;
}
/**
* takes the screen coordinates and puts the corresponding
* world coordinates in argWorld.
* @param screenX
* @param screenY
* @param argWorld
*/
public void getScreenToWorldToOut(float screenX, float screenY, Vec2 argWorld){
argWorld.set(screenX,screenY);
viewportTransform.getScreenToWorld(argWorld, argWorld);
}
/**
* takes the screen coordinates (argScreen) and returns
* the world coordinates
* @param argScreen
*/
public Vec2 getScreenToWorld(Vec2 argScreen){
Vec2 world = new Vec2();
viewportTransform.getScreenToWorld(argScreen, world);
return world;
}
/**
* takes the screen coordinates and returns the
* world coordinates.
* @param screenX
* @param screenY
*/
public Vec2 getScreenToWorld(float screenX, float screenY){
Vec2 screen = new Vec2(screenX, screenY);
viewportTransform.getScreenToWorld( screen, screen);
return screen;
}
}