CollisionTable.h

#pragma once
#include "AABB2DCollider.h"
#include "CircleCollider.h"
#include "PolygonCollider.h"

namespace Framework
{
#define MY_FORCE_INLINE __forceinline

	class CollisionTable
	{
	public:
        static MY_FORCE_INLINE bool AreColliding(const TransformedCircle circleA, const TransformedCircle circleB)
        {
            const float combinedRadius2 = Math::sqr(circleA.mRadius + circleB.mRadius);
            return glm::distance2(circleA.mWorldPosition, circleB.mWorldPosition) <= combinedRadius2;
        }

        static MY_FORCE_INLINE bool AreColliding(const TransformedAABB boxA, const TransformedAABB boxB)
        {
            return boxA.mMin.x < boxB.mMax.x
                && boxA.mMax.x > boxB.mMin.x
                && boxA.mMax.y > boxB.mMin.y
                && boxA.mMin.y < boxB.mMax.y;
        }

        static MY_FORCE_INLINE bool AreColliding(const TransformedPolygon& polygonA, const TransformedPolygon& polygonB)
        {
            if (!AreColliding(polygonA.mBoundingBox, polygonB.mBoundingBox))
            {
                return false;
            }

            for (uint i = 0, j = polygonA.mPoints.size() - 1; i < polygonA.mPoints.size(); j = i++)
            {
                if (polygonB.CollidesWith({ polygonA.mPoints[i], polygonA.mPoints[j] }))
                {
                    return true;
                }
            }

            // None of the lines intersect, but it's still possible that one of them is completely inside the other one.
            return polygonA.Contains(polygonB.mPoints.front())
                || polygonB.Contains(polygonA.mPoints.front());
        }

        static MY_FORCE_INLINE bool AreColliding(const TransformedPolygon& polygon, const TransformedCircle circle)
        {
            if (!AreColliding(polygon.mBoundingBox, circle))
            {
                return false;
            }

            for (uint i = 0, j = polygon.mPoints.size() - 1; i < polygon.mPoints.size(); j = i++)
            {
                if (circle.CollidesWith({ polygon.mPoints[i], polygon.mPoints[j] }))
                {
                    return true;
                }
            }

            // None of the lines intersect and none of the polygon's points are inside the circle, but maybe the circle is completely inside the polygon
            return polygon.Contains(circle.mWorldPosition);
        }

        static MY_FORCE_INLINE bool AreColliding(const TransformedPolygon& polygon, const TransformedAABB aabb)
        {
            if (!AreColliding(polygon.mBoundingBox, aabb))
            {
                return false;
            }

            for (uint i = 0, j = polygon.mPoints.size() - 1; i < polygon.mPoints.size(); j = i++)
            {
                if (aabb.CollidesWith({ polygon.mPoints[i], polygon.mPoints[j] }))
                {
                    return true;
                }
            }

            // None of the lines of the polygon intersected with the box. Either the box is fully outside, or fully inside.
            return polygon.Contains(aabb.GetCentre());
        }

        // https://learnopengl.com/In-Practice/2D-Game/Collisions/Collision-Detection
        static MY_FORCE_INLINE bool AreColliding(const TransformedAABB aabb, const TransformedCircle circle)
        {
            // calculate AABB info (center, half-extents)
            const glm::vec2 size = aabb.GetSize();
            const glm::vec2 halfSize = size * 0.5f;
            const glm::vec2 aabbCentre = aabb.mMin + halfSize;

            // get difference vector between both centers
            glm::vec2 difference = circle.mWorldPosition - aabbCentre;
            glm::vec2 clamped = glm::clamp(difference, -halfSize, halfSize);
            // add clamped value to AABB_center and we get the value of box closest to circle
            glm::vec2 closest = aabbCentre + clamped;
            // retrieve vector between center circle and closest point AABB and check if length <= radius
            difference = closest - circle.mWorldPosition;
            return glm::length(difference) < circle.mRadius;
        }

        static MY_FORCE_INLINE bool AreColliding(const Math::Line line1, const Math::Line line2)
        {
            return Math::LineIntersection(line1, line2);
        }

        static MY_FORCE_INLINE bool AreColliding(const Math::Line line, const TransformedAABB aabb)
        {
            // https://tavianator.com/2022/ray_box_boundary.html
            // While this is fast, rays completely inside the box will be considered an intersection, which may not be what we want.
            float tmin = 0.0, tmax = INFINITY;

            const glm::vec2 invRayDir = 1.0f / (line.mEnd - line.mStart);

            for (int i = 0; i < 2; ++i)
            {
                float t1 = (aabb.mMin[i] - line.mStart[i]) * invRayDir[i];
                float t2 = (aabb.mMax[i] - line.mStart[i]) * invRayDir[i];

                tmin = glm::max(tmin, glm::min(glm::min(t1, t2), tmax));
                tmax = glm::min(tmax, glm::max(glm::max(t1, t2), tmin));
            }

            return tmin < tmax&& tmin <= 1.0f;
        }

        static MY_FORCE_INLINE bool AreColliding(const Math::Line line, const TransformedCircle circle)
        {
            // Uses the signed distance to a line segment function from:
            // https://iquilezles.org/articles/distfunctions2d/

            const glm::vec2 pa = circle.mWorldPosition - line.mStart, ba = line.mEnd - line.mStart;

            float h = glm::clamp(dot(pa, ba) / dot(ba, ba), 0.0f, 1.0f);
            float distance2ToLine = length2(pa - ba * h);
            return distance2ToLine <= circle.mRadius2;
        }

        static MY_FORCE_INLINE bool AreColliding(const Math::Line line, const TransformedPolygon& polygon)
        {
            if (!AreColliding(polygon.mBoundingBox, line)
                && !polygon.mBoundingBox.Contains(line.mStart)) // The ray might have started and ended inside the box, hence the additonal check
            {
                return false;
            }

            for (uint i = 0, j = polygon.mPoints.size() - 1; i < polygon.mPoints.size(); j = i++)
            {
                if (Math::LineIntersection(line, { polygon.mPoints[i], polygon.mPoints[j] }))
                {
                    return true;
                }
            }

            return false;
        }

        static MY_FORCE_INLINE bool AreColliding(const TransformedCircle circle, const TransformedPolygon& polygon) { return AreColliding(polygon, circle); }
        static MY_FORCE_INLINE bool AreColliding(const TransformedAABB box, const TransformedPolygon& polygon) { return AreColliding(polygon, box); }
        static MY_FORCE_INLINE bool AreColliding(const TransformedCircle circle, const TransformedAABB box) { return AreColliding(box, circle); }
        static MY_FORCE_INLINE bool AreColliding(const TransformedAABB aabb, const Math::Line line) { return AreColliding(line, aabb); }
        static MY_FORCE_INLINE bool AreColliding(const TransformedCircle circle, const Math::Line line) { return AreColliding(line, circle); }
        static MY_FORCE_INLINE bool AreColliding(const TransformedPolygon& polygon, const Math::Line line) { return AreColliding(line, polygon); }

        template<typename TransformedType>
        static MY_FORCE_INLINE bool AreColliding(const ShapeType typeA, const void* transformedShapeA, const TransformedType& transformedShapeB)
        {
            switch (typeA)
            {
            case ShapeType::Circle:		return AreColliding(*static_cast<const TransformedCircle*>(transformedShapeA), transformedShapeB);
            case ShapeType::AABB:		return AreColliding(*static_cast<const TransformedAABB*>(transformedShapeA), transformedShapeB);
            case ShapeType::Polygon:	return AreColliding(*static_cast<const TransformedPolygon*>(transformedShapeA), transformedShapeB);
            }
            assert(false);
            return false;
        }

        template<typename TransformedType>
        static MY_FORCE_INLINE bool AreColliding(const TransformedType& transformedShapeA, const ShapeType typeB, const void* transformedShapeB)
        {
            return AreColliding(typeB, transformedShapeB, transformedShapeA);
        }

        static MY_FORCE_INLINE bool AreColliding(const ShapeType typeA, const void* transformedShapeA, const ShapeType typeB, const void* transformedShapeB)
        {
            switch (typeA)
            {
            case ShapeType::Circle:         return AreColliding(*static_cast<const TransformedCircle*>(transformedShapeA), typeB, transformedShapeB);
            case ShapeType::AABB:           return AreColliding(*static_cast<const TransformedAABB*>(transformedShapeA), typeB, transformedShapeB);
            case ShapeType::Polygon:        return AreColliding(*static_cast<const TransformedPolygon*>(transformedShapeA), typeB, transformedShapeB);
            }

            assert(false);
            return false;
        }
	};
}