Box2D b2World in the classroom

Question

So, I have a:

class bc_Game
{
public:
//blah
private:
b2World world;
};

bc_Game::bc_Game()
{
//blah, defining variables used
world = b2World(gravity, sleep);
}

Now I just get error: there is no corresponding function to call in 'b2World :: b2World ()' note: candidates: b2World :: b2World (const b2Vec2 &, bool) note: b2World :: b2World (const b2World &)

I have no idea how to make this work, I tried std :: auto_ptr, the new b2World, all I could think of.

b2World is part of Box2D, but here goes ...

 
/*
* Copyright (c) 2006-2009 Erin Catto http://www.gphysics.com
*
* 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.
*/

#ifndef B2_WORLD_H
#define B2_WORLD_H

#include 
#include 
#include 
#include 
#include 

struct b2AABB;
struct b2BodyDef;
struct b2JointDef;
struct b2TimeStep;
class b2Body;
class b2Fixture;
class b2Joint;

/// The world class manages all physics entities, dynamic simulation,
/// and asynchronous queries. The world also contains efficient memory
/// management facilities.
class b2World
{
public:
    /// Construct a world object.
    /// @param gravity the world gravity vector.
    /// @param doSleep improve performance by not simulating inactive bodies.
    b2World(const b2Vec2& gravity, bool doSleep);

    /// Destruct the world. All physics entities are destroyed and all heap memory is released.
    ~b2World();

    /// Register a destruction listener. The listener is owned by you and must
    /// remain in scope.
    void SetDestructionListener(b2DestructionListener* listener);

    /// Register a contact filter to provide specific control over collision.
    /// Otherwise the default filter is used (b2_defaultFilter). The listener is
    /// owned by you and must remain in scope. 
    void SetContactFilter(b2ContactFilter* filter);

    /// Register a contact event listener. The listener is owned by you and must
    /// remain in scope.
    void SetContactListener(b2ContactListener* listener);

    /// Register a routine for debug drawing. The debug draw functions are called
    /// inside with b2World::DrawDebugData method. The debug draw object is owned
    /// by you and must remain in scope.
    void SetDebugDraw(b2DebugDraw* debugDraw);

    /// Create a rigid body given a definition. No reference to the definition
    /// is retained.
    /// @warning This function is locked during callbacks.
    b2Body* CreateBody(const b2BodyDef* def);

    /// Destroy a rigid body given a definition. No reference to the definition
    /// is retained. This function is locked during callbacks.
    /// @warning This automatically deletes all associated shapes and joints.
    /// @warning This function is locked during callbacks.
    void DestroyBody(b2Body* body);

    /// Create a joint to constrain bodies together. No reference to the definition
    /// is retained. This may cause the connected bodies to cease colliding.
    /// @warning This function is locked during callbacks.
    b2Joint* CreateJoint(const b2JointDef* def);

    /// Destroy a joint. This may cause the connected bodies to begin colliding.
    /// @warning This function is locked during callbacks.
    void DestroyJoint(b2Joint* joint);

    /// Take a time step. This performs collision detection, integration,
    /// and constraint solution.
    /// @param timeStep the amount of time to simulate, this should not vary.
    /// @param velocityIterations for the velocity constraint solver.
    /// @param positionIterations for the position constraint solver.
    void Step(  float32 timeStep,
                int32 velocityIterations,
                int32 positionIterations);

    /// Call this after you are done with time steps to clear the forces. You normally
    /// call this after each call to Step, unless you are performing sub-steps. By default,
    /// forces will be automatically cleared, so you don't need to call this function.
    /// @see SetAutoClearForces
    void ClearForces();

    /// Call this to draw shapes and other debug draw data.
    void DrawDebugData();

    /// Query the world for all fixtures that potentially overlap the
    /// provided AABB.
    /// @param callback a user implemented callback class.
    /// @param aabb the query box.
    void QueryAABB(b2QueryCallback* callback, const b2AABB& aabb) const;

    /// Ray-cast the world for all fixtures in the path of the ray. Your callback
    /// controls whether you get the closest point, any point, or n-points.
    /// The ray-cast ignores shapes that contain the starting point.
    /// @param callback a user implemented callback class.
    /// @param point1 the ray starting point
    /// @param point2 the ray ending point
    void RayCast(b2RayCastCallback* callback, const b2Vec2& point1, const b2Vec2& point2) const;

    /// Get the world body list. With the returned body, use b2Body::GetNext to get
    /// the next body in the world list. A NULL body indicates the end of the list.
    /// @return the head of the world body list.
    b2Body* GetBodyList();

    /// Get the world joint list. With the returned joint, use b2Joint::GetNext to get
    /// the next joint in the world list. A NULL joint indicates the end of the list.
    /// @return the head of the world joint list.
    b2Joint* GetJointList();

    /// Get the world contact list. With the returned contact, use b2Contact::GetNext to get
    /// the next contact in the world list. A NULL contact indicates the end of the list.
    /// @return the head of the world contact list.
    /// @warning contacts are 
    b2Contact* GetContactList();

    /// Enable/disable warm starting. For testing.
    void SetWarmStarting(bool flag) { m_warmStarting = flag; }

    /// Enable/disable continuous physics. For testing.
    void SetContinuousPhysics(bool flag) { m_continuousPhysics = flag; }

    /// Get the number of broad-phase proxies.
    int32 GetProxyCount() const;

    /// Get the number of bodies.
    int32 GetBodyCount() const;

    /// Get the number of joints.
    int32 GetJointCount() const;

    /// Get the number of contacts (each may have 0 or more contact points).
    int32 GetContactCount() const;

    /// Change the global gravity vector.
    void SetGravity(const b2Vec2& gravity);

    /// Get the global gravity vector.
    b2Vec2 GetGravity() const;

    /// Is the world locked (in the middle of a time step).
    bool IsLocked() const;

    /// Set flag to control automatic clearing of forces after each time step.
    void SetAutoClearForces(bool flag);

    /// Get the flag that controls automatic clearing of forces after each time step.
    bool GetAutoClearForces() const;

private:

    // m_flags
    enum
    {
        e_newFixture    = 0x0001,
        e_locked        = 0x0002,
        e_clearForces   = 0x0004,
    };

    friend class b2Body;
    friend class b2ContactManager;
    friend class b2Controller;

    void Solve(const b2TimeStep& step);
    void SolveTOI();
    void SolveTOI(b2Body* body);

    void DrawJoint(b2Joint* joint);
    void DrawShape(b2Fixture* shape, const b2Transform& xf, const b2Color& color);

    b2BlockAllocator m_blockAllocator;
    b2StackAllocator m_stackAllocator;

    int32 m_flags;

    b2ContactManager m_contactManager;

    b2Body* m_bodyList;
    b2Joint* m_jointList;

    int32 m_bodyCount;
    int32 m_jointCount;

    b2Vec2 m_gravity;
    bool m_allowSleep;

    b2Body* m_groundBody;

    b2DestructionListener* m_destructionListener;
    b2DebugDraw* m_debugDraw;

    // This is used to compute the time step ratio to
    // support a variable time step.
    float32 m_inv_dt0;

    // This is for debugging the solver.
    bool m_warmStarting;

    // This is for debugging the solver.
    bool m_continuousPhysics;
};

inline b2Body* b2World::GetBodyList()
{
    return m_bodyList;
}

inline b2Joint* b2World::GetJointList()
{
    return m_jointList;
}

inline b2Contact* b2World::GetContactList()
{
    return m_contactManager.m_contactList;
}

inline int32 b2World::GetBodyCount() const
{
    return m_bodyCount;
}

inline int32 b2World::GetJointCount() const
{
    return m_jointCount;
}

inline int32 b2World::GetContactCount() const
{
    return m_contactManager.m_contactCount;
}

inline void b2World::SetGravity(const b2Vec2& gravity)
{
    m_gravity = gravity;
}

inline b2Vec2 b2World::GetGravity() const
{
    return m_gravity;
}

inline bool b2World::IsLocked() const
{
    return (m_flags & e_locked) == e_locked;
}

inline void b2World::SetAutoClearForces(bool flag)
{
    if (flag)
    {
        m_flags |= e_clearForces;
    }
    else
    {
        m_flags &= ~e_clearForces;
    }
}

/// Get the flag that controls automatic clearing of forces after each time step.
inline bool b2World::GetAutoClearForces() const
{
    return (m_flags & e_clearForces) == e_clearForces;
}

#endif
 

Answer 1

Box2D has been recently updated. I correct the textbook and notice this. However, if you look at the header file, you will notice that the new constructor only accepts gravity by default. Delete the hibernation variable.

YourVariable = b2World ();

. , , , , ... , , Box2D , , ,

Answer 2

b2World, :

bc_Game::bc_Game() :world(gravity, sleep)
{
}

, .