RigidBody.hpp

Go to the documentation of this file.

#pragma once
 
#include <glm/glm.hpp>
#include <memory>
#include "SuperComponent.hpp"
 
class btCollisionObject;
class btGhostObject;
class btRigidBody;
class PhysicsManager;
 
namespace Physics {
class Shape;
class Trigger;
} // namespace Physics
 
namespace Component {
class RigidBody : public SuperComponent {
    friend class ::PhysicsManager;
    friend class ::Physics::Trigger;
    friend class Shape;
 
  public:
    RigidBody() = default;
 
    ~RigidBody();
 
    void Serialize(Json::Value& node, bool load) override;
 
 
    bool IsKinematic() const;
 
 
    bool IsGhost() const;
 
 
    float GetFriction() const;
 
 
    float GetRollingFriction() const;
 
 
    float GetSpinningFriction() const;
 
 
    float GetRestitution() const;
 
 
    float GetLinearDamping() const;
 
 
    float GetAngularDamping() const;
 
  private:
    // Get the underlying Bullet rigid body. If none has been set,
    // nullptr is returned.
    btRigidBody* GetBulletRigidBody();
 
    // Get the underlying Bullet collision object. If none has been
    // set, nullptr is returned. If the rigid body is not a ghost,
    // the returned collision object is the rigid body.
    btCollisionObject* GetBulletCollisionObject();
 
    // Creates the underlying Bullet rigid body. Mass is provided in
    // units of kilograms.
    void NewBulletRigidBody(float mass);
 
    // Destroy resources completely.
    void Destroy();
 
    void SetCollisionShape(std::shared_ptr<Physics::Shape> shape);
 
    // Get the position of a rigid body.
    glm::vec3 GetPosition() const;
 
    // Set the position of a rigid body.
    void SetPosition(const glm::vec3& pos);
 
    // Get the orientation of a rigid body.
    glm::quat GetOrientation() const;
 
    // Set the orientation of a rigid body.
    void SetOrientation(const glm::quat& rotation);
 
    // Get the mass in kilograms of a rigid body.
    float GetMass();
 
    // Set the mass in kilograms of a rigid body.
    void SetMass(float mass);
 
    void SetFriction(float friction);
    void SetRollingFriction(float friction);
    void SetSpinningFriction(float friction);
 
    void SetRestitution(float cor);
 
    void SetLinearDamping(float damping);
    void SetAngularDamping(float damping);
 
    void MakeKinematic();
    void MakeDynamic();
    void SetGhost(bool ghost);
 
    // Get/set whether a dynamic rigid body should synchronize its
    // transform against the owning entity during the next simulation.
    bool GetForceTransformSync() const;
    void SetForceTransformSync(bool sync);
 
    // Get/set whether a kinematic rigid body should halt its movement
    // during the next simulation frame.
    bool GetHaltMovement() const;
    void SetHaltMovement(bool halt);
 
    float mass = 1.0f;
    btRigidBody* rigidBody = nullptr;
    btGhostObject* ghostObject = nullptr;
    bool kinematic = false;
    bool forceTransformSync = true; // For first frame
    bool haltMovement = true;       // True for first frame
    float friction = 0.0f;
    float rollingFriction = 0.0f;
    float spinningFriction = 0.0f;
    float restitution = 0.0f;
    float linearDamping = 0.0f;
    float angularDamping = 0.0f;
    bool ghost = false;
    std::shared_ptr<Physics::Shape> shape;
};
} // namespace Component