ParaAxisAlignedBox.h

#pragma once
#include "ParaVector3.h"
#include "ParaMatrix4.h"

namespace ParaEngine {

    class AxisAlignedBox
    {
    public:
        enum Extent
        {
            EXTENT_NULL,
            EXTENT_FINITE,
            EXTENT_INFINITE
        };
    protected:

        Vector3 mMinimum;
        Vector3 mMaximum;
        Extent mExtent;
        mutable Vector3* mpCorners;

    public:
        /*
        1-----2
        /|    /|
        / |   / |
        5-----4  |
        |  0--|--3
        | /   | /
        |/    |/
        6-----7
        */
        typedef enum {
            FAR_LEFT_BOTTOM = 0,
            FAR_LEFT_TOP = 1,
            FAR_RIGHT_TOP = 2,
            FAR_RIGHT_BOTTOM = 3,
            NEAR_RIGHT_BOTTOM = 7,
            NEAR_LEFT_BOTTOM = 6,
            NEAR_LEFT_TOP = 5,
            NEAR_RIGHT_TOP = 4
        } CornerEnum;
        inline AxisAlignedBox() : mpCorners(0)
        {
            // Default to a null box 
            setMinimum( -0.5, -0.5, -0.5 );
            setMaximum( 0.5, 0.5, 0.5 );
            mExtent = EXTENT_NULL;
        }
        inline AxisAlignedBox(Extent e) : mpCorners(0)
        {
            setMinimum( -0.5, -0.5, -0.5 );
            setMaximum( 0.5, 0.5, 0.5 );
            mExtent = e;
        }

        inline AxisAlignedBox(const AxisAlignedBox & rkBox) : mpCorners(0)
        {
            if (rkBox.isNull())
                setNull();
            else if (rkBox.isInfinite())
                setInfinite();
            else
                setExtents( rkBox.mMinimum, rkBox.mMaximum );
        }

        inline AxisAlignedBox( const Vector3& min, const Vector3& max ) : mpCorners(0)
        {
            setExtents( min, max );
        }

        inline AxisAlignedBox(
            float mx, float my, float mz,
            float Mx, float My, float Mz ) : mpCorners(0)
        {
            setExtents( mx, my, mz, Mx, My, Mz );
        }

        AxisAlignedBox& operator=(const AxisAlignedBox& rhs)
        {
            // Specifically override to avoid copying mpCorners
            if (rhs.isNull())
                setNull();
            else if (rhs.isInfinite())
                setInfinite();
            else
                setExtents(rhs.mMinimum, rhs.mMaximum);

            return *this;
        }

        ~AxisAlignedBox()
        {
            if (mpCorners)
                delete [](mpCorners);
        }


        inline const Vector3& getMinimum(void) const
        { 
            return mMinimum; 
        }

        inline Vector3& getMinimum(void)
        { 
            return mMinimum; 
        }

        inline const Vector3& getMaximum(void) const
        { 
            return mMaximum;
        }

        inline Vector3& getMaximum(void)
        { 
            return mMaximum;
        }


        inline void setMinimum( const Vector3& vec )
        {
            mExtent = EXTENT_FINITE;
            mMinimum = vec;
        }

        inline void setMinimum( float x, float y, float z )
        {
            mExtent = EXTENT_FINITE;
            mMinimum.x = x;
            mMinimum.y = y;
            mMinimum.z = z;
        }

        void setMinimumX(float x);

        void setMinimumY(float y);

        void setMinimumZ(float z);

        inline void setMaximum( const Vector3& vec )
        {
            mExtent = EXTENT_FINITE;
            mMaximum = vec;
        }

        inline void setMaximum( float x, float y, float z )
        {
            mExtent = EXTENT_FINITE;
            mMaximum.x = x;
            mMaximum.y = y;
            mMaximum.z = z;
        }

        void setMaximumX( float x );

        void setMaximumY( float y );

        void setMaximumZ( float z );

        void setExtents( const Vector3& min, const Vector3& max );

        void setExtents(
            float mx, float my, float mz,
            float Mx, float My, float Mz );

        const Vector3* getAllCorners(void) const;

        Vector3 getCorner(CornerEnum cornerToGet) const;

        friend std::ostream& operator<<( std::ostream& o, const AxisAlignedBox aab )
        {
            switch (aab.mExtent)
            {
            case EXTENT_NULL:
                o << "AxisAlignedBox(null)";
                return o;

            case EXTENT_FINITE:
                o << "AxisAlignedBox(min=" << aab.mMinimum << ", max=" << aab.mMaximum << ")";
                return o;

            case EXTENT_INFINITE:
                o << "AxisAlignedBox(infinite)";
                return o;

            default: // shut up compiler
                PE_ASSERT( false && "Never reached" );
                return o;
            }
        }

        void merge( const AxisAlignedBox& rhs );

        void merge( const Vector3& point );

        void transform( const Matrix4& matrix );

        void transformAffine(const Matrix4& m);

        void setNull();

        bool isNull(void) const;

        bool isFinite(void) const;

        void setInfinite();

        bool isInfinite(void) const;

        bool intersects(const AxisAlignedBox& b2) const;

        AxisAlignedBox intersection(const AxisAlignedBox& b2) const;

        float volume(void) const;

        void scale(const Vector3& s);

        bool intersects(const Sphere& s) const;
        bool intersects(const Plane& p) const;
        bool intersects(const Vector3& v) const;
        Vector3 getCenter(void) const;
        Vector3 getSize(void) const;
        Vector3 getHalfSize(void) const;

        bool contains(const Vector3& v) const;

        bool contains(const AxisAlignedBox& other) const;

        bool operator== (const AxisAlignedBox& rhs) const;

        bool operator!= (const AxisAlignedBox& rhs) const;

        // special values
        static const AxisAlignedBox BOX_NULL;
        static const AxisAlignedBox BOX_INFINITE;


    };

} // namespace ParaEngine