PhysicsManager.cpp

Go to the documentation of this file.

#include "physics/PhysicsManager.h"
 
#include <btBulletCollisionCommon.h>
#include <btBulletDynamicsCommon.h>
 
#include "Constants.h"
#include "physics/CollisionObject.h"
#include "physics/Raycast.h"
#include "physics/RigidBody.h"
 
namespace mnd
{
PhysicsManager::PhysicsManager() {}
 
PhysicsManager::~PhysicsManager() {}
 
void PhysicsManager::Init()
{
    m_broadphase      = std::make_unique<btDbvtBroadphase>();
    m_collisionConfig = std::make_unique<btDefaultCollisionConfiguration>();
    m_dispatcher      = std::make_unique<btCollisionDispatcher>(m_collisionConfig.get());
    m_solver          = std::make_unique<btSequentialImpulseConstraintSolver>();
    m_world           = std::make_unique<btDiscreteDynamicsWorld>(
        m_dispatcher.get(), m_broadphase.get(), m_solver.get(), m_collisionConfig.get()
    );
 
    m_world->setGravity(btVector3(0, kGravity, 0));
}
 
void PhysicsManager::Update(float deltaTime)
{
    m_world->stepSimulation(deltaTime, kMaxSubSteps, kFixedTimeStep);
 
    auto       dispatcher   = m_world->getDispatcher();
    const auto numManifolds = dispatcher->getNumManifolds();
 
    for (int i = 0; i < numManifolds; ++i)
    {
        auto manifold = dispatcher->getManifoldByIndexInternal(i);
 
        if (!manifold)
        {
            continue;
        }
 
        auto bodyA = reinterpret_cast<CollisionObject *>(manifold->getBody0()->getUserPointer());
        auto bodyB = reinterpret_cast<CollisionObject *>(manifold->getBody1()->getUserPointer());
 
        if (!bodyA || !bodyB)
        {
            continue;
        }
 
        const auto numContacts = manifold->getNumContacts();
        for (int j = 0; j < numContacts; ++j)
        {
            const auto &point = manifold->getContactPoint(j);
            const vec3  pos(point.m_positionWorldOnB.x(), point.m_positionWorldOnB.y(), point.m_positionWorldOnB.z());
            const vec3  norm(point.m_normalWorldOnB.x(), point.m_normalWorldOnB.y(), point.m_normalWorldOnB.z());
 
            bodyA->DispatchContactEvent(bodyB, pos, norm);
            bodyB->DispatchContactEvent(bodyA, pos, norm);
        }
    }
}
 
void PhysicsManager::AddRigidBody(RigidBody *body)
{
    if (!body || !m_world)
    {
        return;
    }
 
    if (auto rigidBody = body->GetBody())
    {
        m_world->addRigidBody(rigidBody, btBroadphaseProxy::StaticFilter, btBroadphaseProxy::AllFilter);
        body->SetAddedToWorld(true);
    }
}
 
void PhysicsManager::RemoveRigidBody(RigidBody *body)
{
    if (!body || !m_world)
    {
        return;
    }
 
    if (auto rigidBody = body->GetBody())
    {
        m_world->removeRigidBody(rigidBody);
        body->SetAddedToWorld(false);
    }
}
 
btDiscreteDynamicsWorld *PhysicsManager::GetWorld()
{
    return m_world.get();
}
 
bool PhysicsManager::Raycast(const vec3 &from, const vec3 &to, RayHit &out)
{
    if (!m_world)
    {
        return false;
    }
 
    const btVector3 btFrom(btScalar(from.x), btScalar(from.y), btScalar(from.z));
    const btVector3 btTo(btScalar(to.x), btScalar(to.y), btScalar(to.z));
 
    btCollisionWorld::ClosestRayResultCallback cb(btFrom, btTo);
    m_world->rayTest(btFrom, btTo, cb);
 
    if (!cb.hasHit())
    {
        return false;
    }
 
    out.point    = vec3(cb.m_hitPointWorld.x(), cb.m_hitPointWorld.y(), cb.m_hitPointWorld.z());
    out.normal   = vec3(cb.m_hitNormalWorld.x(), cb.m_hitNormalWorld.y(), cb.m_hitNormalWorld.z());
    out.fraction = cb.m_closestHitFraction;
    out.object   = nullptr;
 
    if (cb.m_collisionObject)
    {
        if (auto *co = reinterpret_cast<CollisionObject *>(cb.m_collisionObject->getUserPointer()))
        {
            out.object = co->GetOwner();
        }
    }
 
    return true;
}
}  // namespace mnd