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=4)
	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 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 GameWorld *	GetGameWorld ()
PhysicsShape *	CreateSphereWrapper (float radius)
PhysicsShape *	CreateCompoundWrapper ()

Protected Member Functions
void	OnManifoldWithContact (btPersistentManifold *contactManifold, const btManifoldPoint &contactPoint, const btCollisionObject *objA, const btCollisionObject *objB)
	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...

Detailed Description

Definition at line 54 of file PhysicalWorld.h.

Constructor & Destructor Documentation

PhysicalWorld()

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

Definition at line 74 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 111 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 359 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 284 of file PhysicalWorld.cpp.

{
    if(!shape)
        return nullptr;

    btTransform transform;
    transform.setIdentity();

    if(positionsynchronization) {
        const Float3* position;
        const Float4* 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 277 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 259 of file PhysicalWorld.cpp.

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

CreateCompoundWrapper()

PhysicsShape* Leviathan::PhysicalWorld::CreateCompoundWrapper ( )

inline

Definition at line 123 of file PhysicalWorld.h.

    {
        auto obj = CreateCompound();

        if(obj)
            obj->AddRef();

        return obj.get();
    }

CreateSphere()

DLLEXPORT PhysicsShape::pointer PhysicalWorld::CreateSphere

(

float

radius

)

Definition at line 264 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 113 of file PhysicalWorld.h.

    {
        auto obj = CreateSphere(radius);

        if(obj)
            obj->AddRef();

        return obj.get();
    }

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 400 of file PhysicalWorld.cpp.

{
    if(PhysicsUpdateInProgress) {
        DEBUG_BREAK;
        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) {

            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;
}

GetGameWorld()

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

inline

Definition at line 105 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 211 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 btCollisionObject *  objA, const btCollisionObject *  objB  )

protected

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

Definition at line 180 of file PhysicalWorld.cpp.

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

    // Find matching materials
    PhysicsBody* body1 = static_cast<PhysicsBody*>(objA->getUserPointer());
    PhysicsBody* body2 = static_cast<PhysicsBody*>(objB->getUserPointer());

    if(body1 && body2) {

        const auto materialID1 = body1->GetPhysicalMaterialID();
        const auto materialID2 = body2->GetPhysicalMaterialID();

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

            auto pair = GetMaterialPair(materialID1, materialID2);

            if(pair && pair->ContactCallback) {

                pair->ContactCallback(*this, *body1, *body2);
            }
        }
    }
}

OnPhysicsSubStep()

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

staticprotected

Definition at line 136 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 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) {

            const int numContacts = contactManifold->getNumContacts();

            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, objA, objB);
                }
            }
        }
    }
}

SimulateWorld()

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

Advances the simulation the specified amount of time.

Definition at line 127 of file PhysicalWorld.cpp.

{
    PhysicsUpdateInProgress = true;

    DynamicsWorld->stepSimulation(secondspassed, maxsubsteps);

    PhysicsUpdateInProgress = false;
}

Member Data Documentation

CollisionConfiguration

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

protected

Definition at line 153 of file PhysicalWorld.h.

Dispatcher

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

protected

Definition at line 155 of file PhysicalWorld.h.

DynamicsWorld

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

protected

Definition at line 161 of file PhysicalWorld.h.

OverlapFilter

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

protected

Definition at line 163 of file PhysicalWorld.h.

OverlappingPairCache

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

protected

Definition at line 157 of file PhysicalWorld.h.

OwningWorld

GameWorld* Leviathan::PhysicalWorld::OwningWorld

protected

Definition at line 146 of file PhysicalWorld.h.

PassedTimeTotal

float Leviathan::PhysicalWorld::PassedTimeTotal = 0

protected

Total amount of seconds required to be simulated.

Definition at line 144 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 166 of file PhysicalWorld.h.

PhysicsMaterials

PhysicsMaterialManager* Leviathan::PhysicalWorld::PhysicsMaterials

protected

Definition at line 147 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 150 of file PhysicalWorld.h.

Solver

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

protected

Definition at line 159 of file PhysicalWorld.h.

---

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

• PhysicalWorld.h
• PhysicalWorld.cpp