BoundsAABB.hpp

#pragma once
#ifndef __H__OCULAR_MATH_BOUNDS_AABB__H__
#define __H__OCULAR_MATH_BOUNDS_AABB__H__

#include "Math/Bounds/Bounds.hpp"
#include "Graphics/Mesh/Vertex.hpp"

#include "Math/Matrix4x4.hpp"
#include "Math/Vector3.hpp"

#include <list>
#include <vector>

//------------------------------------------------------------------------------------------

namespace Ocular
{
    namespace Math
    {
        class Ray;
        class BoundsSphere;
        class BoundsOBB;
        class Plane;

        class BoundsAABB : public Bounds
        {
        public:

            BoundsAABB(std::list<Point3f> const& points, Math::Matrix4x4 const& matrix = Math::Matrix4x4());

            BoundsAABB(std::vector<Graphics::Vertex> const& vertices, Math::Matrix4x4 const& matrix = Math::Matrix4x4());

            BoundsAABB(Vector3f const& center, Vector3f const& extents);

            BoundsAABB();

            ~BoundsAABB();

            void construct(std::list<Point3f> const& points, Math::Matrix4x4 const& matrix = Math::Matrix4x4());

            void construct(std::vector<Graphics::Vertex> const& vertices, Math::Matrix4x4 const& matrix = Math::Matrix4x4());

            void setCenter(Vector3f const& center);

            void setExtents(Vector3f const& extents);

            Vector3f const& getCenter() const;

            Vector3f const& getExtents() const;

            Vector3f const& getMinPoint() const;

            Vector3f const& getMaxPoint() const;

            void expand(Vector3f const& modifier);

            void expandToContain(Vector3f const& point);

            void expandToContain(BoundsAABB const& bounds);

            //------------------------------------------------------------------------------
            // Intersection and Containment Testing
            //------------------------------------------------------------------------------
            
            bool intersects(Ray const& ray) const;
            
            bool intersects(Ray const& ray, Point3f& point, float& distance) const;
            
            bool intersects(BoundsSphere const& bounds) const;

            bool intersects(BoundsAABB const& bounds) const;
            
            bool intersects(BoundsOBB const& bounds) const;
            
            bool intersects(Plane const& plane, IntersectionType* result = nullptr) const;

            bool contains(Vector3f const& point, IntersectionType* result = nullptr) const;

            bool contains(BoundsAABB const& bounds, IntersectionType* result = nullptr) const;

        protected:

            void calculateMinMaxPoints();

        private:

            Vector3f m_Center;      
            Vector3f m_Extents;     
            Vector3f m_MinPoint;    
            Vector3f m_MaxPoint;
        };
    }
}
//------------------------------------------------------------------------------------------

#endif