BoundsSphere.hpp

#pragma once
#ifndef __H__OCULAR_MATH_BOUNDS_SPHERE__H__
#define __H__OCULAR_MATH_BOUNDS_SPHERE__H__

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

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

#include <list>
#include <vector>

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

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

        class BoundsSphere : public Bounds
        {
        public:

            BoundsSphere(std::list<Point3f> const& points, Math::Matrix4x4 const& matrix = Math::Matrix4x4());
            BoundsSphere(std::vector<Graphics::Vertex> const& vertices, Math::Matrix4x4 const& matrix = Math::Matrix4x4());
            BoundsSphere(Vector3f const& center, float radius);
            BoundsSphere();
            ~BoundsSphere();

            void construct(std::list<Vector3f> 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 setRadius(float radius);

            Vector3f const& getCenter() const;
            
            float getRadius() const;

            void expand(float const amount);

            void expandToContain(Vector3f const& point);

            void expandToContain(BoundsSphere const& other);

            //------------------------------------------------------------------------------
            // Intersection and Containment Testing
            //------------------------------------------------------------------------------
            
            bool intersects(Ray const& ray) const;

            bool intersects(Ray const& ray, Vector3f& 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(BoundsSphere const& sphere, IntersectionType* result = nullptr) const;

        protected:

        private:

            Vector3f m_Center;
            float m_Radius;

        };
    }
}
//------------------------------------------------------------------------------------------

#endif