Components.hpp

#ifndef COMPONENTS_HPP
#define COMPONENTS_HPP
 
#include <utility>
#include "pch.hpp"
#include "PhysicsParam.hpp"
#include "Types.hpp"
#include "Entity.hpp"
 
namespace Engine {
 
  struct Transform;
  struct Collider;
  struct RigidBody;
  struct PhysicsEntity;
 
  //<editor-fold desc="Physics">
  struct CollisionHook {
    virtual void processCollision(const Ref<PhysicsEntity>& other) {};
  };
 
  struct Collider {
    bool trigger = false; 
    Ref<CollisionHook> hook; 
 
    void processCollision(const Ref<PhysicsEntity>& other) { if (hook != nullptr) hook->processCollision(other);};
    [[nodiscard]] virtual glm::vec3 furthestInDir(const Ref<PhysicsEntity> &pe, const glm::vec3 &norm) const {return {0, 0, 0};}
  };
 
  struct PhysicsEntity {
    PhysicsEntity(Ref<Entity>& e, Ref<Transform>& transform, Ref<Collider>& collider, Ref<RigidBody>& rigidBody):
        entity(e), tf(transform), c(collider), rb(rigidBody) {};
 
    Ref<Entity> entity;
    Ref<Transform> tf = nullptr;
    Ref<Collider> c = nullptr;
    Ref<Collider> cuse = nullptr;
    Ref<RigidBody> rb = nullptr;
 
    glm::vec3 v{0}; 
    glm::vec3 w{0}; 
    glm::vec3 x{0}; 
    glm::vec3 xPrev{0}; 
 
 
    glm::qua<float> q{}; 
    glm::qua<float> qPrev{}; 
    glm::qua<float> dQ{}; 
 
    bool matUpdated = true;
    bool itmatUpdated = true;
 
 
    glm::mat4 getMat() {
      if (matUpdated) {
        calcMat();
      }
      return mat;
    }
 
    glm::mat4 getIMat() {
      if (itmatUpdated) {
        calcITMat();
      }
      return imat;
    }
 
    void clearMat() {
      itmatUpdated = true;
      matUpdated = true;
    }
 
  private:
    void calcMat() {
      mat = (glm::translate(x) * glm::toMat4(q));
      matUpdated = false;
    }
 
    void calcITMat() {
      imat = glm::affineInverse(getMat());
      itmatUpdated = false;
    }
 
    glm::mat4 mat {};
    glm::mat4 imat {};
  };
 
  struct Shape {
    explicit Shape(Ref<PhysicsEntity>& pe):  pe(pe){};
    Ref<PhysicsEntity> pe;
    [[nodiscard]] glm::vec3 furthestInDir(const glm::vec3 &norm) const {
      return pe->c->furthestInDir(pe, norm);
    }
  };
 
  struct Support : public glm::vec3 {
    glm::vec3 supportA;
    glm::vec3 supportB;
 
    Support &operator=(glm::vec3 support) {
      x = support.x;
      y = support.y;
      z = support.z;
      return *this;
    }
 
    Support &operator=(const Support& support) {
      x = support.x;
      y = support.y;
      z = support.z;
      supportA = support.supportA;
      supportB = support.supportB;
      return *this;
    }
  };
 
  struct CollisionPoint {
    glm::vec3 Normal;
    std::vector<glm::vec3> contacts;
    float PenetrationDepth;
    bool HasCollision;
  };
 
  struct Simplex {
    std::vector<Support> supports = std::vector<Support>(SIMPLEX_COUNT); 
    size_t index = 0;
 
    Simplex &operator=(std::initializer_list<Support> ilist) {
      int i = 0;
      for (auto item : ilist) {
        supports[i] = item;
        i++;
      }
      index = ilist.size();
 
      return *this;
    }
 
    Support &operator[](const int &i) {
      return supports[i];
    }
 
    void operator+=(const Support &support) {
      supports[index] = support;
      index++;
    }
 
    void add(glm::vec3 p, glm::vec3 a, glm::vec3 b) {
      supports[index] = p;
      supports[index].supportA = a;
      supports[index].supportB = b;
      index++;
    }
 
    void set(int i, glm::vec3 p, glm::vec3 a, glm::vec3 b) {
      supports[i] = p;
      supports[i].supportA = a;
      supports[i].supportB = b;
    }
 
    void push(Support p) {
      for (size_t i = index; i >= 1; i--) {
        supports[i] = supports[i - 1];
      }
 
      supports[0] = p;
      index++;
    }
 
    void push(glm::vec3 p, glm::vec3 a, glm::vec3 b) {
      for (int i = SIMPLEX_COUNT - 1; i >= 1; i--) {
        supports[i] = supports[i - 1];
      }
 
      supports[0] = p;
      supports[0].supportA = a;
      supports[0].supportB = b;
      index++;
    }
  };
 
  struct FacePoint {
    std::vector<Support> verts = std::vector<Support>(FACE_VERTS);
    glm::vec3 normal{};
 
    Support &operator[](const int &i) {
      return verts[i];
    }
 
    FacePoint &operator=(FacePoint support) {
      for (int i = 0; i < FACE_VERTS; ++i) {
        verts[i] = support[i];
      }
      normal = support.normal;
      return *this;
    }
 
    FacePoint &operator=(std::initializer_list<Support> list) {
      int i = 0;
      for (Support elem : list) {
        verts[i] = elem;
        ++i;
      }
      return *this;
    }
  };
 
  struct Joint {
    glm::vec3 positionA = {0,0,0}, positionB{};
    Ref<RigidBody> connectedRigidBody = nullptr;
    float minLength = 0;
    float maxLength = 0;
    float springConstant = 0;
    Ref<RigidBody> rigidBody = nullptr;
 
    explicit Joint(Ref<RigidBody>& otherRigidBody, float maxLength) {
      connectedRigidBody = otherRigidBody;
      this->maxLength = maxLength;
    }
 
    Joint(glm::vec3 selfPosition, glm::vec3 globalPosition) {
      positionA = selfPosition;
      positionB = globalPosition;
    }
 
    explicit Joint(glm::vec3 globalPosition, float maxLength = 0) {
      positionA = {0, 0, 0};
      positionB = globalPosition;
      this->maxLength = maxLength;
    }
  };
  //</editor-fold>
 
  struct Transform {
    glm::vec3 position = {0.f, 0.f, 0.f};
    glm::qua<float> rotation = {1.f, 0.f, 0.f, 0.f};
    glm::vec3 scale = {1.f, 1.f, 1.f};
 
    Transform(glm::vec3 p, glm::vec3 r, glm::vec3 s):
      position(p),
      rotation(glm::radians(r)),
      scale(s) {
 
    };
 
    Transform(const Transform&) = default;
    Transform() = default;
 
    glm::mat4 GetMatrix() const{
      glm::mat4 t(1.f);
      auto positionM = glm::translate(t, position);
      auto rotationM = glm::toMat4(rotation);
      auto scaleM = glm::scale(t, scale);
 
      return positionM * rotationM * scaleM;
    }
 
  };
 
  struct ForceApplier {
  public:
    glm::vec3 force;
  };
 
  enum Allignment {
    TOP_LEFT, TOP, TOP_RIGHT,
    LEFT, CENTER, RIGHT,
    BOTTOM_LEFT, BOTTOM, BOTTOM_RIGHT
  };
 
 
  struct ForceGenerator {
  public:
    glm::vec3 force;
  };
 
  struct RigidBody {
    RigidBody() = default;
    RigidBody(float height, float width, float depth, float m) {
      setMomentCube(height, width, depth, m);
    }
 
    glm::vec3 velocity = glm::vec3(0, 0, 0);
    glm::vec3 force = glm::vec3(0, 0, 0);
 
    float airDrag = 0.1f;
    float angularDrag = 1.f;
 
    bool kinematic = true;
 
    glm::mat3 moment;
    glm::mat3 invMoment;
 
    glm::vec3 w = glm::vec3(0, 0, 0);
    glm::vec3 t = glm::vec3(0, 0.f, 0);
 
    Ref<PhysicsEntity> physicsEntity;
 
    void setMomentCube(float height, float width, float depth, float m) {
      if (m == 0) {
        moment = glm::mat4{0};
        iMass = 0;
      } else {
        moment = {{I12 * ((height * height) + (depth * depth)), 0, 0},
                  {0, I12 * ((width * width) + (depth * depth)), 0},
                  {0, 0, I12 * ((width * width) + (height * height))}};
        moment *= m;
        invMoment = glm::inverse(moment);
        iMass = 1 / m;
      }
    }
 
    float iMass = 1;
    float drag = 2.98f;
    bool grounded = true;
  };
 
  struct VertexCollider : virtual Collider {
    VertexCollider() = default;
    explicit VertexCollider(std::vector<glm::vec3> verts) : verts(std::move(verts)) {}
    std::vector<glm::vec3> verts;
 
    [[nodiscard]] glm::vec3 furthestInDir(const Ref<PhysicsEntity>& pe, const glm::vec3 &norm) const override {
      // convert to model space
      glm::mat4 mat = pe->getMat();
      glm::vec3 out;
 
      bool found = false;
      float f, o;
 
      for (glm::vec3 v : verts) {
        v = glm::vec3{mat * glm::vec4{v, 1.0f}};
        o = glm::dot(norm, v);
        if (!found || o > f) {
          f = o;
          out = v;
          found = true;
        }
      }
      // convert back to global space
      return out;
    }
 
    static Ref<VertexCollider> boxCollider(float width = 64, float height = 64, float depth = 64) {
      Ref<VertexCollider> vertexCollider = CreateRef<VertexCollider>();
      float back = depth / 2.0f;
      float front = depth / 2.0f;
      float up = height  / 2.0f;
      float down = height / 2.0f;
      float left = width  / 2.0f;
      float right = width / 2.0f;
      vertexCollider->verts = std::vector<glm::vec3> {{-left, -down, back}, {-left, up, back},
                                                      {right, up, back}, {right, -down, back},
                                                      {-left, -down, -front}, {-left, up, -front},
                                                      {right, up, -front}, {right, -down, -front}};
      return vertexCollider;
    }
  };
 
  struct Collider2D: virtual Collider {
  };
 
  struct VertexCollider2D : Collider2D, VertexCollider {
    VertexCollider2D() = default;
    explicit VertexCollider2D(std::vector<glm::vec3> verts) : VertexCollider(std::move(verts)) {
      trigger = true;
    };
  };
 
}
 
#endif