PhysicsManager.h

#pragma once
#ifdef _WIN32
#pragma warning(push)
#pragma warning(disable: 4127)  // conditional expression is constant
#pragma warning(disable: 4324)  // structure was padded due to alignment specifier
#pragma warning(disable: 5033)  // 'register' is no longer a supported storage class
#endif
#include <btBulletDynamicsCommon.h>
#include <BulletCollision/CollisionShapes/btCylinderShape.h>
#ifdef _WIN32
#pragma warning(pop)
#endif
 
#include "EntityDefinition.h"
#include "Services/TaskManager.h"
#include "Systems/Core/DynamicComponentSystem.h"
 
#include "Foundation/ComponentModel/Entity.h"
#include "Foundation/Reflection/TypeDatabase.h"
#include "Foundation/Platform/Threads.h"
 
#include <memory>
#include <unordered_map>
#include <glm/glm.hpp>
 
namespace Cogs
{
  namespace Core
  {
    struct SizeT
    {
      size_t value;
    };
 
    struct CollisionDetail
    {
      SizeT idA;
      SizeT idB;
 
      glm::vec3 positionA;
      glm::vec3 positionB;
 
      float impulse;
 
      static void registerType();
    };
 
    struct CollisionInfo
    {
      size_t contactCode;
 
      WeakEntityPtr entityA;
      WeakEntityPtr entityB;
 
      CollisionDetail detail;
 
      bool trigger;
      bool visited;
    };
 
    inline btVector3 toBullet(const glm::vec3 & v)
    {
      return btVector3(v.x, v.y, v.z);
    }
 
    inline btQuaternion toBullet(const glm::quat & v)
    {
      btQuaternion b;
      b.deSerializeFloat(*reinterpret_cast<const btQuaternionData *>(&v));
      return b;
    }
 
    class Context;
 
    class PhysicsManager
    {
    public:
      explicit PhysicsManager(Context * context);
      ~PhysicsManager();
 
      static Reflection::TypeId getTypeId() { return Reflection::TypeDatabase::getType<PhysicsManager>().getTypeId(); }
 
      void addRigidBody(btRigidBody * rigidBody);
      void removeRigidBody(btRigidBody * rigidBody);
 
      void addCollisionObject(btCollisionObject * btCollisionObject);
      void removeCollisionObject(btCollisionObject * btCollisionObject);
 
      void addConstraint(btTypedConstraint * constraint);
      void removeConstraint(btTypedConstraint * constraint);
 
      void preUpdate(Context* context);
 
      void postUpdate(Context* context);
 
      void waitForASync(Context* context);
 
      constexpr Context* getContext() noexcept { return context; }
 
    private:
 
      void stepSimulation(float deltaTime);
      void pullGhostState();
      void pushGhostState();
 
    private:
      Context* context;
 
      bool ghostCallbackSet = false;
 
      std::unique_ptr<btBroadphaseInterface> broadphase;
      std::unique_ptr<btDefaultCollisionConfiguration> collisionConfiguration;
      std::unique_ptr<btCollisionDispatcher> dispatcher;
      std::unique_ptr<btSequentialImpulseConstraintSolver> solver;
      std::unique_ptr<btDiscreteDynamicsWorld> dynamicsWorld;
 
      struct CollisionEvent
      {
        CollisionInfo * info;
        MessageId id;
      };
 
      TaskId task = NoTask;
    };
  }
}
 
template<> inline Cogs::StringView getName<Cogs::Core::PhysicsManager>() { return "PhysicsManager"; }
template<> inline Cogs::StringView getName<Cogs::Core::SizeT>() { return "SizeT"; }
template<> inline Cogs::StringView getName<Cogs::Core::CollisionDetail>() { return "CollisionDetail"; }