cSphere.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cSphere_H
#define _INC_cSphere_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cBounds3.h"
#include "GrayCore/include/IUnknown.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cSphere);
        class cVariant;
 
        class GRAYLIB_LINK DECLSPEC_UUID("{fc4dda18-7e6b-4a0d-9be3-34366ddb059c}") cSpheref
        {
 
        public:
                typedef float DVALUE_t;         //!< Dimension value type.
                cVector3f  m_vCenter;           //!< Sphere center
                DVALUE_t   m_fRadius;           //!< Sphere radius
 
        public:
 
                cSpheref(DVALUE_t fObjectRadius = 0) noexcept
                : m_fRadius(fObjectRadius)
                {
                }
                cSpheref(const cVector3f& vObjectCenter, DVALUE_t fObjectRadius) noexcept
                : m_vCenter(vObjectCenter)
                , m_fRadius(fObjectRadius)
                {}
                cSpheref(DVALUE_t x, DVALUE_t y, DVALUE_t z, DVALUE_t r = 0) noexcept
                : m_vCenter(x, y, z)
                , m_fRadius(r)
                {}
 
                // Testing
                DVALUE_t get_Radius() const
                {
                        return m_fRadius;
                }
                DVALUE_t get_RadiusSq() const
                {
                        return Calc::Sqr(m_fRadius);
                }
                const cVector3f& get_Center() const
                {
                        return m_vCenter;
                }
 
                bool isZero() const
                {
                        return(m_fRadius <= 0);
                }
                bool operator == (const cSpheref& sphere) const
                {
                        return(sphere.m_vCenter == m_vCenter && sphere.m_fRadius == m_fRadius);
                }
 
                bool IsInSphere(const cVector3f& v) const
                {
                        DVALUE_t fDistSq = m_vCenter.GetDistSq(v);
                        return(fDistSq <= get_RadiusSq());
                }
                bool IsInSphere(DVALUE_t _x, DVALUE_t _y, DVALUE_t _z) const
                {
                        return IsInSphere(cVector3f(_x, _y, _z));
                }
 
                bool IsInSphere(const cSpheref& s) const
                {
                        DVALUE_t fDistSq = m_vCenter.GetDistSq(s.m_vCenter);
                        return (fDistSq <= Calc::Sqr(m_fRadius - s.m_fRadius));
                }
 
                bool IsOverlapSphere(const cVector3f& vObjectCenter, DVALUE_t fObjectRadius) const
                {
                        DVALUE_t fDistSq = m_vCenter.GetDistSq(vObjectCenter);
                        return (fDistSq <= Calc::Sqr(m_fRadius + fObjectRadius));
                }
                bool IsOverlapSphere(const cSpheref& s) const
                {
                        return IsOverlapSphere(s.m_vCenter, s.m_fRadius);
                }
 
                GINTERSECT_TYPE GetIntersectSphere(const cSpheref& s) const
                {
                        DVALUE_t fDistSq = m_vCenter.GetDistSq(s.m_vCenter);
                        if (fDistSq >= Calc::Sqr(m_fRadius + s.m_fRadius))
                                return GINTERSECT_None;
                        DVALUE_t fRadiusDiff = m_fRadius - s.m_fRadius;
                        if (fDistSq <= Calc::Sqr(fRadiusDiff))
                        {
                                // one is inside the other.
                                if (fRadiusDiff < 0)            // s is larger.
                                        return GINTERSECT_In2;  // *this is inside s
                                return GINTERSECT_In1;  // s is inside *this.
                        }
                        return GINTERSECT_Partial; // partial overlap.
                }
 
                GINTERSECT_TYPE GetIntersectBounds(const cBounds3f& bbox) const;
                bool IsIntersectSegment(const cSegment3f& segment) const;
                bool TestRay(const cVector3f& vPickRayOrig, const cVector3f& vPickRayDir) const;
 
                // Init operators
                void SetSphere(const cVector3f &vObjectCenter, DVALUE_t fObjectRadius)
                {
                        m_vCenter = vObjectCenter;
                        m_fRadius = fObjectRadius;
                }
                void SetZero()
                {
                        m_vCenter.SetZero();
                        m_fRadius = 0;
                }
                void SetMax()
                {
                        m_vCenter.SetZero();
                        m_fRadius = k_FLT_MAX2;
                }
                void SetFromBoxO(const cBounds3f& box)
                {
                        m_vCenter = box.get_Center();
                        m_fRadius = box.get_Radius();
                }
                void SetFromBoxI(const cBounds3f& box)
                {
                        m_vCenter = box.get_Center();
                        m_fRadius = box.get_MaxDelta() / 2;
                }
 
                // Change operators.
 
                void put_Radius(DVALUE_t fObjectRadius)
                {
                        m_fRadius = fObjectRadius;
                }
                void ScaleCoords(DVALUE_t fScale)
                {
                        m_fRadius *= fScale;
                        m_vCenter *= fScale;
                }
 
                void Encapsulate(const cVector3f& v);
                void UnionSphere(const cSpheref& sphere);
 
 
                void OrthoTransform(const cMatrix4x4f& xform)
                {
                        cVector3f vAx(xform.m[0][0], xform.m[1][0], xform.m[2][0]); // transposed ??
                        DVALUE_t fScale = vAx.get_Magnitude();
                        m_fRadius *= fScale;
                        m_vCenter = m_vCenter.GetProj(xform);
                }
 
                void BoundsAffineTransform(const cMatrix4x4f& xform)
                {
                        cVector3f vAx(xform.m[0][0], xform.m[1][0], xform.m[2][0]); // transposed ??
                        cVector3f vAy(xform.m[0][1], xform.m[1][1], xform.m[2][1]);
                        cVector3f vAz(xform.m[0][2], xform.m[1][2], xform.m[2][2]);
 
                        DVALUE_t fLenX = vAx.get_MagnitudeSq();
                        DVALUE_t fLenY = vAy.get_MagnitudeSq();
                        DVALUE_t fLenZ = vAz.get_MagnitudeSq();
                        DVALUE_t fScale = Calc::Sqrt(Calc::Max3(fLenX, fLenY, fLenZ));
 
                        m_fRadius *= fScale;
                        m_vCenter = m_vCenter.GetProj(xform);
                }
 
                void ComputeBoundingSphere(const cVector3f* pVerts, UINT dwNumVertices, size_t dwStride);
 
                // Serialize
                ITERATE_t v_SetSphere(const cVariant& vArgs, ITERATE_t i = 0);
                void v_GetSphere(cVariant& vArgs) const;
 
                ITERATE_t v_SetSphereRev(const cVariant& vArgs, ITERATE_t i = 0);
                void v_GetSphereRev(cVariant& vArgs) const;
 
                UNITTEST_FRIEND(cSphere);
        };
 
        class GRAYLIB_LINK cSphere2 : public cSpheref
        {
 
                typedef cSpheref SUPER_t;
 
        protected:
                DVALUE_t m_fRadiusSq; //!< keep radius squared. for faster access.
        public:
                cSphere2()
                : cSpheref(cVector3f(0.0f, 0.0f, 0.0f), 0.0f)
                , m_fRadiusSq(0.0f)
                {}
 
                cSphere2(const cVector3f& vCenter, DVALUE_t fObjectRadius)
                : cSpheref(vCenter, fObjectRadius)
                , m_fRadiusSq(Calc::Sqr(fObjectRadius))
                {}
 
                void put_Radius(DVALUE_t fRadius)
                {
                        SUPER_t::put_Radius(fRadius);
                        m_fRadiusSq = Calc::Sqr(fRadius);
                }
                DVALUE_t get_RadiusSq() const
                {
                        return m_fRadiusSq;
                }
                void SetSphere(const cVector3f &vCenter, DVALUE_t fRadius)
                {
                        SUPER_t::SetSphere(vCenter, fRadius);
                        m_fRadiusSq = Calc::Sqr(fRadius);
                }
 
                GINTERSECT_TYPE GetRayIntersectionFrustum(const cVector3f &vRayOrigin,
                        const cVector3f &vRayDir,
                        cVector3f* pvIntersect, DVALUE_t fDistMaxSq) const;
 
                bool IsRayIntersectionInFront(const cVector3f& vRayOrigin,
                        const cVector3f &vRayDir,
                        cVector3f* pvIntersect) const;
 
                bool IsRayIntersectionDistSq(const cVector3f& vRayOrigin,
                        const cVector3f &vRayDir,
                        DVALUE_t fDistMaxSq,
                        OUT cVector3f* pvIntersect) const;
        };
 
        class GRAYLIB_LINK cSphereWork
        {
 
        private:
                int m_iPass;    //!< pass 1 or 2 on the data set.
 
                cVector3f m_xmin, m_xmax, m_ymin, m_ymax, m_zmin, m_zmax;       //!< used to compute box. after pass 1
                cSphere2 m_sphere;      //!< valid after pass 2
 
        public:
                cSphereWork();
                void InitWork();
 
                void AddVertex(const cVector3f& vTmp);
                void InitPass2();       // we are about to make pass2 on the data set
 
                void AddVertices1(const cVector3f* pVerts, UINT dwNumVertices, size_t dwStride);
                void AddVertices2(const cVector3f* pVerts, UINT dwNumVertices, size_t dwStride);
 
                // results
                cBounds3f get_Box() const
                {
                        cBounds3f bbox;
                        bbox.m_vMin.x = m_xmin.x;
                        bbox.m_vMin.y = m_ymin.y;
                        bbox.m_vMin.z = m_zmin.z;
                        bbox.m_vMax.x = m_xmax.x;
                        bbox.m_vMax.y = m_ymax.y;
                        bbox.m_vMax.z = m_zmax.z;
                        return bbox;
                }
                cSphere2 get_Sphere() const     // get a box from my first pass data.
                {
                        return m_sphere;
                }
        };
}
#endif // _INC_cSphere_H