cSegment3.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cSegment3_H
#define _INC_cSegment3_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../Math/cVector.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cSegment3);
        class cVariant;
 
        class GRAYLIB_LINK cSegment3f
        {
 
        public:
                typedef float DVALUE_t; 
                cVector3f m_vMin;               
                cVector3f m_vMax;
 
        public:
                cSegment3f() noexcept
                {
                }
 
                cSegment3f(const cVector3f& v1, const cVector3f& v2) noexcept
                        : m_vMin(v1), m_vMax(v2)
                {}
 
                // Get operators.
                cVector3f get_Center() const noexcept
                {
                        return cVector3f((m_vMin.x + m_vMax.x) / 2, (m_vMin.y + m_vMax.y) / 2, (m_vMin.z + m_vMax.z) / 2);
                }
                DVALUE_t get_Width() const noexcept
                {
                        return m_vMax.x - m_vMin.x;
                }
                DVALUE_t get_Height() const noexcept
                {
                        return m_vMax.y - m_vMin.y;
                }
                DVALUE_t get_HeightMax() const noexcept
                {
                        return m_vMax.y;
                }
                DVALUE_t get_Depth() const noexcept
                {
                        return m_vMax.z - m_vMin.z;
                }
                cVector3f get_Delta() const noexcept
                {
                        return cVector3f(m_vMax.x - m_vMin.x, m_vMax.y - m_vMin.y, m_vMax.z - m_vMin.z);
                }
                enum AXIS_TYPE get_LargestAxis() const noexcept
                {
                        const cVector3f s = get_Delta();
                        if ((s.x >= s.y) && (s.x >= s.z))
                                return AXIS_TYPE::AXIS_X;
                        if ((s.y >= s.x) && (s.y >= s.z))
                                return AXIS_TYPE::AXIS_Y;
                        return AXIS_TYPE::AXIS_Z;
                }
                DVALUE_t get_MaxDelta() const noexcept
                {
                        const cVector3f v = get_Delta();
                        return Calc::Max3(v.x, v.y, v.z);
                }
 
                DVALUE_t get_Diameter() const
                {
                        return get_Delta().get_Magnitude();
                }
                DVALUE_t get_Radius() const
                {
                        return get_Diameter() / 2.0f;
                }
 
                DVALUE_t GetDistanceTo(const cVector3f& v) const
                {
                        // Get the shortest distance from a point to line.
                        // the length of the line segment that is perpendicular to the line and passes through the point.
                        // https://en.wikipedia.org/wiki/Distance_from_a_point_to_a_line
                        // https://brilliant.org/wiki/dot-product-distance-between-point-and-a-line/
                        // https://codereview.stackexchange.com/questions/143424/c-code-to-find-distance-between-line-and-point
                        // AKA Dot Product ??
 
                        const cVector3f AB = get_Delta();
                        const cVector3f AC = v - m_vMin;
                        const DVALUE_t norm = AB.get_Magnitude();
                        const DVALUE_t area = ((AB.m_x * AC.m_y) - (AB.m_y * AC.m_x));  // (int)
                        return Calc::Abs(area / norm);
                }
 
                bool operator == (const cSegment3f& line) const
                {
                        return(line.m_vMin == m_vMin && line.m_vMax == m_vMax);
                }
                inline operator const DVALUE_t* () const noexcept
                {
                        return &m_vMin.m_a[0];
                }
                inline operator DVALUE_t* () noexcept
                {
                        return &m_vMin.m_a[0];
                }
 
                // Init operators.
                void SetMin() noexcept
                {
                        m_vMin = cVector3f(k_FLT_MAX2, k_FLT_MAX2, k_FLT_MAX2);
                        m_vMax = cVector3f(-k_FLT_MAX2, -k_FLT_MAX2, -k_FLT_MAX2);
                }
                void SetMax() noexcept
                {
                        m_vMin = cVector3f(-k_FLT_MAX2, -k_FLT_MAX2, -k_FLT_MAX2);
                        m_vMax = cVector3f(k_FLT_MAX2, k_FLT_MAX2, k_FLT_MAX2);
                }
                void SetOne() noexcept
                {
                        m_vMin = cVector3f(-0.5f, -0.5f, -0.5f);
                        m_vMax = cVector3f(0.5f, 0.5f, 0.5f);
                }
                void SetZero() noexcept
                {
                        cMem::Zero(&m_vMin, sizeof(m_vMin) * 2);
                }
                void SetRay(const cVector3f& vOrigin, const cVector3f& vDir, DVALUE_t fDist)
                {
                        m_vMin = vOrigin;
                        m_vMax = vDir;
                        m_vMax.put_Magnitude(fDist);
                        m_vMax += vOrigin;
                }
 
 
                void Scale(DVALUE_t fScale)
                {
                        ASSERT(fScale > 0);
                        m_vMin *= fScale;
                        m_vMax *= fScale;
                }
                void ScaleVect(const cVector3f& vScale)
                {
                        // ASSERT( scale > 0 );
                        m_vMin *= vScale;
                        m_vMax *= vScale;
                }
                void ScaleY(DVALUE_t fScaleY)
                {
                        ASSERT(fScaleY > 0);
                        m_vMin.y *= fScaleY;
                        m_vMax.y *= fScaleY;
                }
 
                void Offset(const cVector3f& vOffset)
                {
                        m_vMin += vOffset;
                        m_vMax += vOffset;
                }
                void Grow(const cVector3f& vOffset)
                {
                        m_vMin -= vOffset;
                        m_vMax += vOffset;
                }
                void GrowN(DVALUE_t nValue)
                {
                        m_vMin -= nValue;
                        m_vMax += nValue;
                }
 
                // Serialize.
 
                ITERATE_t v_SetLine(const cVariant& vArgs, ITERATE_t i = 0);
                void v_GetLine(cVariant& vArgs) const;
 
                // ITERATE_t v_SetLineRev( const cVariant& vArgs, ITERATE_t i=0 );
                // void v_GetLineRev( cVariant& vArgs ) const;
 
                UNITTEST_FRIEND(cSegment3);
        };
}
#endif