cOctreeNode.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cOctreeNode_H
#define _INC_cOctreeNode_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cOctree.h"
#include "cOctreeObject.h"
#include "GrayLib/include/Math/cFloatEst.h"
#include "GrayLib/include/Math/cVecT.h"
#include "GrayLib/include/Misc/cPool.h" // IPoolNode
#include "GrayCore/include/CList.h"
 
namespace Gray3D
{
        class GRAY3D_LINK cOctreeNode
                : public IPoolNode
                , public cListT<cOctreeObject>
                , public cOctreeNodeCont
        {
 
                friend class cOctree;
                friend class cOctreeObject;
                friend class cOctreeNodeCont;
                friend class cOctreeNodePool;
                typedef cListT<cOctreeObject> LIST_t;   
 
        protected:
                int m_iLevel;                                           
                cVec3i m_vTreePos;                                      
                cOctree* m_pTree;                                       
                cOctreeNode* m_pParentNode;                     
 
        protected:
                static constexpr bool IsInsideNode(int v) noexcept
                {
                        return v >= 0 && v < 6;
                }
                constexpr bool IsInsideNode(const cVec3i& vPi) const noexcept
                {
                        return IsInsideNode(vPi.m_x - (m_vTreePos.m_x << 2) + 1)
                                && IsInsideNode(vPi.m_y - (m_vTreePos.m_y << 2) + 1)
                                && IsInsideNode(vPi.m_z - (m_vTreePos.m_z << 2) + 1);
                }
 
                void onDetachSpatialObject(cOctreeObject* pObj);
 
                HRESULT DisposeThis();
                void FreeThisNode()
                {
                        if (m_pParentNode != nullptr)
                        {
                                // i am a regular node.
                                CHILDIDX_t nChildIdx = get_ChildIdx();
                                ASSERT(m_pParentNode->m_aChildNodes[nChildIdx] == this);
                                m_pParentNode->FreeChildNode(nChildIdx);
                        }
                        else
                        {
                                // i am a root node.
                                CHILDIDX_t nRootIdx = get_RootIdx();
                                if (m_pTree->m_aChildNodes[nRootIdx] == nullptr)        // a transient root node.
                                {
                                        DisposeThis();
                                }
                                else
                                {
                                        ASSERT(m_pTree->m_aChildNodes[nRootIdx] == this);
                                        m_pTree->FreeChildNode(nRootIdx);
                                }
                        }
                }
 
                bool CollapseLeafCheck()
                {
                        if (m_nChildNodes || !LIST_t::isEmpty())
                                return false;
                        FreeThisNode();
                        return true; // was deleted
                }
 
                bool CollapseLeafAndTrimRootCheck();
 
        public:
                cOctreeNode();
                virtual ~cOctreeNode();
 
                float get_StepF() const noexcept
                {
                        return cFloatEst::pow2(m_iLevel);
                }
 
                static inline CHILDIDX_t MakeChildIdx(const cVec3i& vPi)
                {
                        return (vPi.m_x & 1) + ((vPi.m_y & 1) << 1) + ((vPi.m_z & 1) << 2);
                }
 
                CHILDIDX_t get_RootIdx() const
                {
                        ASSERT(m_pParentNode == nullptr);
                        return cOctree::MakeRootIdx(m_vTreePos);
                }
 
                CHILDIDX_t get_ChildIdx() const
                {
                        return MakeChildIdx(m_vTreePos);
                }
 
                cBounds3f get_BoundBox() const
                {
                        cBounds3f bounds;
                        bounds.m_vMin.x = bounds.m_vMax.x = (float)m_vTreePos.m_x;
                        bounds.m_vMin.y = bounds.m_vMax.y = (float)m_vTreePos.m_y;
                        bounds.m_vMin.z = bounds.m_vMax.z = (float)m_vTreePos.m_z;
 
                        static const cVector3f k_vMio(-0.5f, -0.5f, -0.5f);
                        bounds.m_vMin += k_vMio;
                        static const cVector3f k_vMao(1.5f, 1.5f, 1.5f);
                        bounds.m_vMax += k_vMao;
 
                        float fStepSize = get_StepF();
                        bounds.m_vMin *= fStepSize;
                        bounds.m_vMax *= fStepSize;
                        return bounds;
                }
 
                cSpheref get_BoundSphere() const
                {
                        float fStepSize = get_StepF();
 
                        // 1.73205080756887729 = square root of 3
                        cSpheref bsphere(0.5f + (float)m_vTreePos.m_x, 0.5f + (float)m_vTreePos.m_y, 0.5f + (float)m_vTreePos.m_z,
                                1.73205080756887729f * fStepSize);      // node bsphere fRadius
 
                        bsphere.m_vCenter *= fStepSize;
                        return bsphere;
                }
 
                GINTERSECT_TYPE GetIntersectTestNode(const cSpheref& rSphere) const
                {
                        cSpheref bsphereThis = get_BoundSphere();
                        return bsphereThis.GetIntersectSphere(rSphere);
                }
 
                // cOctreeNodeCont::ISpatialTest tests for objects in the node.
                virtual bool TraverseIntersectSphere(ISpatialTestVisitor* tif, const cSpheref& frustum) const override;
                virtual bool TraverseIntersectBounds(ISpatialTestVisitor* tif, const cBounds3f& bbox) const override;
                virtual bool TraverseIntersectHex(ISpatialTestVisitor* tif, const cHexahedron& frustum, cHexahedron::PLANES_MASK_t planes); // override??
                virtual bool TraverseIntersectSegment(ISpatialTestVisitor* tif, const cSegment3f& segment) override;
                virtual bool TraverseAll(ISpatialTestVisitor* tif) const override;
 
                int TestTree(const cOctree* pTree, CHILDIDX_t rootIdx) const; // validates tree structure
                bool isPoolNodeValid(UINT_PTR uCheckParent = 0) const;
        };
};
 
#endif // _INC_cOctreeNode_H