AABox.h

Go to the documentation of this file.

// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <Jolt/Geometry/Triangle.h>
#include <Jolt/Geometry/IndexedTriangle.h>
#include <Jolt/Geometry/Plane.h>
#include <Jolt/Math/Mat44.h>
 
JPH_NAMESPACE_BEGIN
 
class [[nodiscard]] AABox
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
                    AABox()                                             : mMin(Vec3::sReplicate(FLT_MAX)), mMax(Vec3::sReplicate(-FLT_MAX)) { }
                    AABox(Vec3Arg inMin, Vec3Arg inMax)                 : mMin(inMin), mMax(inMax) { }
                    AABox(DVec3Arg inMin, DVec3Arg inMax)               : mMin(inMin.ToVec3RoundDown()), mMax(inMax.ToVec3RoundUp()) { }
                    AABox(Vec3Arg inCenter, float inRadius)             : mMin(inCenter - Vec3::sReplicate(inRadius)), mMax(inCenter + Vec3::sReplicate(inRadius)) { }
 
    static AABox    sFromTwoPoints(Vec3Arg inP1, Vec3Arg inP2)          { return AABox(Vec3::sMin(inP1, inP2), Vec3::sMax(inP1, inP2)); }
 
    static AABox    sFromTriangle(const VertexList &inVertices, const IndexedTriangle &inTriangle)
    {
        AABox box = sFromTwoPoints(Vec3(inVertices[inTriangle.mIdx[0]]), Vec3(inVertices[inTriangle.mIdx[1]]));
        box.Encapsulate(Vec3(inVertices[inTriangle.mIdx[2]]));
        return box;
    }
 
    static AABox    sBiggest()
    {
        return AABox(Vec3::sReplicate(-0.5f * FLT_MAX), Vec3::sReplicate(0.5f * FLT_MAX));
    }
 
    bool            operator == (const AABox &inRHS) const              { return mMin == inRHS.mMin && mMax == inRHS.mMax; }
    bool            operator != (const AABox &inRHS) const              { return mMin != inRHS.mMin || mMax != inRHS.mMax; }
 
    void            SetEmpty()
    {
        mMin = Vec3::sReplicate(FLT_MAX);
        mMax = Vec3::sReplicate(-FLT_MAX);
    }
 
    bool            IsValid() const
    {
        return mMin.GetX() <= mMax.GetX() && mMin.GetY() <= mMax.GetY() && mMin.GetZ() <= mMax.GetZ();
    }
 
    void            Encapsulate(Vec3Arg inPos)
    {
        mMin = Vec3::sMin(mMin, inPos);
        mMax = Vec3::sMax(mMax, inPos);
    }
 
    void            Encapsulate(const AABox &inRHS)
    {
        mMin = Vec3::sMin(mMin, inRHS.mMin);
        mMax = Vec3::sMax(mMax, inRHS.mMax);
    }
 
    void            Encapsulate(const Triangle &inRHS)
    {
        Vec3 v = Vec3::sLoadFloat3Unsafe(inRHS.mV[0]);
        Encapsulate(v);
        v = Vec3::sLoadFloat3Unsafe(inRHS.mV[1]);
        Encapsulate(v);
        v = Vec3::sLoadFloat3Unsafe(inRHS.mV[2]);
        Encapsulate(v);
    }
 
    void            Encapsulate(const VertexList &inVertices, const IndexedTriangle &inTriangle)
    {
        for (uint32 idx : inTriangle.mIdx)
            Encapsulate(Vec3(inVertices[idx]));
    }
 
    AABox           Intersect(const AABox &inOther) const
    {
        return AABox(Vec3::sMax(mMin, inOther.mMin), Vec3::sMin(mMax, inOther.mMax));
    }
 
    void            EnsureMinimalEdgeLength(float inMinEdgeLength)
    {
        Vec3 min_length = Vec3::sReplicate(inMinEdgeLength);
        mMax = Vec3::sSelect(mMax, mMin + min_length, Vec3::sLess(mMax - mMin, min_length));
    }
 
    void            ExpandBy(Vec3Arg inVector)
    {
        mMin -= inVector;
        mMax += inVector;
    }
 
    Vec3            GetCenter() const
    {
        return 0.5f * (mMin + mMax);
    }
 
    Vec3            GetExtent() const
    {
        return 0.5f * (mMax - mMin);
    }
 
    Vec3            GetSize() const
    {
        return mMax - mMin;
    }
 
    float           GetSurfaceArea() const
    {
        Vec3 extent = mMax - mMin;
        return 2.0f * (extent.GetX() * extent.GetY() + extent.GetX() * extent.GetZ() + extent.GetY() * extent.GetZ());
    }
 
    float           GetVolume() const
    {
        Vec3 extent = mMax - mMin;
        return extent.GetX() * extent.GetY() * extent.GetZ();
    }
 
    bool            Contains(const AABox &inOther) const
    {
        return UVec4::sAnd(Vec3::sLessOrEqual(mMin, inOther.mMin), Vec3::sGreaterOrEqual(mMax, inOther.mMax)).TestAllXYZTrue();
    }
 
    bool            Contains(Vec3Arg inOther) const
    {
        return UVec4::sAnd(Vec3::sLessOrEqual(mMin, inOther), Vec3::sGreaterOrEqual(mMax, inOther)).TestAllXYZTrue();
    }
 
    bool            Contains(DVec3Arg inOther) const
    {
        return Contains(Vec3(inOther));
    }
 
    bool            Overlaps(const AABox &inOther) const
    {
        return !UVec4::sOr(Vec3::sGreater(mMin, inOther.mMax), Vec3::sLess(mMax, inOther.mMin)).TestAnyXYZTrue();
    }
 
    bool            Overlaps(const Plane &inPlane) const
    {
        Vec3 normal = inPlane.GetNormal();
        float dist_normal = inPlane.SignedDistance(GetSupport(normal));
        float dist_min_normal = inPlane.SignedDistance(GetSupport(-normal));
        return dist_normal * dist_min_normal <= 0.0f; // If both support points are on the same side of the plane we don't overlap
    }
 
    void            Translate(Vec3Arg inTranslation)
    {
        mMin += inTranslation;
        mMax += inTranslation;
    }
 
    void            Translate(DVec3Arg inTranslation)
    {
        mMin = (DVec3(mMin) + inTranslation).ToVec3RoundDown();
        mMax = (DVec3(mMax) + inTranslation).ToVec3RoundUp();
    }
 
    AABox           Transformed(Mat44Arg inMatrix) const
    {
        // Start with the translation of the matrix
        Vec3 new_min, new_max;
        new_min = new_max = inMatrix.GetTranslation();
 
        // Now find the extreme points by considering the product of the min and max with each column of inMatrix
        for (int c = 0; c < 3; ++c)
        {
            Vec3 col = inMatrix.GetColumn3(c);
 
            Vec3 a = col * mMin[c];
            Vec3 b = col * mMax[c];
 
            new_min += Vec3::sMin(a, b);
            new_max += Vec3::sMax(a, b);
        }
 
        // Return the new bounding box
        return AABox(new_min, new_max);
    }
 
    AABox           Transformed(DMat44Arg inMatrix) const
    {
        AABox transformed = Transformed(inMatrix.GetRotation());
        transformed.Translate(inMatrix.GetTranslation());
        return transformed;
    }
 
    AABox           Scaled(Vec3Arg inScale) const
    {
        return AABox::sFromTwoPoints(mMin * inScale, mMax * inScale);
    }
 
    Vec3            GetSupport(Vec3Arg inDirection) const
    {
        return Vec3::sSelect(mMax, mMin, Vec3::sLess(inDirection, Vec3::sZero()));
    }
 
    template <class VERTEX_ARRAY>
    void            GetSupportingFace(Vec3Arg inDirection, VERTEX_ARRAY &outVertices) const
    {
        outVertices.resize(4);
 
        int axis = inDirection.Abs().GetHighestComponentIndex();
        if (inDirection[axis] < 0.0f)
        {
            switch (axis)
            {
            case 0:
                outVertices[0] = Vec3(mMax.GetX(), mMin.GetY(), mMin.GetZ());
                outVertices[1] = Vec3(mMax.GetX(), mMax.GetY(), mMin.GetZ());
                outVertices[2] = Vec3(mMax.GetX(), mMax.GetY(), mMax.GetZ());
                outVertices[3] = Vec3(mMax.GetX(), mMin.GetY(), mMax.GetZ());
                break;
 
            case 1:
                outVertices[0] = Vec3(mMin.GetX(), mMax.GetY(), mMin.GetZ());
                outVertices[1] = Vec3(mMin.GetX(), mMax.GetY(), mMax.GetZ());
                outVertices[2] = Vec3(mMax.GetX(), mMax.GetY(), mMax.GetZ());
                outVertices[3] = Vec3(mMax.GetX(), mMax.GetY(), mMin.GetZ());
                break;
 
            case 2:
                outVertices[0] = Vec3(mMin.GetX(), mMin.GetY(), mMax.GetZ());
                outVertices[1] = Vec3(mMax.GetX(), mMin.GetY(), mMax.GetZ());
                outVertices[2] = Vec3(mMax.GetX(), mMax.GetY(), mMax.GetZ());
                outVertices[3] = Vec3(mMin.GetX(), mMax.GetY(), mMax.GetZ());
                break;
            }
        }
        else
        {
            switch (axis)
            {
            case 0:
                outVertices[0] = Vec3(mMin.GetX(), mMin.GetY(), mMin.GetZ());
                outVertices[1] = Vec3(mMin.GetX(), mMin.GetY(), mMax.GetZ());
                outVertices[2] = Vec3(mMin.GetX(), mMax.GetY(), mMax.GetZ());
                outVertices[3] = Vec3(mMin.GetX(), mMax.GetY(), mMin.GetZ());
                break;
 
            case 1:
                outVertices[0] = Vec3(mMin.GetX(), mMin.GetY(), mMin.GetZ());
                outVertices[1] = Vec3(mMax.GetX(), mMin.GetY(), mMin.GetZ());
                outVertices[2] = Vec3(mMax.GetX(), mMin.GetY(), mMax.GetZ());
                outVertices[3] = Vec3(mMin.GetX(), mMin.GetY(), mMax.GetZ());
                break;
 
            case 2:
                outVertices[0] = Vec3(mMin.GetX(), mMin.GetY(), mMin.GetZ());
                outVertices[1] = Vec3(mMin.GetX(), mMax.GetY(), mMin.GetZ());
                outVertices[2] = Vec3(mMax.GetX(), mMax.GetY(), mMin.GetZ());
                outVertices[3] = Vec3(mMax.GetX(), mMin.GetY(), mMin.GetZ());
                break;
            }
        }
    }
 
    Vec3            GetClosestPoint(Vec3Arg inPoint) const
    {
        return Vec3::sMin(Vec3::sMax(inPoint, mMin), mMax);
    }
 
    inline float    GetSqDistanceTo(Vec3Arg inPoint) const
    {
        return (GetClosestPoint(inPoint) - inPoint).LengthSq();
    }
 
    Vec3            mMin;
    Vec3            mMax;
};
 
JPH_NAMESPACE_END