OgreVolumeOctreeNode.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
(Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2013 Torus Knot Software Ltd

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
-----------------------------------------------------------------------------
*/
#ifndef __Ogre_Volume_OctreeNode_H__
#define __Ogre_Volume_OctreeNode_H__

#include "OgreMatrix3.h"
#include "OgreEntity.h"
#include "OgreSceneManager.h"
#include "OgreManualObject.h"
#include "OgreVolumeOctreeNodeSplitPolicy.h"
#include "OgreVolumePrerequisites.h"

namespace Ogre {
namespace Volume {

    class OctreeNodeSplitPolicy;

    class _OgreVolumeExport OctreeNode : public UtilityAlloc
    {
    protected:
        
        static const Real NEAR_FACTOR;

        static uint32 mGridPositionCount;

        static size_t mNodeI;

        Vector3 mFrom;
        
        Vector3 mTo;

        OctreeNode **mChildren;

        Entity* mOctreeGrid;

        Vector4 mCenterValue;

        void buildOctreeGridLines(ManualObject *manual) const;
    public:

        static const size_t OCTREE_CHILDREN_COUNT;
        
        static inline void getChildrenDimensions(const Vector3 &from, const Vector3 &to, Vector3 &center, Vector3 &width, Vector3 &height, Vector3 &depth)
        {
            center = (to - from) / (Real)2.0;
            width.x = center.x;
            width.y = (Real)0.0;
            width.z = (Real)0.0;
            height.x = (Real)0.0;
            height.y = center.y;
            height.z = (Real)0.0;
            depth.x = (Real)0.0;
            depth.y = (Real)0.0;
            depth.z = center.z;
            center += from;
        }

        OctreeNode(const Vector3 &from = Vector3::ZERO, const Vector3 &to = Vector3::ZERO);

        virtual ~OctreeNode(void);

        virtual OctreeNode* createInstance(const Vector3& from, const Vector3& to);

        void split(const OctreeNodeSplitPolicy *splitPolicy, const Source *src, const Real geometricError);

        Entity* getOctreeGrid(SceneManager *sceneManager);

        inline void setFrom(Vector3 from)
        {
            mFrom = from;
        }
        
        inline void setTo(Vector3 to)
        {
            mTo = to;
        }

        inline bool isSubdivided(void) const 
        {
            return mChildren != 0;
        }

        inline const OctreeNode* getChild(const size_t i) const
        {
            return mChildren[i];
        }
        
        inline const Vector3 getCenter(void) const
        {
            return (mFrom + mTo) / (Real)2.0;
        }
        
        inline const Vector3& getFrom(void) const
        {
            return mFrom;
        }
        
        inline const Vector3& getTo(void) const
        {
            return mTo;
        }

        inline bool isBorderLeft(const OctreeNode &root) const
        {
            return mFrom.x == root.mFrom.x;
        }
        
        inline bool isBorderRight(const OctreeNode &root) const
        {
            return mTo.x == root.mTo.x;
        }
        
        inline bool isBorderBottom(const OctreeNode &root) const
        {
            return mFrom.y == root.mFrom.y;
        }
        
        inline bool isBorderTop(const OctreeNode &root) const
        {
            return mTo.y == root.mTo.y;
        }
        
        inline bool isBorderBack(const OctreeNode &root) const
        {
            return mFrom.z == root.mFrom.z;
        }
        
        inline bool isBorderFront(const OctreeNode &root) const
        {
            return mTo.z == root.mTo.z;
        }

        inline const Vector3 getCenterBack(void) const
        {
            return Vector3(mFrom.x + (mTo.x - mFrom.x) / (Real)2.0, mFrom.y + (mTo.y - mFrom.y) / (Real)2.0, mFrom.z);
        }
        
        inline const Vector3 getCenterFront(void) const
        {
            return Vector3(mFrom.x + (mTo.x - mFrom.x) / (Real)2.0, mFrom.y + (mTo.y - mFrom.y) / (Real)2.0, mTo.z);
        }
        
        inline const Vector3 getCenterLeft(void) const
        {
            return Vector3(mFrom.x, mFrom.y + (mTo.y - mFrom.y) / (Real)2.0, mFrom.z + (mTo.z - mFrom.z) / (Real)2.0);
        }
        
        inline const Vector3 getCenterRight(void) const
        {
            return Vector3(mTo.x, mFrom.y + (mTo.y - mFrom.y) / (Real)2.0, mFrom.z + (mTo.z - mFrom.z) / (Real)2.0);
        }
        
        inline const Vector3 getCenterTop(void) const
        {
            return Vector3(mFrom.x + (mTo.x - mFrom.x) / (Real)2.0, mTo.y, mFrom.z + (mTo.z - mFrom.z) / (Real)2.0);
        }
        
        inline const Vector3 getCenterBottom(void) const
        {
            return Vector3(mFrom.x + (mTo.x - mFrom.x) / (Real)2.0, mFrom.y, mFrom.z + (mTo.z - mFrom.z) / (Real)2.0);
        }
        
        inline const Vector3 getCenterBackTop(void) const
        {
            return Vector3(mFrom.x + (mTo.x - mFrom.x) / (Real)2.0, mTo.y, mFrom.z);
        }
        
        inline const Vector3 getCenterBackBottom(void) const
        {
            return Vector3(mFrom.x + (mTo.x - mFrom.x) / (Real)2.0, mFrom.y, mFrom.z);
        }
        
        inline const Vector3 getCenterFrontTop(void) const
        {
            return Vector3(mFrom.x + (mTo.x - mFrom.x) / (Real)2.0, mTo.y, mTo.z);
        }
        
        inline const Vector3 getCenterFrontBottom(void) const
        {
            return Vector3(mFrom.x + (mTo.x - mFrom.x) / (Real)2.0, mFrom.y, mTo.z);
        }
        
        inline const Vector3 getCenterLeftTop(void) const
        {
            return Vector3(mFrom.x, mTo.y, mFrom.z + (mTo.z - mFrom.z) / (Real)2.0);
        }
        
        inline const Vector3 getCenterLeftBottom(void) const
        {
            return Vector3(mFrom.x, mFrom.y, mFrom.z + (mTo.z - mFrom.z) / (Real)2.0);
        }
        
        inline const Vector3 getCenterRightTop(void) const
        {
            return Vector3(mTo.x, mTo.y, mFrom.z + (mTo.z - mFrom.z) / (Real)2.0);
        }
        
        inline const Vector3 getCenterRightBottom(void) const
        {
            return Vector3(mTo.x, mFrom.y, mFrom.z + (mTo.z - mFrom.z) / (Real)2.0);
        }
        
        inline const Vector3 getCenterBackLeft(void) const
        {
            return Vector3(mFrom.x, mFrom.y + (mTo.y - mFrom.y) / (Real)2.0, mFrom.z);
        }

        inline const Vector3 getCenterFrontLeft(void) const
        {
            return Vector3(mFrom.x, mFrom.y + (mTo.y - mFrom.y) / (Real)2.0, mTo.z);
        }
        
        inline const Vector3 getCenterBackRight(void) const
        {
            return Vector3(mTo.x, mFrom.y + (mTo.y - mFrom.y) / (Real)2.0, mFrom.z);
        }

        inline const Vector3 getCenterFrontRight(void) const
        {
            return Vector3(mTo.x, mFrom.y + (mTo.y - mFrom.y) / (Real)2.0, mTo.z);
        }

        inline const Vector3 getCorner1(void) const
        {
            return Vector3(mTo.x, mFrom.y, mFrom.z);
        }
        
        inline const Vector3 getCorner2(void) const
        {
            return Vector3(mTo.x, mFrom.y, mTo.z);
        }
        
        inline const Vector3 getCorner3(void) const
        {
            return Vector3(mFrom.x, mFrom.y, mTo.z);
        }
        
        inline const Vector3 getCorner4(void) const
        {
            return Vector3(mFrom.x, mTo.y, mFrom.z);
        }
        
        inline const Vector3 getCorner5(void) const
        {
            return Vector3(mTo.x, mTo.y, mFrom.z);
        }
        
        inline const Vector3 getCorner7(void) const
        {
            return Vector3(mFrom.x, mTo.y, mTo.z);
        }

        inline void setCenterValue(Vector4 value)
        {
            mCenterValue = value;
        }

        inline const Vector4 getCenterValue(void) const
        {
            return mCenterValue;
        }

        inline bool isIsoSurfaceNear(void) const
        {
            if (mCenterValue.w == (Real)0.0)
            {
                return true;
            }
            return Math::Abs(mCenterValue.w) < (mFrom - mTo).length() * NEAR_FACTOR;
        }
    };
}
}

#endif