Collision 2/2

Src/IAEngine/imp/cpp/Physics/Physics.cpp

@@ -25,6 +25,49 @@ namespace ia::iae
 {
     Vector<PhysicsComponent *> g_physicsComponents;
 
+    FLOAT32 Sq(IN FLOAT32 v)
+    {
+        return v * v;
+    }
+
+    enum class RectSide
+    {
+        NONE,
+        LEFT,
+        RIGHT,
+        TOP,
+        BOTTOM,
+    };
+
+    RectSide GetRectSide(IN glm::vec2 d)
+    {
+        const auto dX = abs(d.x);
+        const auto dY = abs(d.y);
+        if (d.x >= 0)
+        {
+            if (dX >= dY)
+            {
+                return RectSide::RIGHT;
+            }
+            else
+            {
+                return (d.y < 0) ? RectSide::TOP : RectSide::BOTTOM;
+            }
+        }
+        else
+        {
+            if (dX >= dY)
+            {
+                return RectSide::LEFT;
+            }
+            else
+            {
+                return (d.y < 0) ? RectSide::TOP : RectSide::BOTTOM;
+            }
+        }
+        return RectSide::NONE;
+    }
+
     VOID Physics::Initialize()
     {
     }
@@ -47,14 +90,45 @@ namespace ia::iae
     {
         const auto comp = g_physicsComponents[handle];
         const auto middle = comp->GetNode()->GetPosition() + movement + collider.Position + collider.Size / 2.0f;
+        const auto halfSize = collider.Size / 2.0f;
         for (const auto &t : g_physicsComponents)
         {
             if (t == comp)
                 continue;
-            for(const auto& tc: t->Colliders())
+            for (const auto &tc : t->Colliders())
             {
+                BOOL isColliding = false;
                 const auto tMiddle = t->GetNode()->GetPosition() + tc.Position + tc.Size / 2.0f;
-                
+                const auto tHalfSize = tc.Size / 2.0f;
+                const auto rectSide = GetRectSide(tMiddle - middle);
+                const auto distance = Sq(tMiddle.x - middle.x) + Sq(tMiddle.y - middle.y);
+                switch (rectSide)
+                {
+                case RectSide::LEFT:
+                case RectSide::RIGHT:
+                    isColliding = (Sq(tHalfSize.x + halfSize.x) >= distance);
+                    break;
+
+                case RectSide::TOP:
+                case RectSide::BOTTOM:
+                    isColliding = (Sq(tHalfSize.y + halfSize.y) >= distance);
+                    break;
+
+                default:
+                    isColliding = false;
+                    break;
+                }
+                if (isColliding)
+                {
+                    // Collision callback
+                    comp->OnCollision(t);
+                    t->OnCollision(comp);
+
+                    // Overlap block
+                    if (tc.IsTrigger)
+                        continue;
+                    return false;
+                }
             }
         }
         return true;

Src/IAEngine/inc/IAEngine/Nodes/Transform.hpp

@@ -23,6 +23,30 @@ namespace ia::iae
     template<typename _node_type> class Transform
     {
       public:
+        VOID Translate(IN glm::vec2 v)
+        {
+            m_local.Position += v;
+            RecalculatePosition();
+        }
+
+        VOID Scale(IN FLOAT32 v)
+        {
+            m_local.Scale *= v;
+            RecalculateScale();
+        }
+
+        VOID Scale(IN glm::vec2 v)
+        {
+            m_local.Scale *= v;
+            RecalculateScale();
+        }
+
+        VOID Rotate(IN FLOAT32 v)
+        {
+            m_local.Rotation += v;
+            RecalculateRotation();
+        }
+
         VOID SetLocalSortIndex(IN INT16 index)
         {
             m_local.SortIndex = index;