Box2D Hello World (Delphi)

From RAD Studio Code Examples
Jump to: navigation, search


This is a Delphi port of the Hello World example that the chapter 2 of the Box2D manual features.

Select File > New > Other > Delphi Projects > Console Application to create a new Delphi console application, and use the code below.

  • You might need to update the program name from Project1 to the actual name of your console application.
  • If your development system is 32-bit Windows, you must rename "Program Files (x86)" to "Program Files" in the paths of the uses clause.


{ Copyright (c) 2006-2007 Erin Catto

  This software is provided 'as-is', without any express or implied
  warranty.  In no event will the authors be held liable for any damages
  arising from the use of this software.
  Permission is granted to anyone to use this software for any purpose,
  including commercial applications, and to alter it and redistribute it
  freely, subject to the following restrictions:
  1. The origin of this software must not be misrepresented; you must not
  claim that you wrote the original software. If you use this software
  in a product, an acknowledgment in the product documentation would be
  appreciated but is not required.
  2. Altered source versions must be plainly marked as such, and must not be
  misrepresented as being the original software.
  3. This notice may not be removed or altered from any source distribution. }

// This is a simple example of building and running a simulation using Box2D.
// Here we create a large ground box and a small dynamic box.
// There are no graphics for this example. Box2D is meant to be used
// with your rendering engine in your game engine.

program Project1;


{$R *.res}

  System.SysUtils, Box2D.Collision,Box2D.Common, Box2D.Dynamics, Box2D.Rope, Box2DTypes;

  gravity: b2Vec2;
  world: b2WorldWrapper;
  groundBodyDef: b2BodyDef;
  groundBody: b2BodyWrapper;
  groundBox: b2PolygonShapeWrapper;
  bodyDef: b2BodyDef;
  body: b2BodyWrapper;
  dynamicBox: b2PolygonShapeWrapper;
  fixtureDef: b2FixtureDef;
  timeStep, angle: Single;
  velocityIterations, positionIterations, i: Integer;
  position: b2Vec2;
    // Define the gravity vector.
    gravity := b2Vec2.Create(0.0, -10.0);

    // Construct a world object, which will hold and simulate the rigid bodies.
    world := b2WorldWrapper.Create(gravity);

    // Define the ground body.
    groundBodyDef := b2BodyDef.Create;
    groundBodyDef.position.&Set(0.0, -10.0);

    // Call the body factory which allocates memory for the ground body
    // from a pool and creates the ground box shape (also from a pool).
    // The body is also added to the world.
    groundBody := world.CreateBody(@groundBodyDef);

    // Define the ground box shape.
    groundBox := b2PolygonShapeWrapper.Create;

    // The extents are the half-widths of the box.
    groundBox.SetAsBox(50.0, 10.0);

    // Add the ground fixture to the ground body.
    groundBody.CreateFixture(groundBox, 0.0);

    // Define the dynamic body. We set its position and call the body factory.
    bodyDef := b2BodyDef.Create;
    bodyDef.&type := b2_dynamicBody;
    bodyDef.position.&Set(0.0, 4.0);
    body := world.CreateBody(@bodyDef);

    // Define another box shape for our dynamic body.
    dynamicBox := b2PolygonShapeWrapper.Create;
    dynamicBox.SetAsBox(1.0, 1.0);

    // Define the dynamic body fixture.
    fixtureDef := b2FixtureDef.Create;
    fixtureDef.shape := dynamicBox;

    // Set the box density to be non-zero, so it will be dynamic.
    fixtureDef.density := 1.0;

    // Override the default friction.
    fixtureDef.friction := 0.3;

    // Add the shape to the body.

    // Prepare for simulation. Typically we use a time step of 1/60 of a
    // second (60Hz) and 10 iterations. This provides a high quality simulation
    // in most game scenarios.
    timeStep := 1.0 / 60.0;
    velocityIterations := 6;
    positionIterations := 2;

    // This is our little game loop.
    for I := 0 to 59 do
      // Instruct the world to perform a single step of simulation.
      // It is generally best to keep the time step and iterations fixed.
      world.Step(timeStep, velocityIterations, positionIterations);

      // Now print the position and angle of the body.
      position := body.GetPosition^;
      angle := body.GetAngle;

      WriteLn(Format('%4.2f %4.2f %4.2f', [position.x, position.y, angle]));

    // When the world destructor is called, all bodies and joints are freed.
    // This can create orphaned pointers, so be careful about your world
    // management.

    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);

See Also