cPoint3.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cPoint3_H
#define _INC_cPoint3_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cPoint2.h"
#include "cRectI.h"
 
namespace GrayLib
{
        template <typename TYPE = float>
        class GRAYLIB_LINK cPoint3T : public cVecT3<TYPE>
        {
 
                typedef cVecT3<TYPE> SUPER_t;
                typedef cPoint3T<TYPE> THIS_t;
 
        public:
                cPoint3T()
                {
                        // ASSUME TYPE = float ?
                        this->SetZero();
                }
#if 1
                cPoint3T(const SUPER_t& ptVal)
                : cVecT3<TYPE>(ptVal)
                {
                }
#endif
                cPoint3T(TYPE x, TYPE y, TYPE z = 0)
                : cVecT3<TYPE>(x, y, z)
                {
                }
                cPoint3T(const cVariant& vVal, int iArrayIndexStart = 0)
                {
                        v_SetPoint(vVal, iArrayIndexStart);
                }
 
                // validate the point
                void InitInvalid()
                {
                        this->m_x = this->m_y = this->m_z = k_FLT_MAX2;
                }
                bool IsValid2d() const
                {
                        return this->m_x != k_FLT_MAX2 && this->m_y != k_FLT_MAX2;
                }
                bool IsValid() const
                {
                        return this->m_x != k_FLT_MAX2 && this->m_y != k_FLT_MAX2 && this->m_z != k_FLT_MAX2;
                }
 
                // compare the point.
 
                void Set(POINT pt)
                {
                        this->m_x = (TYPE)pt.x;
                        this->m_y = (TYPE)pt.y;
                        this->m_z = 0;  // NOTE: remember this is a nonsense value.
                }
                void Set(POINTS pt)
                {
                        this->m_x = (TYPE)pt.x;
                        this->m_y = (TYPE)pt.y;
                        this->m_z = 0;  // NOTE: remember this is a nonsense value.
                }
                POINT get_POINT() const
                {
                        // int point.
                        POINT pt;
                        pt.x = (LONG)this->m_x;
                        pt.y = (LONG)this->m_y;
                        return pt;
                }
                operator POINT() const
                {
                        return get_POINT();
                }
                POINTS get_POINTS() const
                {
                        POINTS pt;
                        pt.x = (short)this->m_x;
                        pt.y = (short)this->m_y;
                        return pt;
                }
                operator POINTS() const
                {
                        return get_POINTS();
                }
 
                cVecT2<TYPE> get_Point2() const
                {
                        return cVecT2<TYPE>(this->m_x, this->m_y);
                }
 
                void MoveDir(DIR_TYPE eDir)
                {
                        ASSERT(IS_INDEX_GOOD(eDir, DIR_QTY + 1));
                        this->m_x += cDirectionDef::k_Directions[eDir].m_dx;
                        this->m_y += cDirectionDef::k_Directions[eDir].m_dy;
                }
                void MoveDirN(DIR_TYPE eDir, float nSteps)
                {
                        ASSERT(IS_INDEX_GOOD(eDir, DIR_QTY + 1));
                        this->m_x += cDirectionDef::k_Directions[eDir].m_dx * nSteps;
                        this->m_y += cDirectionDef::k_Directions[eDir].m_dy * nSteps;
                }
 
                TYPE GetDirZ(const SUPER_t& pt) const
                {
                        TYPE dx = pt.m_x - this->m_x;
                        TYPE dy = pt.m_y - this->m_y;
                        return Calc::ATan2(dx, dy);
                }
                cVecT2<TYPE>& get_Point2f()
                {
                        // Downcast to 2d point. reinterpret_cast
                        return (cVecT2<TYPE>&)(this->m_x);
                }
 
                ITERATE_t v_SetPoint(const cVariant& vVal, ITERATE_t iArrayIndexStart = 0);     // set this from a variant, x,y,z
                ITERATE_t v_AddPoint(OUT cVariant& vVal) const; // get this as a variant
 
                cString get_StringI3() const;
                bool put_MapCoord(cString sVal);
 
                HASHCODE_t get_HashCode2() const
                {
                        // If the point is the index for a Hash Table (2D).
                        return((((HASHCODE_t)this->m_y) << 16) | ((HASHCODE_t)this->m_x));
                }
        };
 
        typedef cPoint3T<float> cPoint3f;
        typedef cPoint3T<double> cPoint3d;
 
}
#endif