ShapeSphere.h

#pragma once

namespace ParaEngine
{
    class CShapeAABB;
    class CShapeSphere
    {
    public:
        inline                  CShapeSphere()                                                                      {}
        inline                  CShapeSphere(const Vector3& center, float radius) : mCenter(center), mRadius(radius)    {}
        CShapeSphere(int nb_verts, const Vector3* verts);
        inline                  CShapeSphere(const CShapeSphere& sphere) : mCenter(sphere.mCenter), mRadius(sphere.mRadius) {}
        inline                  ~CShapeSphere()                                                                     {}

        void    Compute(int nb_verts, const Vector3* verts);
        
        // Access methods
        inline  const Vector3&  GetCenter()                     const       { return mCenter; }
        inline  float           GetRadius()                     const       { return mRadius; }

        inline  const Vector3&  Center()                        const       { return mCenter; }
        inline  float           Radius()                        const       { return mRadius; }

        inline  CShapeSphere&           Set(const Vector3& center, float radius)        { mCenter = center; mRadius = radius; return *this; }
        inline  CShapeSphere&           SetCenter(const Vector3& center)                { mCenter = center; return *this; }
        inline  CShapeSphere&           SetRadius(float radius)                     { mRadius = radius; return *this; }


        inline  bool            Contains(const Vector3& p)      const
        {
            return (mCenter-p).squaredLength() <= mRadius*mRadius;
        }


        inline  bool            Contains(const CShapeSphere& sphere)    const
        {
            // If our radius is the smallest, we can't possibly contain the other sphere
            if(mRadius < sphere.mRadius)    return false;
            // So r is always positive or null now
            float r = mRadius - sphere.mRadius;
            return (mCenter-sphere.mCenter).squaredLength() <= r*r;
        }


        BOOL            Contains(const CShapeAABB& aabb)    const;


        inline  bool            Intersect(const CShapeSphere& sphere)   const
        {
            float r = mRadius + sphere.mRadius;
            return (mCenter-sphere.mCenter).squaredLength() <= r*r;
        }


        inline  BOOL            IsValid()   const
        {
            // Consistency condition for spheres: Radius >= 0.0f
            if(mRadius < 0.0f)  return FALSE;
            return TRUE;
        }
    public:
        Vector3     mCenter;        
        float           mRadius;        
    };

}