CollisionSystem.h

#pragma once
#pragma once
#ifdef _WIN32
#pragma warning(push)
#pragma warning(disable: 4127)  // conditional expression is constant
#pragma warning(disable: 5033)  // 'register' is no longer a supported storage class
#endif
#include <btBulletDynamicsCommon.h>
#ifdef _WIN32
#pragma warning(pop)
#endif
 
#include "Systems/ComponentSystem.h"
#include "CollisionComponent.h"
 
namespace Cogs
{
  namespace Core
  {
    class PhysicsManager;
 
    struct CollisionData
    {
      std::unique_ptr<btCollisionShape> collisionShape;
      std::unique_ptr<btTriangleMesh> mesh;
    };
 
    template<typename T>
    class CollisionSystem : public ComponentSystemWithDataPool<T, CollisionData>
    {
    public:
      CollisionSystem(Memory::Allocator * allocator, Cogs::SizeType capacity) : ComponentSystemWithDataPool<T, CollisionData>(allocator, capacity) {}
    };
 
    class PlaneCollisionSystem : public CollisionSystem<PlaneCollisionComponent>
    {
    public:
      PlaneCollisionSystem(Memory::Allocator * allocator, Cogs::SizeType capacity) : CollisionSystem<PlaneCollisionComponent>(allocator, capacity) {}
 
      void update(Context * context) final;
    };
 
    class SphereCollisionSystem : public CollisionSystem<SphereCollisionComponent>
    {
    public:
      SphereCollisionSystem(Memory::Allocator * allocator, Cogs::SizeType capacity) : CollisionSystem<SphereCollisionComponent>(allocator, capacity) {}
 
      void update(Context * context) final;
    };
 
    class BoxCollisionSystem : public CollisionSystem<BoxCollisionComponent>
    {
    public:
      BoxCollisionSystem(Memory::Allocator * allocator, Cogs::SizeType capacity) : CollisionSystem<BoxCollisionComponent>(allocator, capacity) {}
 
      void update(Context * context) final;
    };
 
    class CapsuleCollisionSystem : public CollisionSystem<CapsuleCollisionComponent>
    {
    public:
      CapsuleCollisionSystem(Memory::Allocator * allocator, Cogs::SizeType capacity) : CollisionSystem<CapsuleCollisionComponent>(allocator, capacity) {}
 
      void update(Context * context) final;
    };
 
    class CylinderCollisionSystem : public CollisionSystem<CylinderCollisionComponent>
    {
    public:
      CylinderCollisionSystem(Memory::Allocator * allocator, Cogs::SizeType capacity) : CollisionSystem<CylinderCollisionComponent>(allocator, capacity) {}
 
      void update(Context * context) final;
    };
 
    class EmptyCollisionSystem : public CollisionSystem<EmptyCollisionComponent>
    {
    public:
      EmptyCollisionSystem(Memory::Allocator * allocator, Cogs::SizeType capacity) : CollisionSystem<EmptyCollisionComponent>(allocator, capacity) {}
 
      void update(Context * context) final;
    };
 
    class MeshCollisionSystem : public CollisionSystem<MeshCollisionComponent>
    {
    public:
      MeshCollisionSystem(Memory::Allocator * allocator, Cogs::SizeType capacity) : CollisionSystem<MeshCollisionComponent>(allocator, capacity) {}
 
      void update(Context * context) final;
    };
  }
}