IceBoundingSphere.h

Go to the documentation of this file.

// Include Guard
#ifndef __ICEBOUNDINGSPHERE_H__
#define __ICEBOUNDINGSPHERE_H__

        enum BSphereMethod
        {
                BS_NONE,
                BS_GEMS,
                BS_MINIBALL,

                BS_FORCE_DWORD  = 0x7fffffff
        };

        class ICEMATHS_API Sphere
        {
                public:
                inline_                                 Sphere()                                                                                                                                                {}
                inline_                                 Sphere(const Point& center, float radius) : mCenter(center), mRadius(radius)    {}
                                                                Sphere(udword nb_verts, const Point* verts);
                inline_                                 Sphere(const Sphere& sphere) : mCenter(sphere.mCenter), mRadius(sphere.mRadius) {}
                inline_                                 ~Sphere()                                                                                                                                               {}

                                BSphereMethod   Compute(udword nb_verts, const Point* verts);
                                bool                    FastCompute(udword nb_verts, const Point* verts);

                // Access methods
                inline_ const Point&    GetCenter()                                             const           { return mCenter; }
                inline_ float                   GetRadius()                                             const           { return mRadius; }

                inline_ const Point&    Center()                                                const           { return mCenter; }
                inline_ float                   Radius()                                                const           { return mRadius; }

                inline_ Sphere&                 Set(const Point& center, float radius)          { mCenter = center; mRadius = radius; return *this; }
                inline_ Sphere&                 SetCenter(const Point& center)                          { mCenter = center; return *this; }
                inline_ Sphere&                 SetRadius(float radius)                                         { mRadius = radius; return *this; }


                inline_ bool                    Contains(const Point& p)                const
                                                                {
                                                                        return mCenter.SquareDistance(p) <= mRadius*mRadius;
                                                                }


                inline_ bool                    Contains(const Sphere& 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.SquareDistance(sphere.mCenter) <= r*r;
                                                                }


                inline_ BOOL                    Contains(const AABB& aabb)      const
                                                                {
                                                                        // I assume if all 8 box vertices are inside the sphere, so does the whole box.
                                                                        // Sounds ok but maybe there's a better way?
                                                                        float R2 = mRadius * mRadius;
#ifdef USE_MIN_MAX
                                                                        const Point& Max = ((ShadowAABB&)&aabb).mMax;
                                                                        const Point& Min = ((ShadowAABB&)&aabb).mMin;
#else
                                                                        Point Max; aabb.GetMax(Max);
                                                                        Point Min; aabb.GetMin(Min);
#endif
                                                                        Point p;
                                                                        p.x=Max.x; p.y=Max.y; p.z=Max.z;        if(mCenter.SquareDistance(p)>=R2)       return FALSE;
                                                                        p.x=Min.x;                                                      if(mCenter.SquareDistance(p)>=R2)       return FALSE;
                                                                        p.x=Max.x; p.y=Min.y;                           if(mCenter.SquareDistance(p)>=R2)       return FALSE;
                                                                        p.x=Min.x;                                                      if(mCenter.SquareDistance(p)>=R2)       return FALSE;
                                                                        p.x=Max.x; p.y=Max.y; p.z=Min.z;        if(mCenter.SquareDistance(p)>=R2)       return FALSE;
                                                                        p.x=Min.x;                                                      if(mCenter.SquareDistance(p)>=R2)       return FALSE;
                                                                        p.x=Max.x; p.y=Min.y;                           if(mCenter.SquareDistance(p)>=R2)       return FALSE;
                                                                        p.x=Min.x;                                                      if(mCenter.SquareDistance(p)>=R2)       return FALSE;

                                                                        return TRUE;
                                                                }


                inline_ bool                    Intersect(const Sphere& sphere) const
                                                                {
                                                                        float r = mRadius + sphere.mRadius;
                                                                        return mCenter.SquareDistance(sphere.mCenter) <= r*r;
                                                                }


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

#endif // __ICEBOUNDINGSPHERE_H__