com.badlogic.gdx.physics.box2d.CircleShape Java Examples

/** Creates a circle object with the given position and radius. Resitution defaults to 0.6. */
public static Body createCircle(World world, float x, float y, float radius, boolean isStatic) {
    CircleShape sd = new CircleShape();
    sd.setRadius(radius);

    FixtureDef fdef = new FixtureDef();
    fdef.shape = sd;
    fdef.density = 1.0f;
    fdef.friction = 0.3f;
    fdef.restitution = 0.6f;

    BodyDef bd = new BodyDef();
    bd.allowSleep = true;
    bd.position.set(x, y);
    Body body = world.createBody(bd);
    body.createFixture(fdef);
    if (isStatic) {
        body.setType(BodyDef.BodyType.StaticBody);
    }
    else {
        body.setType(BodyDef.BodyType.DynamicBody);
    }
    return body;
}
 

private void createBoxes() {
	CircleShape ballShape = new CircleShape();
	ballShape.setRadius(RADIUS);

	FixtureDef def = new FixtureDef();
	def.restitution = 0.9f;
	def.friction = 0.01f;
	def.shape = ballShape;
	def.density = 1f;
	BodyDef boxBodyDef = new BodyDef();
	boxBodyDef.type = BodyType.DynamicBody;

	for (int i = 0; i < BALLSNUM; i++) {
		// Create the BodyDef, set a random position above the
		// ground and create a new body
		boxBodyDef.position.x = -20 + (float) (Math.random() * 40);
		boxBodyDef.position.y = 10 + (float) (Math.random() * 15);
		Body boxBody = world.createBody(boxBodyDef);
		boxBody.createFixture(def);
		balls.add(boxBody);
	}
	ballShape.dispose();
}
 

public Box2dSteeringEntity createSteeringEntity (World world, TextureRegion region, boolean independentFacing, int posX, int posY) {

		CircleShape circleChape = new CircleShape();
		circleChape.setPosition(new Vector2());
		int radiusInPixels = (int)((region.getRegionWidth() + region.getRegionHeight()) / 4f);
		circleChape.setRadius(Box2dSteeringTest.pixelsToMeters(radiusInPixels));

		BodyDef characterBodyDef = new BodyDef();
		characterBodyDef.position.set(Box2dSteeringTest.pixelsToMeters(posX), Box2dSteeringTest.pixelsToMeters(posY));
		characterBodyDef.type = BodyType.DynamicBody;
		Body characterBody = world.createBody(characterBodyDef);

		FixtureDef charFixtureDef = new FixtureDef();
		charFixtureDef.density = 1;
		charFixtureDef.shape = circleChape;
		charFixtureDef.filter.groupIndex = 0;
		characterBody.createFixture(charFixtureDef);

		circleChape.dispose();

		return new Box2dSteeringEntity(region, characterBody, independentFacing, Box2dSteeringTest.pixelsToMeters(radiusInPixels));
	}
 

public void draw(IFieldRenderer renderer) {
    CircleShape shape = (CircleShape)body.getFixtureList().get(0).getShape();
    Vector2 center = body.getPosition();
    float radius = shape.getRadius();
    renderer.fillCircle(center.x, center.y, radius, primaryColor);

    // Draw a smaller circle to show the ball's rotation.
    float angle = body.getAngle();
    float smallCenterX = center.x + (radius / 2) * MathUtils.cos(angle);
    float smallCenterY = center.y + (radius / 2) * MathUtils.sin(angle);
    renderer.fillCircle(smallCenterX, smallCenterY, radius / 4, secondaryColor);
}
 

public RenderOfCircleFixture(Fixture fixture, VertexBufferObjectManager pVBO) {
	super(fixture);

	CircleShape fixtureShape = (CircleShape) fixture.getShape();
	Vector2 position = fixtureShape.getPosition();
	float radius = fixtureShape.getRadius() * PhysicsConnector.PIXEL_TO_METER_RATIO_DEFAULT;

	mEntity = new Ellipse(position.x * PhysicsConnector.PIXEL_TO_METER_RATIO_DEFAULT,
			position.y * PhysicsConnector.PIXEL_TO_METER_RATIO_DEFAULT,
			radius, radius, pVBO);
}
 

/** Circle Shape */
public Piece (float radius, BodyType type) {
	this.shape = new CircleShape();
	((CircleShape)this.shape).setRadius(radius);
	this.pos = new Vector2();
	this.type = type;
	this.radius = radius;
}
 

public static Body createCircleBody(final PhysicsWorld pPhysicsWorld, final float pCenterX, final float pCenterY, final float pRadius, final float pRotation, final BodyType pBodyType, final FixtureDef pFixtureDef, final float pPixelToMeterRatio) {
	final BodyDef circleBodyDef = new BodyDef();
	circleBodyDef.type = pBodyType;

	circleBodyDef.position.x = pCenterX / pPixelToMeterRatio;
	circleBodyDef.position.y = pCenterY / pPixelToMeterRatio;

	circleBodyDef.angle = MathUtils.degToRad(pRotation);

	final Body circleBody = pPhysicsWorld.createBody(circleBodyDef);

	final CircleShape circlePoly = new CircleShape();
	pFixtureDef.shape = circlePoly;

	final float radius = pRadius / pPixelToMeterRatio;
	circlePoly.setRadius(radius);

	circleBody.createFixture(pFixtureDef);

	circlePoly.dispose();

	return circleBody;
}
 

public static Shape createCircleShape(float radius) {
	CircleShape circleShape = new CircleShape();
	circleShape.setRadius(radius);

	return circleShape;
}