Box2D is a widely-used 2D physics engine available in multiple prgoramming languages. LibGDX provides a well-encapsulated and efficient Java wrapper for Box2D, simplifying its integration. However, creating complex physical bodies programmatically can be tedious. The Physics Body Editor tool addresses this by offering a visual interface for body creation, significantly accelerating development.

Physics Body Editer Overview

Project Homepage: http://code.google.com/p/box2d-editor/

This editor allows developers to define complex collision shapes by outlining them with a mouse. It exports data in JSON format, making it portable across different enviroments. For LibGDX, a dedicated loader is available to import these definitions.

Creating a Physics Body: Example with a Bottle

As a demonstration, we'll use the bottle image provided by the editor's official resources.

1. Launch the editor and create a new project.
2. Import the desired sprite image.
3. Use the mouse to trace the outline of the object, defining its collision polygon.
4. The editor includes a test mode where you can interact with the body using simulated balls.
5. Save the project to generate a JSON configuration file.

Integration in LibGDX

First, include the loader libray in your project. Then, use it to load the created JSON file.

BodyEditorLoader bodyLoader = new BodyEditorLoader(Gdx.files.internal("physics/bottle.json"));

Next, define a dynamic body and its fixture properties.

// Define the body
BodyDef bodyDef = new BodyDef();
bodyDef.type = BodyType.DynamicBody;

// Define fixture properties
FixtureDef fixtureDef = new FixtureDef();
fixtureDef.density = 1.0f;
fixtureDef.friction = 0.5f;
fixtureDef.restitution = 0.3f;

Create the body in the physics world and use the loader to attach the complex fixture defined in the editor.

// Create the body in the world
bottleBody = physicsWorld.createBody(bodyDef);

// Attach the fixture using the loader. "bottleSprite" is the image name used in the editor.
float spritePixelWidth = 2.0f; // The width of the sprite in world units
bodyLoader.attachFixture(bottleBody, "bottleSprite", fixtureDef, spritePixelWidth);

// Get the origin offset for correct rendering
Vector2 bodyOrigin = bodyLoader.getOrigin("bottleSprite", spritePixelWidth).cpy();

The string "bottleSprite" corresponds to the name assigned to the image within the editor and must be adjusted accordingly.

For testing, we can create multiple simple ball bodies.

// Ball creation setup
BodyDef ballDef = new BodyDef();
ballDef.type = BodyType.DynamicBody;

CircleShape ballShape = new CircleShape();
ballShape.setRadius(0.15f); // Radius in world units

FixtureDef ballFixtureDef = new FixtureDef();
ballFixtureDef.shape = ballShape;
ballFixtureDef.density = 1.0f;
ballFixtureDef.friction = 0.5f;
ballFixtureDef.restitution = 0.5f;

// Create an array of ball bodies
Body[] ballArray = new Body[50];
for (int i = 0; i < ballArray.length; i++) {
    ballArray[i] = physicsWorld.createBody(ballDef);
    ballArray[i].createFixture(ballFixtureDef);
}
ballShape.dispose(); // Dispose of the shape to avoid memory leaks

During rendering, calculate the correct sprite position by accounting for the body's origin offset.

Vector2 bodyPos = bottleBody.getPosition();
float renderX = bodyPos.x - bodyOrigin.x;
float renderY = bodyPos.y - bodyOrigin.y;
// Set your sprite's position to (renderX, renderY)

Understanding the Generated Data

The exported JSON file essentially contains the vertex coordinates of the defined polygon(s). The loader parses this data and constructs the appropriate Box2D shapes. Examining the loader's source code provides insight for adapting this workflow to other engines or languages.

Implementation Notes for LibGDX

When using LibGDX's Stage for rendering, pay attention to camera transformations. Maintain a consistent scale factor (e.g., 10-100 pixels per world unit) to convert between screen coordinates and physics world coordinates, avoiding confusion between the two systems.