OgreTerrainQuadTreeNode.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-2014 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_TerrainQuadTreeNode_H__
#define __Ogre_TerrainQuadTreeNode_H__

#include "OgreTerrainPrerequisites.h"
#include "OgreCommon.h"
#include "OgreHardwareIndexBuffer.h"
#include "OgreMovableObject.h"
#include "OgreRenderable.h"



namespace Ogre
{
    class HardwareVertexBufferSharedPtr;
    
    class _OgreTerrainExport TerrainQuadTreeNode : public TerrainAlloc
    {
    public:
        TerrainQuadTreeNode(Terrain* terrain, TerrainQuadTreeNode* parent, 
            uint16 xoff, uint16 yoff, uint16 size, uint16 lod, uint16 depth, uint16 quadrant);
        virtual ~TerrainQuadTreeNode();

        uint16 getXOffset() const { return mOffsetX; }
        uint16 getYOffset() const { return mOffsetY; }
        bool isLeaf() const;
        uint16 getBaseLod() const { return mBaseLod; }
        uint16 getLodCount() const;
        TerrainQuadTreeNode* getChild(unsigned short child) const;
        TerrainQuadTreeNode* getParent() const;
        Terrain* getTerrain() const;

        void prepare();
        void prepare(StreamSerialiser& stream);
        void load();
        void load(uint16 depthStart, uint16 depthEnd);
        void loadSelf();
        void unload();
        void unload(uint16 depthStart, uint16 depthEnd);
        void unprepare();
        void save(StreamSerialiser& stream);

        struct _OgreTerrainExport LodLevel : public TerrainAlloc
        {
            uint16 batchSize;
            IndexData* gpuIndexData;
            Real maxHeightDelta;
            Real calcMaxHeightDelta;
            Real lastTransitionDist;
            Real lastCFactor;

            LodLevel() : batchSize(0), gpuIndexData(0), maxHeightDelta(0), calcMaxHeightDelta(0),
                lastTransitionDist(0), lastCFactor(0) {}
        };
        typedef vector<LodLevel*>::type LodLevelList;

        const LodLevel* getLodLevel(uint16 lod);

        void preDeltaCalculation(const Rect& rect);

        void notifyDelta(uint16 x, uint16 y, uint16 lod, Real delta);

        void postDeltaCalculation(const Rect& rect);

        void finaliseDeltaValues(const Rect& rect);

        void assignVertexData(uint16 treeDepthStart, uint16 treeDepthEnd, uint16 resolution, uint sz);

        void useAncestorVertexData(TerrainQuadTreeNode* owner, uint16 treeDepthEnd, uint16 resolution);

        void updateVertexData(bool positions, bool deltas, const Rect& rect, bool cpuData);



        void mergeIntoBounds(long x, long y, const Vector3& pos);
        void resetBounds(const Rect& rect);
        
        bool rectIntersectsNode(const Rect& rect);
        bool rectContainsNode(const Rect& rect);
        bool pointIntersectsNode(long x, long y);

        const AxisAlignedBox& getAABB() const;
        Real getBoundingRadius() const;
        const Vector3& getLocalCentre() const { return mLocalCentre; }
        Real getMinHeight() const;
        Real getMaxHeight() const;

        bool calculateCurrentLod(const Camera* cam, Real cFactor);

        int getCurrentLod() const { return mCurrentLod; }
        bool isRenderedAtCurrentLod() const;
        bool isSelfOrChildRenderedAtCurrentLod() const;
        void setCurrentLod(int lod);
        float getLodTransition() const { return mLodTransition; }
        void setLodTransition(float t);

        static unsigned short POSITION_BUFFER;
        static unsigned short DELTA_BUFFER;

        Renderable *_getRenderable();
    protected:
        Terrain* mTerrain;
        TerrainQuadTreeNode* mParent;
        TerrainQuadTreeNode* mChildren[4];
        LodLevelList mLodLevels;

        uint16 mOffsetX, mOffsetY;
        uint16 mBoundaryX, mBoundaryY;
        uint16 mSize;
        uint16 mBaseLod;
        uint16 mDepth;
        uint16 mQuadrant;
        Vector3 mLocalCentre; 
        AxisAlignedBox mAABB; 
        Real mBoundingRadius; 
        int mCurrentLod; 
        unsigned short mMaterialLodIndex;
        float mLodTransition; 
        TerrainQuadTreeNode* mChildWithMaxHeightDelta;
        bool mSelfOrChildRendered;

        struct VertexDataRecord : public TerrainAlloc
        {
            VertexData* cpuVertexData;
            VertexData* gpuVertexData;
            uint16 resolution;
            uint16 size;
            uint16 treeLevels;
            uint16 numSkirtRowsCols;
            uint16 skirtRowColSkip;
            bool gpuVertexDataDirty;

            VertexDataRecord(uint16 res, uint16 sz, uint16 lvls) 
                : cpuVertexData(0), gpuVertexData(0), resolution(res), size(sz),
                treeLevels(lvls), numSkirtRowsCols(0),
                skirtRowColSkip(0), gpuVertexDataDirty(false) {}
        };
        
        TerrainQuadTreeNode* mNodeWithVertexData;
        VertexDataRecord* mVertexDataRecord;

        class _OgreTerrainExport Movable : public MovableObject
        {
        protected:
            TerrainQuadTreeNode* mParent;
        public:
            Movable(TerrainQuadTreeNode* parent);
            virtual ~Movable();
            
            // necessary overrides
            const String& getMovableType(void) const;
            const AxisAlignedBox& getBoundingBox(void) const;
            Real getBoundingRadius(void) const;
            void _updateRenderQueue(RenderQueue* queue);
            void visitRenderables(Renderable::Visitor* visitor,  bool debugRenderables = false);
            bool isVisible(void) const;
            uint32 getVisibilityFlags(void) const;
            uint32 getQueryFlags(void) const;
            bool getCastShadows(void) const;

        };
        Movable* mMovable;
        friend class Movable;
        SceneNode* mLocalNode;

        class _OgreTerrainExport Rend : public Renderable, public TerrainAlloc
        {
        protected:
            TerrainQuadTreeNode* mParent;
        public:
            Rend(TerrainQuadTreeNode* parent);
            virtual ~Rend();

            const MaterialPtr& getMaterial(void) const;
            Technique* getTechnique(void) const;
            void getRenderOperation(RenderOperation& op);
            void getWorldTransforms(Matrix4* xform) const;
            Real getSquaredViewDepth(const Camera* cam) const;
            const LightList& getLights(void) const;
            bool getCastsShadows(void) const;

        };
        Rend* mRend;
        friend class Rend;

        // actual implementation of MovableObject methods
        void updateRenderQueue(RenderQueue* queue);
        void visitRenderables(Renderable::Visitor* visitor,  bool debugRenderables = false);
        // actual implementations of Renderable methods
        const MaterialPtr& getMaterial(void) const;
        Technique* getTechnique(void) const;
        void getRenderOperation(RenderOperation& op);
        void getWorldTransforms(Matrix4* xform) const;
        Real getSquaredViewDepth(const Camera* cam) const;
        const LightList& getLights(void) const;
        bool getCastsShadows(void) const;


        const VertexDataRecord* getVertexDataRecord() const;
        void createCpuVertexData();
        /* Update the vertex buffers - the rect in question is relative to the whole terrain, 
            not the local vertex data (which may use a subset)
        */
        void updateVertexBuffer(HardwareVertexBufferSharedPtr& posbuf, HardwareVertexBufferSharedPtr& deltabuf, const Rect& rect);
        void destroyCpuVertexData();

        void createGpuVertexData();
        void destroyGpuVertexData();
        void updateGpuVertexData();
        void createGpuIndexData();
        void destroyGpuIndexData();

        void populateIndexData(uint16 batchSize, IndexData* destData);
        void writePosVertex(bool compress, uint16 x, uint16 y, float height, const Vector3& pos, float uvScale, float** ppPos);
        void writeDeltaVertex(bool compress, uint16 x, uint16 y, float delta, float deltaThresh, float** ppDelta);
        
        uint16 calcSkirtVertexIndex(uint16 mainIndex, bool isCol);

    };

}

#endif