PhysicsManager.hpp

Go to the documentation of this file.

#pragma once
 
#include <functional>
#include <glm/glm.hpp>
#include <memory>
#include <Utility/LockBox.hpp>
#include <vector>
#include "../Entity/ComponentContainer.hpp"
 
namespace Component {
class RigidBody;
class Shape;
} // namespace Component
 
namespace Physics {
class Shape;
class Trigger;
} // namespace Physics
 
class btBroadphaseInterface;
class btDefaultCollisionConfiguration;
class btCollisionDispatcher;
class btSequentialImpulseConstraintSolver;
class btDiscreteDynamicsWorld;
class Entity;
 
class PhysicsManager {
    friend class Hub;
 
  public:
 
    void Update(float deltaTime);
 
    void UpdateEntityTransforms();
 
 
    void OnTriggerEnter(Utility::LockBox<Physics::Trigger> trigger, Component::RigidBody* object, std::function<void()> callback);
 
 
    void ForgetTriggerEnter(Utility::LockBox<Physics::Trigger> trigger, Component::RigidBody* object);
 
 
    void OnTriggerRetain(Utility::LockBox<Physics::Trigger> trigger, Component::RigidBody* object, std::function<void()> callback);
 
 
    void ForgetTriggerRetain(Utility::LockBox<Physics::Trigger> trigger, Component::RigidBody* object);
 
 
    void OnTriggerLeave(Utility::LockBox<Physics::Trigger> trigger, Component::RigidBody* object, std::function<void()> callback);
 
 
    void ForgetTriggerLeave(Utility::LockBox<Physics::Trigger> trigger, Component::RigidBody* object);
 
 
    Component::RigidBody* CreateRigidBody(Entity* owner);
 
 
    Component::Shape* CreateShape(Entity* owner);
 
 
    Utility::LockBox<Physics::Trigger> CreateTrigger(std::shared_ptr<Physics::Shape> shape);
 
 
    void ReleaseTriggerVolume(Utility::LockBox<Physics::Trigger>&& trigger);
 
 
    void SetPosition(Utility::LockBox<Physics::Trigger> trigger, const glm::vec3& position);
 
 
    void SetShape(Component::Shape* comp, std::shared_ptr<::Physics::Shape> shape);
 
 
    float GetMass(Component::RigidBody* comp);
 
 
    void SetShape(Utility::LockBox<Physics::Trigger> trigger, std::shared_ptr<Physics::Shape> shape);
 
 
    void SetMass(Component::RigidBody* comp, float mass);
 
 
    void SetFriction(Component::RigidBody* comp, float friction);
 
 
    void SetRollingFriction(Component::RigidBody* comp, float friction);
 
 
    void SetSpinningFriction(Component::RigidBody* comp, float friction);
 
 
    void SetRestitution(Component::RigidBody* comp, float cor);
 
 
    void SetLinearDamping(Component::RigidBody* comp, float damping);
 
 
    void SetAngularDamping(Component::RigidBody* comp, float damping);
 
 
    void MakeKinematic(Component::RigidBody* comp);
 
 
    void MakeDynamic(Component::RigidBody* comp);
 
 
    void SetGhost(Component::RigidBody* comp, bool ghost);
 
 
    void ForceTransformSync(Component::RigidBody* comp);
 
 
    void HaltMovement(Component::RigidBody* comp);
 
 
    const std::vector<Component::Shape*>& GetShapeComponents() const;
 
    void ClearKilledComponents();
 
 
    btDiscreteDynamicsWorld* GetDynamicsWorld();
 
  private:
    PhysicsManager();
    ~PhysicsManager();
    PhysicsManager(PhysicsManager const&) = delete;
    void operator=(PhysicsManager const&) = delete;
 
    glm::vec3 gravity = glm::vec3(0.f, -9.82f, 0.f);
 
    ComponentContainer<Component::RigidBody> rigidBodyComponents;
    ComponentContainer<Component::Shape> shapeComponents;
 
    btBroadphaseInterface* broadphase = nullptr;
    btDefaultCollisionConfiguration* collisionConfiguration = nullptr;
    btCollisionDispatcher* dispatcher = nullptr;
    btSequentialImpulseConstraintSolver* solver = nullptr;
    btDiscreteDynamicsWorld* dynamicsWorld = nullptr;
 
    std::shared_ptr<Utility::LockBox<Physics::Trigger>::Key> triggerLockBoxKey;
    std::vector<::Physics::Trigger*> triggers;
};