ShapeAABB.h

#pragma once


namespace ParaEngine
{
    class CShapeBox;
    class CShapeSphere;
    class CShapeOBB;

    class CShapeAABB
    {
    public:
        CShapeAABB() : mCenter(0.f, 0.f, 0.f), mExtents(-1e33f, -1e33f, -1e33f){};
        CShapeAABB(const CShapeBox& box);
        CShapeAABB(const Vector3& center, const Vector3& extents);
        CShapeAABB(const CShapeAABB* boxes, int nSize);
        CShapeAABB( const Vector3* points, int nSize);
        ~CShapeAABB(void);
        
        void        SetMinMax(const Vector3& min, const Vector3& max)       { mCenter = (max + min)*0.5f; mExtents = (max - min)*0.5f;      }

        void        SetCenterExtents(const Vector3& c, const Vector3& e)    { mCenter = c;   mExtents = e;                                  }

        void        SetEmpty();

        void    SetInvalid();

        void        SetPointAABB(const Vector3& pt)                         { mCenter = pt; mExtents=Vector3(0,0,0);}

        float       GetSize()                               const;


        Vector3 Point(int i) const { return Vector3( (i&1)?(mCenter.x-mExtents.x):(mCenter.x+mExtents.x), (i&2)?(mCenter.y-mExtents.y):(mCenter.y+mExtents.y), (i&4)?(mCenter.z-mExtents.z):(mCenter.z+mExtents.z));  }

        void        Extend(const Vector3& p);

        void Extend(const CShapeOBB& p);

        void ExtendByPointList( const Vector3* points, int nSize);

        void ExtendByAABBList( const CShapeAABB* boxes, int nSize );

        // Data access

        void        GetMin(Vector3& min)                        const       { min = mCenter - mExtents;                 }
        void        GetMax(Vector3& max)                        const       { max = mCenter + mExtents;                 }

        Vector3 GetMin()                        const       { return  mCenter - mExtents;                   }
        Vector3 GetMax()                        const       { return mCenter + mExtents;                    }

        float       GetMin(DWORD axis)                      const       { return mCenter[axis] - mExtents[axis];    }
        float       GetMax(DWORD axis)                      const       { return mCenter[axis] + mExtents[axis];    }

        void        GetCenter(Vector3& center)              const       { center = mCenter;                         }
        void        GetExtents(Vector3& extents)                const       { extents = mExtents;                       }

        void        SetCenter(const Vector3& center)                { mCenter = center ;                            }
        void        SetExtents(const Vector3& extents)              { mExtents = extents;                       }

        float       GetCenter(DWORD axis)                   const       { return mCenter[axis];                     }
        inline Vector3&     GetCenter()                 { return mCenter;                       }
        float       GetExtents(DWORD axis)                  const       { return mExtents[axis];                    }
        inline Vector3&     GetExtents()                    { return mExtents;                      }

        void        GetDiagonal(Vector3& diagonal)          const       { diagonal = mExtents * 2.0f;               }
        float       GetWidth()                              const       { return mExtents.x * 2.0f;                 }
        float       GetHeight()                             const       { return mExtents.y * 2.0f;                 }
        float       GetDepth()                              const       { return mExtents.z * 2.0f;                 }

        float  GetRadius();

        void SetWidth(float fWidth);
        void SetHeight(float fHeight);
        void SetDepth(float fDepth);

        float       GetVolume()                             const       { return mExtents.x * mExtents.y * mExtents.z * 8.0f;   }

        BOOL        Intersect(const CShapeAABB& a)              const;

        bool        GomezIntersect(const CShapeAABB& a);

        BOOL        Intersect(const CShapeAABB& a, DWORD axis)  const;

        bool Intersect(float* hitDist, const Vector3* origPt, const Vector3* dir, int* pHitSide = NULL);

        bool IntersectOutside(float* hitDist, const Vector3* origPt, const Vector3* dir, int* pHitSide = NULL);

        void        Rotate(const Matrix4& mtx, CShapeAABB& aabb)    const;

        BOOL        IsValid()   const;

        CShapeAABB&     operator*=(float s)     { mExtents*=s;  return *this;   }

        CShapeAABB&     operator/=(float s)     { mExtents/=s;  return *this;   }

        CShapeAABB&     operator+=(const Vector3& trans)
        {
            mCenter+=trans;
            return *this;
        }
    private:
        
        Vector3     mCenter;            
        Vector3     mExtents;           

    };

    class CShapeBox
    {
    public:
        Vector3 m_Max;
        Vector3 m_Min;

        CShapeBox(): m_Min(1e33f, 1e33f, 1e33f), m_Max(-1e33f, -1e33f, -1e33f) { }
        CShapeBox( const CShapeBox& other ): m_Min(other.m_Min), m_Max(other.m_Max) { }
        CShapeBox( const Vector3& vMin, const Vector3& vMax): m_Min(vMin), m_Max(vMax) { }
        CShapeBox(const CShapeBox* boxes, int nSize);
        CShapeBox( const Vector3* points, int nSize);
        CShapeBox(const CShapeAABB& other);
        inline const Vector3& GetMin()  const                   { return  m_Min;                    }
        inline const Vector3& GetMax()  const                   { return  m_Max;                    }

        inline void     SetMinMax(const Vector3& min, const Vector3& max)       { m_Min = min; m_Max = max;}

        void        SetCenterExtents(const Vector3& c, const Vector3& e);

        void        SetEmpty();
        bool        IsValid();

        void        SetPointBox(const Vector3& pt)                          { m_Min = m_Max = pt;}

        float       GetWidth()                              const       { return m_Max.x - m_Min.x; }
        float       GetHeight()                             const       { return m_Max.y - m_Min.y; }
        float       GetDepth()                              const       { return m_Max.z - m_Min.z; }

        inline void GetCenter( Vector3* vec) const { *vec = 0.5f*(m_Min+m_Max); }

        inline Vector3 GetCenter() const { return 0.5f*(m_Min+m_Max); }
        inline Vector3 GetExtent() const { return 0.5f*(m_Max-m_Min); }

        void Translate(const Vector3& offset);

        void Extend( const Vector3& vec );

        void Extend( const Vector3* points, int nSize);

        void Extend( const CShapeBox* boxes, int nSize );

        void Extend(const CShapeOBB& p);

        bool Intersect( float* hitDist, const Vector3* origPt, const Vector3* dir ) const;

        bool Intersect(const CShapeSphere& sphere) const;

        float DistanceToPoint(const Vector3& p, Vector3* where) const; 

        Vector3 Point(int i) const { return Vector3( (i&1)?m_Min.x:m_Max.x, (i&2)?m_Min.y:m_Max.y, (i&4)?m_Min.z:m_Max.z );  }

    };

}