RigidBody.cpp

Go to the documentation of this file.

#include "physics/RigidBody.h"
 
#include <btBulletCollisionCommon.h>
#include <btBulletDynamicsCommon.h>
 
#include "Engine.h"
#include "LinearMath/btVector3.h"
#include "physics/CollisionObject.h"
 
namespace mnd
{
RigidBody::RigidBody(BodyType type, const std::shared_ptr<Collider> &collider, float mass, float friction)
    : m_type(type)
    , m_collider(collider)
    , m_mass(mass)
    , m_friction(friction)
{
    if (!collider)
    {
        return;
    }
 
    m_collisionObjType = CollisionObjectType::RigidBody;
 
    btVector3 inertia(0, 0, 0);
    if (m_type == BodyType::Dynamic && mass > 0.0f && m_collider->GetShape())
    {
        m_collider->GetShape()->calculateLocalInertia(btScalar(mass), inertia);
    }
 
    btTransform transform;
    transform.setIdentity();
    btDefaultMotionState *motionState = new btDefaultMotionState(transform);
 
    btRigidBody::btRigidBodyConstructionInfo info(
        (m_type == BodyType::Dynamic) ? btScalar(mass) : btScalar(0), motionState, m_collider->GetShape(), inertia
    );
 
    m_body = std::make_unique<btRigidBody>(info);
    m_body->setFriction(friction);
    m_body->setUserPointer(this);
 
    if (m_type == BodyType::Kinematic)
    {
        m_body->setCollisionFlags(m_body->getCollisionFlags() | btCollisionObject::CF_KINEMATIC_OBJECT);
        m_body->setActivationState(DISABLE_DEACTIVATION);
    }
}
 
RigidBody::~RigidBody()
{
    if (m_addedToWorld)
    {
        Engine::GetInstance().GetPhysicsManager().RemoveRigidBody(this);
    }
}
 
btRigidBody *RigidBody::GetBody()
{
    return m_body.get();
}
 
void RigidBody::SetAddedToWorld(bool added)
{
    m_addedToWorld = added;
}
 
bool RigidBody::IsAddedToWorld() const
{
    return m_addedToWorld;
}
 
BodyType RigidBody::GetType() const
{
    return m_type;
}
 
void RigidBody::SetPosition(const glm::vec3 &pos)
{
    if (!m_body)
    {
        return;
    }
 
    auto &tr = m_body->getWorldTransform();
    tr.setOrigin(btVector3(btScalar(pos.x), btScalar(pos.y), btScalar(pos.z)));
    if (m_body->getMotionState())
    {
        m_body->getMotionState()->setWorldTransform(tr);
    }
    m_body->setWorldTransform(tr);
}
 
glm::vec3 RigidBody::GetPosition() const
{
    if (!m_body)
    {
        return vec3(0.0f, 0.0f, 0.0f);
    }
    const auto &pos = m_body->getWorldTransform().getOrigin();
    return glm::vec3(pos.x(), pos.y(), pos.z());
}
 
void RigidBody::SetRotation(const glm::quat &rot)
{
    if (!m_body)
    {
        return;
    }
 
    auto &tr = m_body->getWorldTransform();
    tr.setRotation(btQuaternion(btScalar(rot.x), btScalar(rot.y), btScalar(rot.z), btScalar(rot.w)));
    if (m_body->getMotionState())
    {
        m_body->getMotionState()->setWorldTransform(tr);
    }
    m_body->setWorldTransform(tr);
}
 
glm::quat RigidBody::GetRotation() const
{
    if (!m_body)
    {
        return quat(1.0f, 0.0f, 0.0f, 0.0f);
    }
    const auto &rot = m_body->getWorldTransform().getRotation();
    return glm::quat(rot.w(), rot.x(), rot.y(), rot.z());
}
 
void RigidBody::ApplyImpulse(const vec3 &impulse)
{
    if (!m_body)
    {
        return;
    }
    m_body->applyCentralImpulse(btVector3(btScalar(impulse.x), btScalar(impulse.y), btScalar(impulse.z)));
}
 
void RigidBody::EnableCcd(float motionThreshold, float sweptRadius)
{
    if (!m_body)
    {
        return;
    }
    m_body->setCcdMotionThreshold(btScalar(motionThreshold));
    m_body->setCcdSweptSphereRadius(btScalar(sweptRadius));
}
 
}  // namespace mnd