cOctree.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cOctree_H
#define _INC_cOctree_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cOctreeObject.h"
#include "cSpatialTest.h"
 
namespace Gray3D
{
        UNITTEST2_PREDEF(cOctree);
        class cOctreeNode;
        DECLARE_INTERFACE(ISpatialTestVisitor);
 
#ifdef _DEBUG
#define USE_OCTREE_DBG_ALLOC
#endif
 
        typedef cVecT3<INT32> cVec3i;   // must be 32 bit int.
 
        class GRAY3D_LINK cOctreeNodeCont : public ISpatialTest
        {
 
        public:
                typedef int CHILDIDX_t;         
                static const CHILDIDX_t k_NodeMax = 8;          
 
        protected:
                cOctreeNode* m_aChildNodes[k_NodeMax];          
                CHILDIDX_t m_nChildNodes;                                       
 
        protected:
                mutable int m_iSpatialTestVal;                          
 
        protected:
 
                bool TraverseIntersectHex(ISpatialTestVisitor* pResults, const cHexahedron& frustum, cHexahedron::PLANES_MASK_t planes);
 
                // Implement ISpatialTest for searching the Octree.
                virtual bool TraverseIntersectSphere(ISpatialTestVisitor* pResults, const cSpheref& sphere) const override;
                virtual bool TraverseIntersectBounds(ISpatialTestVisitor* pResults, const cBounds3f& bbox) const override;
                virtual bool TraverseIntersectHex(ISpatialTestVisitor* pResults, const cHexahedron& frustum)   override;
                virtual bool TraverseIntersectSegment(ISpatialTestVisitor* pResults, const cSegment3f& segment) override;
                virtual bool TraverseAll(ISpatialTestVisitor* pResults) const override;
 
        public:
                cOctreeNodeCont() noexcept
                        : m_nChildNodes(0)
                        , m_iSpatialTestVal(0)
                {
                        cMem::Zero(m_aChildNodes, sizeof(m_aChildNodes));
                }
                virtual ~cOctreeNodeCont()
                {
                }
 
                void FreeChildNode(CHILDIDX_t ci);
                void FreeChildNodes();
 
                UNITTEST_FRIEND(cOctree);       
        };
 
        class GRAY3D_LINK cOctree : public cOctreeNodeCont
        {
 
                friend class cOctreeNode;
 
        private:
                static INT32 _FloatUnpack(float fVal, int iBase) noexcept;
 
                cOctreeNode* AllocNode();
                void FreeNode(cOctreeNode* pNode);
                static cVec3i MakeNodePoint(const cVector3f& vPos, int iLevel) noexcept;
 
        public:
                cOctree();
                virtual ~cOctree();
 
                static inline CHILDIDX_t MakeRootIdx(const cVec3i& vPi) noexcept
                {
                        return ((vPi.m_x >> 31) & 1) + ((vPi.m_y >> (31 - 1)) & 2) + ((vPi.m_z >> (31 - 2)) & 4);
                }
 
                void AddToOctree(cOctreeObject* pObj, const cVector3f& vPos, float fRadius);
 
                int TestTree() const;           
 
 
#if 0
                STDMETHOD_(ULONG, AddRef)(void)  override
                {
                        return 1;
                }
                STDMETHOD_(ULONG, Release)(void)  override
                {
                        return 1;
                }
                STDMETHOD(QueryInterface)( /* [in] */ const IID& riid, /* [iid_is][out] */ void __RPC_FAR* __RPC_FAR* ppvObject)  override
                {
                        return E_FAIL;
                }
#endif
 
        };
} 
#endif // _INC_cOctree_H