ConstraintSystem.h

#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 "ConstraintComponent.h"
 
namespace Cogs
{
  namespace Core
  {
    class PhysicsManager;
 
    struct ConstraintData
    {
      template<typename T, typename... Args>
      T * createConstraint(Args && ... args)
      {
        constraint = std::make_unique<T>(std::forward<Args>(args)...);
 
        return static_cast<T *>(constraint.get());
      }
 
      std::unique_ptr<btTypedConstraint> constraint;
 
      glm::mat4 transform;
      glm::mat4 targetTransform;
 
      btRigidBody * rigidBody = nullptr;
      btRigidBody * targetRigidBody = nullptr;
    };
 
    template<typename T>
    class ConstraintSystem : public ComponentSystemWithDataPool<T, ConstraintData>
    {
    public:
      ConstraintSystem(Memory::Allocator * allocator, Cogs::SizeType capacity) : ComponentSystemWithDataPool<T, ConstraintData>(allocator, capacity) {}
    };
 
    class FixedConstraintSystem : public ConstraintSystem<FixedConstraintComponent>
    {
    public:
      FixedConstraintSystem(Memory::Allocator * allocator, Cogs::SizeType capacity) : ConstraintSystem(allocator, capacity) {}
 
      void update(Context * context) final;
 
      void destroyComponent(ComponentHandle component) final;
    };
 
    class HingeConstraintSystem : public ConstraintSystem<HingeConstraintComponent>
    {
    public:
      HingeConstraintSystem(Memory::Allocator * allocator, Cogs::SizeType capacity) : ConstraintSystem(allocator, capacity) {}
 
      void update(Context * context) final;
 
      void destroyComponent(ComponentHandle component) final;
    };
 
    class SpringConstraintSystem : public ConstraintSystem<SpringConstraintComponent>
    {
    public:
      SpringConstraintSystem(Memory::Allocator * allocator, Cogs::SizeType capacity) : ConstraintSystem(allocator, capacity) {}
 
      void update(Context * context) final;
 
      void destroyComponent(ComponentHandle component) final;
    };
 
    class GenericConstraintSystem : public ConstraintSystem<GenericConstraintComponent>
    {
    public:
      GenericConstraintSystem(Memory::Allocator * allocator, Cogs::SizeType capacity) : ConstraintSystem(allocator, capacity) {}
 
      void update(Context * context) final;
 
      void destroyComponent(ComponentHandle component) final;
    };
  }
}