OgreTerrainRenderable.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-2005 The OGRE Team
Also see acknowledgements in Readme.html

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt.
-----------------------------------------------------------------------------
*/
/***************************************************************************
terrainrenderable.h  -  description
-------------------
begin                : Sat Oct 5 2002
copyright            : (C) 2002 by Jon Anderson
email                : janders@users.sf.net

Enhancements 2003 - 2004 (C) The OGRE Team

***************************************************************************/

#ifndef TERRAINRENDERABLE_H
#define TERRAINRENDERABLE_H

#include "OgreTerrainPrerequisites.h"
#include <OgreRenderable.h>
#include <OgreMovableObject.h>
#include <OgreAxisAlignedBox.h>
#include <OgreString.h>
#include <OgreHardwareBufferManager.h>

#include <vector>

#define MORPH_CUSTOM_PARAM_ID 77

namespace Ogre
{

    typedef std::map <unsigned int, IndexData* > IndexMap;
    typedef std::vector < IndexData* > IndexArray;
    typedef std::vector < IndexMap* > LevelArray;

    class TerrainBufferCache
    {
    public:
        void shutdown(void)
        {
            for( size_t i=0; i<mCache.size(); i++ )
            {
                delete mCache[i];
            }
            mCache.clear();
        }
        ~TerrainBufferCache()
        {
            shutdown();
        }

        IndexArray mCache;
    };

    inline Real _max( Real x, Real y )
    {
        return ( x > y ) ? x : y;
    }

    class TerrainOptions
    {
    public:
        TerrainOptions()
        {
            pageSize = 0;
            tileSize = 0;
            tilesPerPage = 0;
            maxGeoMipMapLevel = 0;
            scale = Vector3::UNIT_SCALE;
            maxPixelError = 4;
            detailTile = 1;
            lit = false;
            coloured = false;
            lodMorph = false;
            lodMorphStart = 0.5;
            useTriStrips = false;
            primaryCamera = 0;
            terrainMaterial.setNull();
        };
        size_t pageSize;
        size_t tileSize; 
        size_t tilesPerPage;
        const Camera* primaryCamera;
        size_t maxGeoMipMapLevel;
        Vector3 scale;
        size_t maxPixelError;
        bool useTriStrips;
        size_t detailTile;
        bool lodMorph;
        Real lodMorphStart;
        bool lit;
        bool coloured;
        MaterialPtr terrainMaterial;

    };

#define STITCH_NORTH_SHIFT 0
#define STITCH_SOUTH_SHIFT 8
#define STITCH_WEST_SHIFT  16
#define STITCH_EAST_SHIFT  24

#define STITCH_NORTH  128 << STITCH_NORTH_SHIFT
#define STITCH_SOUTH  128 << STITCH_SOUTH_SHIFT
#define STITCH_WEST   128 << STITCH_WEST_SHIFT
#define STITCH_EAST   128 << STITCH_EAST_SHIFT

    class _OgreTerrainExport TerrainRenderable : public Renderable, public MovableObject
    {
    public:

        TerrainRenderable(const String& name);
        ~TerrainRenderable();

        void deleteGeometry();

        enum Neighbor
        {
            NORTH = 0,
            SOUTH = 1,
            EAST = 2,
            WEST = 3,
            HERE = 4
        };

        void initialise(int startx, int startz, Real* pageHeightData);

        //movable object methods
        virtual const String& getName( void ) const
        {
            return mName;
        };

        virtual const String& getMovableType( void ) const
        {
            return mType;
        };

        const AxisAlignedBox& getBoundingBox( void ) const
        {
            return mBounds;
        };

        virtual void _notifyCurrentCamera( Camera* cam );

        virtual void _updateRenderQueue( RenderQueue* queue );

        virtual void getRenderOperation( RenderOperation& rend );

        virtual const MaterialPtr& getMaterial( void ) const
        {
            return mMaterial;
        };

        virtual void getWorldTransforms( Matrix4* xform ) const;

        virtual const Quaternion& getWorldOrientation(void) const;
        virtual const Vector3& getWorldPosition(void) const;

        inline int getRenderLevel() const
        {
            return mRenderLevel;
        };

        inline void setForcedRenderLevel( int i )
        {
            mForcedRenderLevel = i;
        }

        void _getNormalAt( float x, float y, Vector3 * result );

        float getHeightAt( float x, float y );

        bool intersectSegment( const Vector3 & start, const Vector3 & end, Vector3 * result );

        void _setNeighbor( Neighbor n, TerrainRenderable *t )
        {
            mNeighbors[ n ] = t;
        };

        TerrainRenderable * _getNeighbor( Neighbor n )
        {
            return mNeighbors[ n ];
        }


        void setMaterial(const MaterialPtr& m )
        {
            mMaterial = m;
        };

        void _calculateNormals();




        void _generateVertexLighting( const Vector3 &sun, ColourValue ambient );


        Real getSquaredViewDepth(const Camera* cam) const;

        Real getBoundingRadius(void) const { return mBoundingRadius; }

        const LightList& getLights(void) const;

        void _updateCustomGpuParameter(
            const GpuProgramParameters::AutoConstantEntry& constantEntry,
            GpuProgramParameters* params) const;
        static TerrainBufferCache& _getIndexCache(void) {return msIndexCache;}
    protected:
        static TerrainBufferCache msIndexCache;
        static const TerrainOptions* msOptions;

        inline size_t _index( int x, int z ) const
        {
            return ( x + z * msOptions->tileSize );
        };

        inline float _vertex( int x, int z, int n )
        {
            return mPositionBuffer[x * 3 + z * msOptions->tileSize * 3 + n];
        };


        inline int _numNeighbors() const
        {
            int n = 0;

            for ( int i = 0; i < 4; i++ )
            {
                if ( mNeighbors[ i ] != 0 )
                    n++;
            }

            return n;
        }

        inline bool _hasNeighborRenderLevel( int i ) const
        {
            for ( int j = 0; j < 4; j++ )
            {
                if ( mNeighbors[ j ] != 0 && mNeighbors[ j ] ->mRenderLevel == i )
                    return true;
            }

            return false;

        }

        void _adjustRenderLevel( int i );

        void _initLevelIndexes();
        void _destroyLevelIndexes();

        bool _checkSize( int n );

        void _calculateMinLevelDist2( Real C );

        Real _calculateCFactor();

        VertexData* mTerrain;

        int mRenderLevel;
        int mLastNextLevel; 
        Real mLODMorphFactor;
        Real *mMinLevelDistSqr;
        TerrainRenderable *mNeighbors [ 4 ];
        mutable bool mLightListDirty;
        mutable LightList mLightList;
        Real mBoundingRadius;
        AxisAlignedBox mBounds;
        Vector3 mCenter;
        String mName;
        static String mType;
        MaterialPtr mMaterial;    
        bool mInit;
        static LevelArray mLevelIndex;
        static bool mLevelInit;
        HardwareVertexBufferSharedPtr mMainBuffer;
        HardwareVertexBufferSharedPtr* mDeltaBuffers;
        float* mPositionBuffer;
        int mForcedRenderLevel;
        int mNextLevelDown[10];
        IndexData* getIndexData(void);
        IndexData* generateTriStripIndexes(unsigned int stitchFlags);
        IndexData* generateTriListIndexes(unsigned int stitchFlags);
        int stitchEdge(Neighbor neighbor, int hiLOD, int loLOD, 
            bool omitFirstTri, bool omitLastTri, unsigned short** ppIdx);

        HardwareVertexBufferSharedPtr createDeltaBuffer(void);

    };

}

#endif

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Feb 12 12:59:53 2006