Math.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cmath>
#include <concepts>
#include <stdexcept>
 
/*
 * TODO:
 * * Check if it makes more sense to do triangle checks rather than raw rect checks. This might also be more
 *      generalisable?
 */
namespace stc::math {
 
template <typename T, typename IT>
concept VectorType2D = requires (const T& val) {
    { val.x } -> std::convertible_to<IT>;
    { val.y } -> std::convertible_to<IT>;
};
 
template <typename VT, typename IT>
concept VectorType3D = requires (const VT& val) {
    { val.x } -> std::convertible_to<IT>;
    { val.y } -> std::convertible_to<IT>;
    { val.z } -> std::convertible_to<IT>;
};
 
template <typename IT>
concept SignedNumber = requires {
    std::is_signed_v<IT>;
};
 
template <typename T>
inline T square(const T& val){
    return val * val;
}
 
namespace g2d {
 
template <typename IT, VectorType2D<IT> VT>
inline bool isCounterClockwise(const VT& a, const VT& b, const VT& c) {
    return (c.y - a.y) * (b.x - a.x) > (b.y - a.y) * (c.x - a.x);
}
 
template <SignedNumber IT, VectorType2D<IT> VT>
inline IT isPointOnLeftOfEdge(
    const VT& point,
    const VT& lineStart,
    const VT& lineEnd
) {
    // TODO: is this just the dot product? Can it be replaced with 
    //      0 <= dot(AB,AM) <= dot(AB,AB) && 0 <= dot(BC,BM) <= dot(BC,BC)
    // for any real-world benefit?
    return (lineEnd.x - lineStart.x) * (point.y - lineStart.y)
        - (point.x - lineStart.x) * (lineEnd.y - lineStart.y);
}
 
template <typename IT, VectorType2D<IT> VT>
    requires std::equality_comparable_with<VT, VT>
inline bool lineIntersectsLineInclusive(
    const VT& l1Start,
    const VT& l1End,
    const VT& l2Start,
    const VT& l2End
) {
    return (isCounterClockwise<IT, VT>(l1Start, l2Start, l2End) != isCounterClockwise<IT, VT>(l1End, l2Start, l2End)
        && isCounterClockwise<IT, VT>(l1Start, l1End, l2Start) != isCounterClockwise<IT, VT>(l1Start, l1End, l2End)
    )
        || isPointOnLeftOfEdge<IT, VT>(l1Start, l2Start, l2End) == 0
        || isPointOnLeftOfEdge<IT, VT>(l1End, l2Start, l2End) == 0;
}
 
template <typename IT, VectorType2D<IT> VT>
inline bool lineIntersectsRectangleInclusive(
    const VT& lineStart,
    const VT& lineEnd,
 
    const VT& rectCornerA,
    const VT& rectCornerB,
    const VT& rectCornerC,
    const VT& rectCornerD
) {
    return lineIntersectsLineInclusive<IT, VT>(
        lineStart, lineEnd,
        rectCornerA, rectCornerB
    ) || lineIntersectsLineInclusive<IT, VT>(
        lineStart, lineEnd,
        rectCornerB, rectCornerC
    ) || lineIntersectsLineInclusive<IT, VT>(
        lineStart, lineEnd,
        rectCornerC, rectCornerD
    ) || lineIntersectsLineInclusive<IT, VT>(
        lineStart, lineEnd,
        rectCornerD, rectCornerA
    );
}
 
template <SignedNumber IT, VectorType2D<IT> VT>
inline bool rectangleContainsPointExclusive(
    const VT& point,
 
    const VT& rectCornerA,
    const VT& rectCornerB,
    const VT& rectCornerC,
    const VT& rectCornerD
) {
    return
        isPointOnLeftOfEdge<IT, VT>(
            point, rectCornerA, rectCornerB
        ) > 0
        && isPointOnLeftOfEdge<IT, VT>(
            point, rectCornerB, rectCornerC
        ) > 0
        && isPointOnLeftOfEdge<IT, VT>(
            point, rectCornerC, rectCornerD
        ) > 0
        && isPointOnLeftOfEdge<IT, VT>(
            point, rectCornerD, rectCornerA
        ) > 0;
}
 
 
template <SignedNumber IT, VectorType2D<IT> VT>
inline bool rectangleContainsPointInclusive(
    const VT& point,
 
    const VT& rectCornerA,
    const VT& rectCornerB,
    const VT& rectCornerC,
    const VT& rectCornerD
) {
    return
        isPointOnLeftOfEdge<IT, VT>(
            point, rectCornerA, rectCornerB
        ) >= 0
        && isPointOnLeftOfEdge<IT, VT>(
            point, rectCornerB, rectCornerC
        ) >= 0
        && isPointOnLeftOfEdge<IT, VT>(
            point, rectCornerC, rectCornerD
        ) >= 0
        && isPointOnLeftOfEdge<IT, VT>(
            point, rectCornerD, rectCornerA
        ) >= 0;
}
 
 
template <typename IT, VectorType2D<IT> VT>
inline bool rectangleContainsPointInclusive(
    const VT& point,
 
    const VT& startPosition,
    const VT& endPosition
) {
    auto right = std::max(startPosition.x, endPosition.x);
    auto left = std::min(startPosition.x, endPosition.x);
    auto bottom = std::min(startPosition.y, endPosition.y);
    auto top = std::max(startPosition.y, endPosition.y);
 
    return left <= point.x && point.x <= right
        && bottom <= point.y && point.y <= top;
}
 
template <SignedNumber IT, VectorType2D<IT> VT>
inline bool lineIntersectsRectangleInclusive(
    const VT& lineStart,
    const VT& lineEnd,
 
    const VT& rectStart,
    const VT& rectEnd
) {
    auto right = std::max(rectStart.x, rectEnd.x);
    auto left = std::min(rectStart.x, rectEnd.x);
    auto bottom = std::min(rectStart.y, rectEnd.y);
    auto top = std::max(rectStart.y, rectEnd.y);
 
    if (lineStart.x == lineEnd.x) {
        // Vertical line
        if (lineStart.x > right || lineStart.x < left) {
            return false;
        } 
 
        auto minY = std::min(lineStart.y, lineEnd.y);
        auto maxY = std::max(lineStart.y, lineEnd.y);
 
        if (
            (minY > top && maxY > top)
            || (minY < bottom && maxY < bottom)
        ) {
            return false;
        }
        return true;
    } else if (lineStart.y == lineEnd.y) {
        // Horizontal line
        if (lineStart.y > top || lineStart.y < bottom) {
            return false;
        }
 
        auto minX = std::min(lineStart.x, lineEnd.x);
        auto maxX = std::max(lineStart.x, lineEnd.x);
 
        if (
            (minX > right && maxX > right)
            || (minX < left && maxX < left)
        ) {
            return false;
        }
        return true;
    } else {
        throw std::runtime_error("Diagonal lines are not yet implemented");
    }
}
 
template <SignedNumber IT, VectorType2D<IT> VT>
inline bool lineIntersectsRectangleExclusive(
    const VT& lineStart,
    const VT& lineEnd,
 
    const VT& rectStart,
    const VT& rectEnd
) {
    auto right = std::max(rectStart.x, rectEnd.x);
    auto left = std::min(rectStart.x, rectEnd.x);
    auto bottom = std::min(rectStart.y, rectEnd.y);
    auto top = std::max(rectStart.y, rectEnd.y);
 
    if (lineStart.x == lineEnd.x) {
        // Vertical line
        if (lineStart.x >= right || lineStart.x <= left) {
            return false;
        } 
 
        auto minY = std::min(lineStart.y, lineEnd.y);
        auto maxY = std::max(lineStart.y, lineEnd.y);
 
        if (
            (minY >= top && maxY >= top)
            || (minY <= bottom && maxY <= bottom)
        ) {
            return false;
        }
        return true;
    } else if (lineStart.y == lineEnd.y) {
        // Horizontal line
        if (lineStart.y >= top || lineStart.y <= bottom) {
            return false;
        }
 
        auto minX = std::min(lineStart.x, lineEnd.x);
        auto maxX = std::max(lineStart.x, lineEnd.x);
 
        if (
            (minX >= right && maxX >= right)
            || (minX <= left && maxX <= left)
        ) {
            return false;
        }
        return true;
    } else {
        throw std::runtime_error("Diagonal lines are not yet implemented");
    }
}
 
}
 
}