types.hpp

Go to the documentation of this file.

#pragma once
#include <EventBus.hpp>
#include <entt/entt.hpp>
#include <glm/glm.hpp>
#include <variant>
 
namespace phys2d {
 
/* Maths */
constexpr float pi  = 3.14159265;
constexpr float pi2 = pi * 2;
constexpr float inf = 2e5;
 
/* Precision*/
constexpr float epsilon = 1e-6;
 
/* RigidBody*/
constexpr float rb_defaultDamping      = 0.01f;
constexpr float rb_defaultRestitution  = 0.5f;
constexpr float rb_defaultFriction     = 0.2f;
constexpr float rb_defaultInvMass      = 1.0f;
constexpr float rb_defaultInvInertia   = 1.0f;
constexpr float rb_defaultGravityScale = 1.0f;
 
/* Collider */
constexpr glm::vec2 cd_defaultLocalOffset = {0.0f, 0.0f};
constexpr bool cd_defaultTriggerStatus    = false;
 
enum class BodyType {
  Static,     
  Kinematic,  
  Dynamic     
};
 
enum class BodyShape {
  Polygon,      
  Circle,       
  Capsule,      
  Segment,      
  SegmentChain  
};
 
struct AABB {
  glm::vec2 lowerBound;  
  glm::vec2 upperBound;  
 
  AABB() = default;
  AABB(const glm::vec2& lb, const glm::vec2& ub);
 
  bool collidesWith(const AABB& other) const;
};
 
bool checkCollision(const AABB& aabb1, const AABB& aabb2);
 
struct TransformComponent {
  glm::vec2 position{0.0f, 0.0f};  
  float rotation{0.0f};            
  float scaling{1.0f};             
 
  mutable bool dirty{true};             
  mutable glm::mat3 modelMatrix{1.0f};  
 
  void updateMatrix() const;
 
  TransformComponent() = default;
 
  TransformComponent(const glm::vec2& position, float rotation, float scaling);
 
  const glm::vec2 getForward() const;
 
 
  void setPosition(const glm::vec2& new_position);
 
  void setRotation(const float new_angle);
 
  void setScale(float new_scale);
 
  void move(const glm::vec2& direction);
 
  void rotate(float angle_delta);
 
  void scale(float scale_coef);
};
 
struct RigidBodyComponent {
  BodyType bodyType = BodyType::Dynamic;  
 
  glm::vec2 linearVelocity{0.0f, 0.0f};         
  glm::vec2 force{0.0f, 0.0f};                  
  float gravityScale = rb_defaultGravityScale;  
 
  float angularVelocity = 0.0f;  
  float torque          = 0.0f;  
 
  float invMass =
    rb_defaultInvMass;  
  float invInertia = rb_defaultInvInertia;  
 
  float linearDamping  = rb_defaultDamping;  
  float angularDamping = rb_defaultDamping;  
 
  float restitution = rb_defaultRestitution;  
  float friction    = rb_defaultFriction;     
 
  RigidBodyComponent() = default;
 
  RigidBodyComponent(phys2d::BodyType bt);
 
  RigidBodyComponent(BodyType bt, const glm::vec2& linearVelocity, const glm::vec2& force,
                     float gravityScale, float angularVelocity, float torque, float mass,
                     float inertia, float linearDamping, float angularDamping, float restitution,
                     float friction);
};
 
struct PolygonGeometry {
  std::vector<glm::vec2> vertices;
};
 
struct CircleGeometry {
  float radius;
};
 
struct CapsuleGeometry {
  float radius;
  float rectangleLen;
};
 
struct SegmentGeometry {
  glm::vec2 borders[2];
};
 
struct SegmentChain {
  std::vector<glm::vec2> points;
};
 
using ShapeData = std::variant<PolygonGeometry, CircleGeometry>;
 
namespace ColliderLayers {
constexpr uint32_t None             = 0x0000;
constexpr uint32_t Player           = 0x0001;
constexpr uint32_t PlayerProjectile = 0x0002;
constexpr uint32_t Enemy            = 0x0004;
constexpr uint32_t EnemyProjectile  = 0x0008;
constexpr uint32_t Environment      = 0x0010;
constexpr uint32_t All              = 0xFFFF;
}  // namespace ColliderLayers
 
struct ColliderComponent {
  BodyShape shapeType;  
  ShapeData shapeData;  
  glm::vec2 localOffset = cd_defaultLocalOffset;  
  bool isTrigger = cd_defaultTriggerStatus;  
  uint32_t categoryBits = ColliderLayers::Player;  
  uint32_t maskBits =
    ColliderLayers::All & ~ColliderLayers::PlayerProjectile;  
 
  ColliderComponent();
  ColliderComponent(const BodyShape& st);
  template <typename Geometry>
  ColliderComponent(Geometry&& geom, const glm::vec2& offset = cd_defaultLocalOffset,
                    bool trigger          = cd_defaultTriggerStatus,
                    uint32_t categoryBits = ColliderLayers::Player,
                    uint32_t maskBits     = ColliderLayers::All & ~ColliderLayers::PlayerProjectile)
    : localOffset(offset), isTrigger(trigger), categoryBits(categoryBits), maskBits(maskBits) {
    if constexpr (std::is_same_v<std::decay_t<Geometry>, phys2d::PolygonGeometry>) {
      shapeData     = PolygonGeometry();
      shapeType     = phys2d::BodyShape::Polygon;
      *getPolygon() = std::forward<Geometry>(geom);
    } else if constexpr (std::is_same_v<std::decay_t<Geometry>, phys2d::CircleGeometry>) {
      shapeData    = CircleGeometry();
      shapeType    = phys2d::BodyShape::Circle;
      *getCircle() = std::forward<Geometry>(geom);
    }
  }
 
  CircleGeometry* getCircle();
 
  const CircleGeometry* getCircle() const;
 
  PolygonGeometry* getPolygon();
 
  const PolygonGeometry* getPolygon() const;
 
  AABB getAABB(const TransformComponent& tc) const;
};
 
class PhysicsSystem {
public:
  PhysicsSystem(entt::registry& registry);
 
  void update(float dt);
 
  void setGravity(const glm::vec2& g);
 
  glm::vec2 getGravity() const;
 
  void setRegistry(entt::registry* registry);
 
  void setEventBus(EventBus* eventBus);
 
private:
  void integrateForcesAndVelocities(float dt);
 
  void checkCollisions();
 
  void processImpulseAndPushback(entt::entity eA, entt::entity eB, const glm::vec2& normal,
                                 float penetration, bool isTriggerA, bool isTriggerB);
 
  bool collideCircleVsCircle(entt::entity e1, const TransformComponent& tc1,
                             const CircleGeometry& geometry1, entt::entity e2,
                             const TransformComponent& tc2, const CircleGeometry& geometry2);
 
  bool collideCircleVsPolygon(entt::entity e1, const TransformComponent& tc1,
                              const CircleGeometry& geometry1, entt::entity e2,
                              const TransformComponent& tc2, const PolygonGeometry& geometry2,
                              bool flipNormal);
 
  bool collidePolygonVsPolygon(entt::entity e1, const TransformComponent& tc1,
                               const PolygonGeometry& geometry1, entt::entity e2,
                               const TransformComponent& tc2, const PolygonGeometry& geometry2);
 
private:
  glm::vec2 gravity{0.0f, 0.0f};  
  entt::registry* registry;       
  EventBus* eventBus;             
};
 
}  // namespace phys2d