Leviathan::PhysicalWorld Class Reference

#include <PhysicalWorld.h>

Public Member Functions
DLLEXPORT	PhysicalWorld (GameWorld *owner, PhysicsMaterialManager *physicscallbacks)
DLLEXPORT	~PhysicalWorld ()
DLLEXPORT void	SimulateWorld (float secondspassed, int maxsubsteps=8)
	Advances the simulation the specified amount of time. More...
DLLEXPORT PhysicsShape::pointer	CreateCompound ()
DLLEXPORT PhysicsShape::pointer	CreateSphere (float radius)
DLLEXPORT PhysicsShape::pointer	CreateBox (float xdimension, float ydimension, float zdimension)
	The dimensions are halfwidths of the box along each axis. More...
DLLEXPORT PhysicsShape::pointer	CreateCone (float radius, float height)
DLLEXPORT PhysicsConstraint::pointer	CreateFixedConstraint (const PhysicsBody::pointer &a, const PhysicsBody::pointer &b, const Float3 &aoffset, const Quaternion &aorientation, const Float3 &boffset, const Quaternion &borientation)
DLLEXPORT bool	DestroyConstraint (PhysicsConstraint *constraint)
	Destroys a physics constraint. More...
DLLEXPORT PhysicsBody::pointer	CreateBodyFromCollision (const PhysicsShape::pointer &shape, float mass, PhysicsPositionProvider *positionsynchronization, int physicsmaterialid=-1)
	Constraints body to a 2d plane of movement specified by its normal. More...
DLLEXPORT bool	ChangeBodyShape (const PhysicsBody::pointer &body, const PhysicsShape::pointer &shape)
	Applies a changed shape to a body. More...
DLLEXPORT bool	DestroyBody (PhysicsBody *body)
	Destroys a physics body. More...
const PhysMaterialDataPair *	GetMaterialPair (int id1, int id2) const
	Finds the information for contact between objects with two materials. More...
DLLEXPORT void	SetDebugDrawer (const std::shared_ptr< PhysicsDebugDrawer > &drawer)
	Sets or clears the debug drawer used by this world. More...
DLLEXPORT GameWorld *	GetGameWorld ()
PhysicsShape *	CreateSphereWrapper (float radius)
PhysicsShape *	CreateConeWrapper (float radius, float height)
PhysicsShape *	CreateCompoundWrapper ()
PhysicsConstraint *	CreateFixedConstraintWrapper (PhysicsBody *a, PhysicsBody *b, const Float3 &aoffset, const Quaternion &aorientation, const Float3 &boffset, const Quaternion &borientation)
bool	DestroyConstraintWrapper (PhysicsConstraint *constraint)

Protected Member Functions
void	OnManifoldWithContact (btPersistentManifold *contactManifold, const btManifoldPoint &contactPoint, const PhysMaterialDataPair &pair, PhysicsBody *body1, PhysicsBody *body2)
	Calls appropriate material callbacks. This is called once per contact manifold that has penetrating points. More...

Static Protected Member Functions
static void	OnPhysicsSubStep (btDynamicsWorld *world, btScalar timeStep)

Protected Attributes
float	PassedTimeTotal = 0
	Total amount of seconds required to be simulated. More...
GameWorld *	OwningWorld
PhysicsMaterialManager *	PhysicsMaterials
bool	PhysicsUpdateInProgress = false
	This is a small sanity check for preventing destroying physics bodies during a tick. More...
std::unique_ptr< btDefaultCollisionConfiguration >	CollisionConfiguration
std::unique_ptr< btCollisionDispatcher >	Dispatcher
std::unique_ptr< btBroadphaseInterface >	OverlappingPairCache
std::unique_ptr< btSequentialImpulseConstraintSolver >	Solver
std::unique_ptr< btDiscreteDynamicsWorld >	DynamicsWorld
std::unique_ptr< LeviathanPhysicsOverlapFilter >	OverlapFilter
std::vector< PhysicsBody::pointer >	PhysicsBodies
	We need to keep the physic bodies alive (guaranteed) until they are destroyed. More...
std::vector< PhysicsConstraint::pointer >	PhysicsConstraints
	We need to keep constraints alive until they are destroyed. More...
std::shared_ptr< PhysicsDebugDrawer >	DebugDrawer

Detailed Description

Definition at line 56 of file PhysicalWorld.h.

Constructor & Destructor Documentation

PhysicalWorld()

DLLEXPORT PhysicalWorld::PhysicalWorld	(	GameWorld *	owner,
		PhysicsMaterialManager *	physicscallbacks
	)

Definition at line 77 of file PhysicalWorld.cpp.

                                                                :
    OwningWorld(owner),
    PhysicsMaterials(physicscallbacks),
    OverlapFilter(std::make_unique<LeviathanPhysicsOverlapFilter>(this))
{
    // Setup physics world //
    CollisionConfiguration = std::make_unique<btDefaultCollisionConfiguration>();

    // Non-parallel dispatcher
    Dispatcher = std::make_unique<btCollisionDispatcher>(CollisionConfiguration.get());

    // According to docs this is a good general broadphase
    OverlappingPairCache = std::make_unique<btDbvtBroadphase>();

    // Non-parallel solver
    Solver = std::make_unique<btSequentialImpulseConstraintSolver>();

    DynamicsWorld = std::make_unique<btDiscreteDynamicsWorld>(Dispatcher.get(),
        OverlappingPairCache.get(), Solver.get(), CollisionConfiguration.get());

    // Register required callbacks
    DynamicsWorld->setInternalTickCallback(&PhysicalWorld::OnPhysicsSubStep);
    // Not sure which one of these is better to use for AABB overlap
    DynamicsWorld->getPairCache()->setOverlapFilterCallback(OverlapFilter.get());
    // Dispatcher->setNearCallback(&PhysicalWorld::PhysicsNearCallback);

    // Set gravity. Having this set on worlds that want multiple different gravities might be
    // an issue
    DynamicsWorld->setGravity(btVector3(0, PHYSICS_BASE_GRAVITY, 0));

    // Set us as the user data (this is done last so that nothing overwrites this) //
    DynamicsWorld->setWorldUserInfo(this);

    LEVIATHAN_ASSERT(DynamicsWorld->getWorldUserInfo() != nullptr, "userinfo set failed");
}

~PhysicalWorld()

DLLEXPORT PhysicalWorld::~PhysicalWorld

(

)

Definition at line 114 of file PhysicalWorld.cpp.

{
    // It is an error to not release a body
    if(!PhysicsBodies.empty()) {
        LOG_ERROR("PhysicalWorld: not all bodies have been destroyed, alive count: " +
                  std::to_string(PhysicsBodies.size()));
    }

    // All bodies need to be destroyed here
    while(!PhysicsBodies.empty()) {
        DestroyBody(PhysicsBodies.back().get());
    }

    // We can rely on the default delete order and everything is fine
}

Member Function Documentation

ChangeBodyShape()

DLLEXPORT bool PhysicalWorld::ChangeBodyShape	(	const PhysicsBody::pointer &	body,
		const PhysicsShape::pointer &	shape
	)

Applies a changed shape to a body.

Todo:

Find out if it is required to remove and add the body back to the world (and if that can be done in a physics callback)

Definition at line 443 of file PhysicalWorld.cpp.

{
    if(!body || !shape || !body->GetBody())
        return false;

    // Debug safety code
    bool found = false;
    for(auto iter = PhysicsBodies.begin(); iter != PhysicsBodies.end(); ++iter) {
        if(iter->get() == body.get()) {

            found = true;
            break;
        }
    }

    if(!found) {
        LOG_ERROR("PhysicalWorld: ChangeBodyShape: passed body not part of this world");
        DEBUG_BREAK;
        return false;
    }

    // This might be fine as it will be added back in
    if(body->GetBody()->getNumConstraintRefs() > 0) {
        // "undestroyed constraints on entity";
    }

    if(PhysicsUpdateInProgress) {
        // This might be okay...
        // DEBUG_BREAK;
    }

    DynamicsWorld->removeRigidBody(body->GetBody());

    body->ApplyShapeChange(shape);

    DynamicsWorld->addRigidBody(body->GetBody());

    return true;
}

CreateBodyFromCollision()

DLLEXPORT PhysicsBody::pointer PhysicalWorld::CreateBodyFromCollision	(	const PhysicsShape::pointer &	shape,
		float	mass,
		PhysicsPositionProvider *	positionsynchronization,
		int	physicsmaterialid = -1
	)

Constraints body to a 2d plane of movement specified by its normal.

Note

DestroyBody must be called to remove the created body from this world

Parameters

mass	If 0 then this is a static body

Definition at line 368 of file PhysicalWorld.cpp.

{
    if(!shape)
        return nullptr;

    btTransform transform;
    transform.setIdentity();

    if(positionsynchronization) {
        const Float3* position;
        const Quaternion* orientation;
        positionsynchronization->GetPositionDataForPhysics(position, orientation);

        transform.setRotation(*orientation);
        transform.setOrigin(*position);
    }

    // rigidbody is dynamic if and only if mass is non zero, otherwise static
    const bool isDynamic = mass > 0;

    btVector3 localInertia(0, 0, 0);
    if(isDynamic)
        shape->GetShape()->calculateLocalInertia(mass, localInertia);

    // To not have to lookup all positions all the time we use the position synchronization
    // object
    std::unique_ptr<PhysicsDataBridge> positionBridge;

    if(positionsynchronization)
        positionBridge = std::make_unique<PhysicsDataBridge>(positionsynchronization);

    btRigidBody::btRigidBodyConstructionInfo info(
        mass, positionBridge.get(), shape->GetShape(), localInertia);

    auto body = PhysicsBody::MakeShared<PhysicsBody>(std::make_unique<btRigidBody>(info), mass,
        shape, std::move(positionBridge), physicsmaterialid);

    if(!body->GetBody()) {
        LOG_ERROR("PhysicalWorld: CreateBodyFromCollision: failed to create bullet body");
        return nullptr;
    }

    // Apply material
    if(physicsmaterialid != -1 && PhysicsMaterials) {
        auto material = PhysicsMaterials->GetMaterial(physicsmaterialid);

        if(!material) {
            LOG_ERROR(
                "PhysicalWorld: CreateBodyFromCollision: can't find physics material id: " +
                std::to_string(physicsmaterialid));
            body->SetPhysicalMaterialID(-1);
        } else {

            body->ApplyMaterial(*material);
        }
    }

    // Dirty hack to make bodies not sleep. This makes apply force work (another approach would
    // be to wake any body that has force applied to it)
    body->GetBody()->setActivationState(DISABLE_DEACTIVATION);

    if(PhysicsUpdateInProgress) {
        // This might be okay...
        // DEBUG_BREAK;
    }

    DynamicsWorld->addRigidBody(body->GetBody());

    // Make sure it is alive as long as it is in the world
    PhysicsBodies.push_back(body);
    return body;
}

CreateBox()

DLLEXPORT PhysicsShape::pointer PhysicalWorld::CreateBox	(	float	xdimension,
		float	ydimension,
		float	zdimension
	)

The dimensions are halfwidths of the box along each axis.

Definition at line 302 of file PhysicalWorld.cpp.

{
    return PhysicsShape::MakeShared<PhysicsShape>(
        std::make_unique<btBoxShape>(btVector3(xdimension, ydimension, zdimension)));
}

CreateCompound()

DLLEXPORT PhysicsShape::pointer PhysicalWorld::CreateCompound

(

)

Definition at line 284 of file PhysicalWorld.cpp.

{
    return PhysicsShape::MakeShared<PhysicsShape>(std::make_unique<btCompoundShape>());
}

CreateCompoundWrapper()

PhysicsShape* Leviathan::PhysicalWorld::CreateCompoundWrapper ( )

inline

Definition at line 139 of file PhysicalWorld.h.

    {
        return CreateCompound().detach();
    }

CreateCone()

DLLEXPORT PhysicsShape::pointer PhysicalWorld::CreateCone	(	float	radius,
		float	height
	)

Definition at line 309 of file PhysicalWorld.cpp.

{
    return PhysicsShape::MakeShared<PhysicsShape>(
        std::make_unique<btConeShape>(radius, height));
}

CreateConeWrapper()

PhysicsShape* Leviathan::PhysicalWorld::CreateConeWrapper ( float  radius, float  height  )

inline

Definition at line 134 of file PhysicalWorld.h.

    {
        return CreateCone(radius, height).detach();
    }

CreateFixedConstraint()

DLLEXPORT PhysicsConstraint::pointer PhysicalWorld::CreateFixedConstraint	(	const PhysicsBody::pointer &	a,
		const PhysicsBody::pointer &	b,
		const Float3 &	aoffset,
		const Quaternion &	aorientation,
		const Float3 &	boffset,
		const Quaternion &	borientation
	)

Definition at line 315 of file PhysicalWorld.cpp.

{
    if(!a || !a->GetBody() || !b || !b->GetBody())
        return nullptr;

    btTransform aTransform;
    aTransform.setIdentity();

    aTransform.setRotation(aorientation);
    aTransform.setOrigin(aoffset);

    btTransform bTransform;
    bTransform.setIdentity();

    bTransform.setRotation(borientation);
    bTransform.setOrigin(boffset);

    auto newConstraint = PhysicsConstraint::MakeShared<PhysicsConstraint>(
        new btFixedConstraint(*a->GetBody(), *b->GetBody(), aTransform, bTransform), a.get(),
        b.get());

    DynamicsWorld->addConstraint(newConstraint->GetConstraint());
    PhysicsConstraints.push_back(newConstraint);

    return newConstraint;
}

CreateFixedConstraintWrapper()

PhysicsConstraint* Leviathan::PhysicalWorld::CreateFixedConstraintWrapper ( PhysicsBody *  a, PhysicsBody *  b, const Float3 &  aoffset, const Quaternion &  aorientation, const Float3 &  boffset, const Quaternion &  borientation  )

inline

Definition at line 144 of file PhysicalWorld.h.

    {
        return CreateFixedConstraint(PhysicsBody::WrapPtr(a), PhysicsBody::WrapPtr(b), aoffset,
            aorientation, boffset, borientation)
            .detach();
    }

CreateSphere()

DLLEXPORT PhysicsShape::pointer PhysicalWorld::CreateSphere

(

float

radius

)

Definition at line 289 of file PhysicalWorld.cpp.

{
#ifdef CHECK_FOR_NANS
    if(std::isnan(radius)) {

        DEBUG_BREAK;
        throw std::runtime_error("CreateSphere has NaNs in it!");
    }
#endif // CHECK_FOR_NANS

    return PhysicsShape::MakeShared<PhysicsShape>(std::make_unique<btSphereShape>(radius));
}

CreateSphereWrapper()

PhysicsShape* Leviathan::PhysicalWorld::CreateSphereWrapper ( float  radius )

inline

Definition at line 129 of file PhysicalWorld.h.

    {
        return CreateSphere(radius).detach();
    }

DestroyBody()

DLLEXPORT bool PhysicalWorld::DestroyBody

(

PhysicsBody *

body

)

Destroys a physics body.

May not be called while a physics update is in progress

Definition at line 484 of file PhysicalWorld.cpp.

{
    if(PhysicsUpdateInProgress) {
        LOG_FATAL("PhysicalWorld: DestroyBody: called while physics update is in progress");
        return false;
    }

    // Remove from alive bodies. This also checks that the body is in this world
    for(auto iter = PhysicsBodies.begin(); iter != PhysicsBodies.end(); ++iter) {

        if(iter->get() == body) {

            // Destroy all constraints we can see
            while(!body->GetConstraints().empty()) {
                DestroyConstraint(body->GetConstraints().front().get());
            }

            if(body->GetBody()->getNumConstraintRefs() > 0) {

                LOG_ERROR("PhysicalWorld: DestroyBody: body has undestroyed constraints, "
                          "can't safely destroy");
                return false;
            }

            DynamicsWorld->removeRigidBody(body->GetBody());

            body->DetachResources();
            PhysicsBodies.erase(iter);
            return true;
        }
    }

    LOG_ERROR("PhysicalWorld: DestroyBody: called with body that wasn't in this world");
    return false;
}

DestroyConstraint()

DLLEXPORT bool PhysicalWorld::DestroyConstraint

(

PhysicsConstraint *

constraint

)

Destroys a physics constraint.

May not be called while a physics update is in progress

Definition at line 344 of file PhysicalWorld.cpp.

{
    if(PhysicsUpdateInProgress) {
        LOG_FATAL(
            "PhysicalWorld: DestroyConstraint: called while physics update is in progress");
        return false;
    }

    // Remove from existing constraints and the world
    for(auto iter = PhysicsConstraints.begin(); iter != PhysicsConstraints.end(); ++iter) {
        if(iter->get() == constraint) {

            DynamicsWorld->removeConstraint(constraint->GetConstraint());

            constraint->DetachResources();
            PhysicsConstraints.erase(iter);
            return true;
        }
    }

    // This is not serious as destroying bodies can trigger destroying constraints
    return false;
}

DestroyConstraintWrapper()

bool Leviathan::PhysicalWorld::DestroyConstraintWrapper ( PhysicsConstraint *  constraint )

inline

Definition at line 153 of file PhysicalWorld.h.

    {
        const auto result = DestroyConstraint(constraint);
        if(constraint)
            constraint->Release();
        return result;
    }

GetGameWorld()

DLLEXPORT GameWorld* Leviathan::PhysicalWorld::GetGameWorld ( )

inline

Definition at line 121 of file PhysicalWorld.h.

    {
        return OwningWorld;
    }

GetMaterialPair()

const PhysMaterialDataPair * PhysicalWorld::GetMaterialPair	(	int	id1,
		int	id2
	)		const

Finds the information for contact between objects with two materials.

Definition at line 236 of file PhysicalWorld.cpp.

{
    const auto material1 = PhysicsMaterials->GetMaterial(id1);

    const PhysMaterialDataPair* pair = nullptr;

    // The logs in this method will absolutely trash performance if they get hit as there will
    // be tons of calls with the same parameters

    if(material1) {
        pair = material1->GetPairWith(id2);
    } else {
        LOG_ERROR("PhysicsBody has invalid material ID: " + std::to_string(id1));
    }

    if(!pair) {

        const auto material2 = PhysicsMaterials->GetMaterial(id2);

        if(material2) {
            pair = material2->GetPairWith(id1);
        } else {
            LOG_ERROR("PhysicsBody has invalid material ID: " + std::to_string(id2));
        }
    }

    return pair;
}

OnManifoldWithContact()

void PhysicalWorld::OnManifoldWithContact ( btPersistentManifold *  contactManifold, const btManifoldPoint &  contactPoint, const PhysMaterialDataPair &  pair, PhysicsBody *  body1, PhysicsBody *  body2  )

protected

Calls appropriate material callbacks. This is called once per contact manifold that has penetrating points.

Definition at line 221 of file PhysicalWorld.cpp.

{
    // Actual points touching
    // const btVector3& contactPointA = contactPoint.getPositionWorldOnA();
    // const btVector3& contactPointB = contactPoint.getPositionWorldOnB();
    // const btVector3& normalOnB = contactPoint.m_normalWorldOnB;

    if(pair.ContactCallback) {

        pair.ContactCallback(*this, *body1, *body2);
    }
}

OnPhysicsSubStep()

void PhysicalWorld::OnPhysicsSubStep ( btDynamicsWorld *  world, btScalar  timeStep  )

staticprotected

Definition at line 144 of file PhysicalWorld.cpp.

{
    auto leviathanWorld = static_cast<PhysicalWorld*>(world->getWorldUserInfo());

    // Skip if no physics materials
    if(!leviathanWorld->PhysicsMaterials)
        return;

    btDispatcher* dispatcher = world->getDispatcher();

    // Check all active contacts as to whether something should be done
    const int numManifolds = dispatcher->getNumManifolds();
    for(int i = 0; i < numManifolds; i++) {

        btPersistentManifold* contactManifold = dispatcher->getManifoldByIndexInternal(i);

        const int numContacts = contactManifold->getNumContacts();

        if(numContacts < 1)
            continue;

        const btCollisionObject* objA = contactManifold->getBody0();
        const btCollisionObject* objB = contactManifold->getBody1();

        // TODO: remove this check once it is confirmed that both objects must always exist
        if(objA && objB) {

            PhysicsBody* body1 = static_cast<PhysicsBody*>(objA->getUserPointer());
            PhysicsBody* body2 = static_cast<PhysicsBody*>(objB->getUserPointer());

            // TODO: remove this check after confirming neither is ever null
            if(body1 && body2) {

                // Find matching materials
                const auto materialID1 = body1->GetPhysicalMaterialID();
                const auto materialID2 = body2->GetPhysicalMaterialID();

                // Find contact callbacks
                if(materialID1 >= 0 && materialID2 >= 0) {

                    auto pair = leviathanWorld->GetMaterialPair(materialID1, materialID2);

                    if(!pair)
                        continue;

                    if(pair->ManifoldCallback) {

                        pair->ManifoldCallback(
                            *leviathanWorld, *body1, *body2, *contactManifold);

                        // Maybe release or clear here allows rechecking the AABB overlap
                        // dispatcher->releaseManifold()
                    }

                    bool handled = false;

                    for(int j = 0; j < numContacts; j++) {

                        const btManifoldPoint& contactPoint =
                            contactManifold->getContactPoint(j);

                        if(contactPoint.getDistance() < 0.f) {

                            if(handled)
                                continue;

                            handled = true;
                            leviathanWorld->OnManifoldWithContact(
                                contactManifold, contactPoint, *pair, body1, body2);
                        }
                    }
                }
            }
        }
    }
}

SetDebugDrawer()

DLLEXPORT void PhysicalWorld::SetDebugDrawer

(

const std::shared_ptr< PhysicsDebugDrawer > &

drawer

)

Sets or clears the debug drawer used by this world.

Definition at line 520 of file PhysicalWorld.cpp.

{
    DebugDrawer = drawer;

    if(DebugDrawer) {
        DynamicsWorld->setDebugDrawer(DebugDrawer.get());
    } else {
        DynamicsWorld->setDebugDrawer(nullptr);
    }
}

SimulateWorld()

DLLEXPORT void PhysicalWorld::SimulateWorld	(	float	secondspassed,
		int	maxsubsteps = 8
	)

Advances the simulation the specified amount of time.

Todo:

Verify that this works correctly with the new variable rate ticks

Definition at line 130 of file PhysicalWorld.cpp.

{
    PhysicsUpdateInProgress = true;

    DynamicsWorld->stepSimulation(secondspassed, maxsubsteps);

    PhysicsUpdateInProgress = false;

    if(DebugDrawer) {
        DebugDrawer->OnBeginDraw();
        DynamicsWorld->debugDrawWorld();
    }
}

Member Data Documentation

CollisionConfiguration

std::unique_ptr<btDefaultCollisionConfiguration> Leviathan::PhysicalWorld::CollisionConfiguration

protected

Definition at line 181 of file PhysicalWorld.h.

DebugDrawer

std::shared_ptr<PhysicsDebugDrawer> Leviathan::PhysicalWorld::DebugDrawer

protected

Definition at line 199 of file PhysicalWorld.h.

Dispatcher

std::unique_ptr<btCollisionDispatcher> Leviathan::PhysicalWorld::Dispatcher

protected

Definition at line 183 of file PhysicalWorld.h.

DynamicsWorld

std::unique_ptr<btDiscreteDynamicsWorld> Leviathan::PhysicalWorld::DynamicsWorld

protected

Definition at line 189 of file PhysicalWorld.h.

OverlapFilter

std::unique_ptr<LeviathanPhysicsOverlapFilter> Leviathan::PhysicalWorld::OverlapFilter

protected

Definition at line 191 of file PhysicalWorld.h.

OverlappingPairCache

std::unique_ptr<btBroadphaseInterface> Leviathan::PhysicalWorld::OverlappingPairCache

protected

Definition at line 185 of file PhysicalWorld.h.

OwningWorld

GameWorld* Leviathan::PhysicalWorld::OwningWorld

protected

Definition at line 174 of file PhysicalWorld.h.

PassedTimeTotal

float Leviathan::PhysicalWorld::PassedTimeTotal = 0

protected

Total amount of seconds required to be simulated.

Definition at line 172 of file PhysicalWorld.h.

PhysicsBodies

std::vector<PhysicsBody::pointer> Leviathan::PhysicalWorld::PhysicsBodies

protected

We need to keep the physic bodies alive (guaranteed) until they are destroyed.

Definition at line 194 of file PhysicalWorld.h.

PhysicsConstraints

std::vector<PhysicsConstraint::pointer> Leviathan::PhysicalWorld::PhysicsConstraints

protected

We need to keep constraints alive until they are destroyed.

Definition at line 197 of file PhysicalWorld.h.

PhysicsMaterials

PhysicsMaterialManager* Leviathan::PhysicalWorld::PhysicsMaterials

protected

Definition at line 175 of file PhysicalWorld.h.

PhysicsUpdateInProgress

bool Leviathan::PhysicalWorld::PhysicsUpdateInProgress = false

protected

This is a small sanity check for preventing destroying physics bodies during a tick.

Definition at line 178 of file PhysicalWorld.h.

Solver

std::unique_ptr<btSequentialImpulseConstraintSolver> Leviathan::PhysicalWorld::Solver

protected

Definition at line 187 of file PhysicalWorld.h.

---

The documentation for this class was generated from the following files:

• PhysicalWorld.h
• PhysicalWorld.cpp