| #include "rive/math/aabb.hpp" |
| #include <cmath> |
| |
| using namespace rive; |
| |
| 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; |
| } |
| |
| 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]))); |
| } |
| |
| static inline float graphics_roundf(float x) { |
| return std::floor(x + 0.5f); |
| } |
| |
| static inline int graphics_round(float x) { |
| return (int)graphics_roundf(x); |
| } |
| |
| IAABB AABB::round() const { |
| return { |
| graphics_round(left()), |
| graphics_round(top()), |
| graphics_round(right()), |
| graphics_round(bottom()), |
| }; |
| } |
| |