src/math/aabb.cpp

#include "rive/math/aabb.hpp"
#include <cmath>

using namespace rive;

AABB::AABB() : buffer{0} {}

AABB::AABB(const AABB& copy) {
    buffer[0] = copy.buffer[0];
    buffer[1] = copy.buffer[1];
    buffer[2] = copy.buffer[2];
    buffer[3] = copy.buffer[3];
}

AABB::AABB(float minX, float minY, float maxX, float maxY) :
    buffer{minX, minY, maxX, maxY} {}

void AABB::center(Vec2D& out, const AABB& a) {
    out[0] = (a[0] + a[2]) * 0.5f;
    out[1] = (a[1] + a[3]) * 0.5f;
}

void AABB::size(Vec2D& out, const AABB& a) {
    out[0] = a[2] - a[0];
    out[1] = a[3] - a[1];
}

void AABB::extents(Vec2D& out, const AABB& a) {
    out[0] = (a[2] - a[0]) * 0.5;
    out[1] = (a[3] - a[1]) * 0.5;
}

void AABB::combine(AABB& out, const AABB& a, const AABB& b) {}

bool AABB::contains(const AABB& a, const AABB& b) {
    return a[0] <= b[0] && a[1] <= b[1] && b[2] <= a[2] && b[3] <= a[3];
}

bool AABB::isValid(const AABB& a) {
    float dx = a[2] - a[0];
    float dy = a[3] - a[1];
    return dx >= 0.0f && dy >= 0.0f && std::isfinite(a[0]) &&
           std::isfinite(a[1]) && std::isfinite(a[2]) && std::isfinite(a[3]);
}

bool AABB::testOverlap(const AABB& a, const AABB& b) {
    float d1x = b[0] - a[2];
    float d1y = b[1] - a[3];

    float d2x = a[0] - b[2];
    float d2y = a[1] - b[3];

    if (d1x > 0.0 || d1y > 0.0) {
        return false;
    }

    if (d2x > 0.0 || d2y > 0.0) {
        return false;
    }

    return true;
}

bool AABB::areIdentical(const AABB& a, const AABB& b) {
    return a[0] == b[0] && a[1] == b[1] && a[2] == b[2] && a[3] == b[3];
}

float AABB::width() const { return buffer[2] - buffer[0]; }

float AABB::height() const { return buffer[3] - buffer[1]; }

float AABB::perimeter() const {
    float wx = buffer[2] - buffer[0];
    float wy = buffer[3] - buffer[1];
    return 2.0 * (wx + wy);
}

void AABB::transform(AABB& out, const AABB& a, const Mat2D& matrix) {
    const auto p1 = matrix * Vec2D(a[0], a[1]);
    const auto p2 = matrix * Vec2D(a[2], a[1]);
    const auto p3 = matrix * Vec2D(a[2], a[3]);
    const auto p4 = matrix * Vec2D(a[0], a[3]);

    out[0] = std::fmin(p1[0], std::fmin(p2[0], std::fmin(p3[0], p4[0])));
    out[1] = std::fmin(p1[1], std::fmin(p2[1], std::fmin(p3[1], p4[1])));
    out[2] = std::fmax(p1[0], std::fmax(p2[0], std::fmax(p3[0], p4[0])));
    out[3] = std::fmax(p1[1], std::fmax(p2[1], std::fmax(p3[1], p4[1])));
}