AABB.cpp

Go to the documentation of this file.

#include "AABB.h"
#include <algorithm>
#include <iostream>
#include <memory>
 
#include <glm/gtx/matrix_decompose.hpp>
 
Physics::Bounding::AABB::AABB(const glm::vec3 &ctr, const glm::vec3 &halfExt)
    : center(ctr), halfExtents(halfExt), minCorner(ctr-halfExt), maxCorner(ctr+halfExt) {}
 
std::unique_ptr<Physics::Bounding::ICollider> Physics::Bounding::AABB::getTransformed(const glm::mat4 &modelMatrix) const {
    auto L = glm::mat3(modelMatrix);
    auto T = glm::vec3(modelMatrix[3]);
 
    glm::mat3 absL = glm::mat3(
        glm::abs(L[0]),
        glm::abs(L[1]),
        glm::abs(L[2])
    );
 
    glm::vec3 newHalfExtents = absL * halfExtents;
    glm::vec3 newCenter = L * center + T;
 
    return std::make_unique<AABB>(newCenter, newHalfExtents);
}
 
bool Physics::Bounding::AABB::intersectsAABB(const AABB &other) const {
    return (minCorner.x <= other.maxCorner.x && maxCorner.x >= other.minCorner.x) &&
           (minCorner.y <= other.maxCorner.y && maxCorner.y >= other.minCorner.y) &&
           (minCorner.z <= other.maxCorner.z && maxCorner.z >= other.minCorner.z);
}
 
// Tavian Barnes’ branchless slab method
std::optional<float> Physics::Bounding::AABB::intersectRay(const Math::Ray& ray) const {
    glm::vec3 invDir = 1.0f / ray.dir;
 
    glm::vec3 t0s = (minCorner - ray.origin) * invDir;
    glm::vec3 t1s = (maxCorner - ray.origin) * invDir;
 
    glm::vec3 tsmaller = glm::min(t0s, t1s);
    glm::vec3 tbigger  = glm::max(t0s, t1s);
 
    float tmin = std::max(std::max(tsmaller.x, tsmaller.y), tsmaller.z);
    float tmax = std::min(std::min(tbigger.x, tbigger.y), tbigger.z);
 
    bool hit = tmax >= std::max(tmin, 0.0f);
    return hit ? std::optional{ tmin } : std::nullopt;
}
 
bool Physics::Bounding::AABB::contains(const glm::vec3 &p) const {
    return (p.x >= minCorner.x && p.x <= maxCorner.x) &&
           (p.y >= minCorner.y && p.y <= maxCorner.y) &&
           (p.z >= minCorner.z && p.z <= maxCorner.z);
}
 
Physics::Bounding::ContactInfo Physics::Bounding::AABB::closestPoint(const glm::vec3 &p) const {
    //TODO
    return {p, glm::vec3(0.0f), 0.0f};
}
 
void Physics::Bounding::AABB::expand(const glm::vec3& point) {
    minCorner = glm::min(minCorner, point);
    maxCorner = glm::max(maxCorner, point);
    center = (minCorner + maxCorner) * 0.5f;
    halfExtents = (maxCorner - minCorner) * 0.5f;
}
 
void Physics::Bounding::AABB::expand(const AABB& other) {
    expand(other.getAABBMin());
    expand(other.getAABBMax());
}