source: GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreBiTerrainSceneManager.h @ 2349

/*
-----------------------------------------------------------------------------
This source file is part of the GameTools Project
http://www.gametools.org

Author: Martin Szydlowski
-----------------------------------------------------------------------------
*/

#ifndef _BiTreeTerrainSceneManager_H__
#define _BiTreeTerrainSceneManager_H__

#include <OgreIteratorWrappers.h>

#include "OgreBiTerrainPrerequisites.h"
#include "OgreBiTerrainPageSource.h"
#include "OgreBiTerrainRenderable.h"

#include "OgreBiHierarchySceneManager.h"


namespace Ogre
{

typedef std::vector < BiTerrainPage * > BiTerrainPageRow;
typedef std::vector < BiTerrainPageRow > BiTerrainPage2D;

/** Default implementation of RaySceneQuery. */
// TODO: all scene queries in Bi-tree
class _OgreBiTerrainExport BiTerrainRaySceneQuery : public DefaultRaySceneQuery
{
protected:
        WorldFragment mWorldFrag;
public:
        BiTerrainRaySceneQuery(SceneManager* creator);
        ~BiTerrainRaySceneQuery();

        /** See RayScenQuery. */
        void execute(RaySceneQueryListener* listener);
};

class BiTerrainSceneManager : public BiHierarchySceneManager
{
public:
        BiTerrainSceneManager(const String& name, GtpVisibility::VisibilityManager *vm);
        ~BiTerrainSceneManager(void);

        virtual const String& getTypeName(void) const;

        /************************************************************************/
        /* Functions overriden from (BiTree)SceneManager                        */
        /************************************************************************/

        /** Loads the terrain using parameters int he given config file. */
        void setWorldGeometry( const String& filename );
        /** Loads the terrain using parameters in the given config file (contained 
        in a stream). */
        virtual void setWorldGeometry(DataStreamPtr& stream, 
                const String& typeName = StringUtil::BLANK);

        /** Sets the given option for the SceneManager.
        @remarks
        Options are (in addition to those supported by superclasses):
        "PageSize", int*;
        "TileSize", int*; 
        "PrimaryCamera, Camera*;
        "MaxMipMapLevel", int*;
        "Scale", Vector3 *;
        "MaxPixelError", int*;
        "UseTriStrips", bool*;
        "VertexProgramMorph", bool*;
        "DetailTile", int*;
        "LodMorphStart", Real*;
        "VertexNormals", bool*;
        "VertexColours", bool*;
        "MorphLODFactorParamName", String*;
        "MorphLODFactorParamIndex", size_t*;
        "CustomMaterialName", String*;
        "WorldTexture", String*;
        "DetailTexture", String*;
        */
        virtual bool setOption(const String& strKey, const void* pValue);


        // Overridden from Bitree scene mananger
        //void _findVisibleObjects(Camera *cam, bool onlyShadowCasters);
        // Overridden from Bitree scene manager
        void _renderScene(Camera *cam, Viewport *vp, bool includeOverlays);
        /** Overridden to user _renderVisibleObjects from BiTreeSceneManager */
        //virtual void _renderVisibleObjects( void );
        /** Overridden from SceneManager */
        void setWorldGeometryRenderQueue(uint8 qid);

        /** Overridden in order to store the first camera created as the primary
        one, for determining error metrics and the 'home' terrain page.
        */
        Camera* createCamera( const String &name );


        /** Creates a RaySceneQuery for this scene manager. */
        RaySceneQuery* 
                createRayQuery(const Ray& ray, unsigned long mask = 0xFFFFFFFF);

        /** Overide from scene manager to destroy Bitree properly (before the scene graph is destroyed)
        */
        virtual void clearScene();

        /************************************************************************/
        /* Functions for terrain rendering                                      */
        /************************************************************************/
        /** Returns the height at the given terrain coordinates. */
        float getHeightAt( float x, float y );

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

        /** Sets the texture to use for the main world texture. */
        void setWorldTexture(const String& textureName);
        /** Sets the texture to use for the detail texture. */
        void setDetailTexture(const String& textureName);
        /** Sets the number of times per tile the detail texture should be repeated. */
        void setDetailTextureRepeat(int repeat);
        /** Sets the dimensions of each tile (must be power of 2 + 1) */
        void setTileSize(int size); 
        /** Sets the dimensions of each page (must be power of 2 + 1) */
        void setPageSize(int size); 
        /** Sets the maximum screen space pixel error.  */
        void setMaxPixelError(int pixelError); 
        /** Sets how to scale the terrain data. */
        void setScale(const Vector3& scale);
        /** Sets the maximum geomipmap level to allow. */
        void setMaxGeoMipMapLevel(int maxMip);

        /** Gets the texture to use for the main world texture. */
        const String& getWorldTexture(void) { return mWorldTextureName; }
        /** Gets the texture to use for the detail texture. */
        const String& getDetailTexture(void) { return mDetailTextureName; }
        /** Gets the number of times per tile the detail texture should be repeated. */
        int getDetailTextureRepeat(void);
        /** Gets the dimensions of each tile (must be power of 2 + 1) */
        int getTileSize(void); 
        /** Gets the dimensions of each page (must be power of 2 + 1) */
        int getPageSize(void); 
        /** Gets the maximum screen space pixel error.  */
        int getMaxPixelError(void); 
        /** Gets how to scale the terrain data. */
        const Vector3& getScale(void);
        /** Gets the maximum geomipmap level to allow. */
        int getMaxGeoMipMapLevel(void);


        /** Sets whether the terrain should use triangle strips or not. */
        void setUseTriStrips(bool useStrips);
        /** Sets whether or not terrain tiles should be morphed between LODs
        (NB requires vertex program support). */
        void setUseLODMorph(bool useMorph);
        /** Sets whether vertex normals will be generated for the terrain. */
        void setUseVertexNormals(bool useNormals);
        /** Sets whether vertex colours will be used. */
        void setUseVertexColours(bool useColours);

        /** Sets the name of a custom material to use to shade the landcape. */
        void setCustomMaterial(const String& materialName);
        /** Sets the name of the vertex program parameter to which to pass the
        LOD morph factor. */
        void setCustomMaterialMorphFactorParam(const String& paramName);
        /** Sets the index of the vertex program parameter to which to pass the
        LOD morph factor. */
        void setCustomMaterialMorphFactorParam(uint paramIndex);
        /** Sets the distance at which the LOD will start to morph downwards, as
        a proportion of the distance between the LODs. */
        void setLODMorphStart(Real morphStart);

        /** Returns the TerrainRenderable that contains the given pt.
        If no tile exists at the point, it returns 0;
        */
        virtual BiTerrainRenderable * getTerrainTile( const Vector3 & pt );

        /** Returns the TerrainPage that contains the given pt.
        If no page exists at the point, it returns 0;
        */
        virtual BiTerrainPage* getTerrainPage( const Vector3 & pt );

        /// Gets the terrain options 
        const BiTerrainOptions& getOptions(void) { return mOptions; }

        /** Sets the 'primary' camera, i.e. the one which will be used to determine
        the 'home' terrain page, and to calculate the error metrics. 
        */
        virtual void setPrimaryCamera(const Camera* cam);
        /// Internal map of page source name to page source
        typedef std::map<String, BiTerrainPageSource*> BiPageSourceMap;

        /// Iterator over all page sources
        typedef ConstMapIterator<BiPageSourceMap> BiPageSourceIterator;
        /// Get an iterator over all page sources
        BiPageSourceIterator getPageSourceIterator(void);
        /** Registers a TerrainPageSource class and associates it with a named type 
        of source. */
        virtual void registerPageSource(const String& typeName, BiTerrainPageSource* source);
        /** Selects a given page source based on its type name. */
        virtual void selectPageSource(const String& typeName, 
                BiTerrainPageSourceOptionList& optionList);

        /** Attaches a previously built page to the list of available pages. */
        virtual void attachPage(ushort pageX, ushort pageZ, BiTerrainPage* page);
        /// Get a pointer to the material being used for the terrain
        MaterialPtr& getTerrainMaterial(void);

        /// Get the SceneNode under which all terrain nodes are attached.
        SceneNode* getTerrainRootNode(void) const { return mTerrainRoot; }

        /// Get the shared list of indexes cached (internal use only)
        BiTerrainBufferCache& _getIndexCache(void) {return mIndexCache;}

        /// Get the shared level index list (internal use only)
        LevelArray& _getLevelIndex(void) { return mLevelIndex; }

        /// Get the current page count (internal use only)
        uint _getPageCount(void) { return (uint)mTerrainPages.size(); }

        /// Shutdown cleanly before we get destroyed
        void shutdown(void);

protected:
        /// Validates that the size picked for the terrain is acceptable
        bool _checkSize( int s )
        {
                for ( int i = 0; i < 16; i++ )
                {
                        printf( "Checking...%d\n", ( 1 << i ) + 1 );

                        if ( s == ( 1 << i ) + 1 )
                                return true;
                }

                return false;

        }

        /// The node to which all terrain tiles are attached
        SceneNode * mTerrainRoot;
        /// Terrain size, detail etc
        BiTerrainOptions mOptions;
        /// Should we use an externally-defined custom material?
        bool mUseCustomMaterial;
        /// The name of the custom material to use
        String mCustomMaterialName;
        /// The name of the world texture
        String mWorldTextureName;
        /// The name of the detail texture
        String mDetailTextureName;
        /// Are we using a named parameter to hook up LOD morph?
        bool mUseNamedParameterLodMorph;
        /// The name of the parameter to send the LOD morph to
        String mLodMorphParamName;
        /// The index of the parameter to send the LOD morph to
        uint mLodMorphParamIndex;
        /// Whether paging is enabled, or whether a single page will be used
        bool mPagingEnabled;
        /// The number of pages to render outside the 'home' page
        unsigned short mLivePageMargin;
        /// The number of pages to keep loaded outside the 'home' page
        unsigned short mBufferedPageMargin;
        /// Grid of buffered pages
        BiTerrainPage2D mTerrainPages;
        //-- attributes to share across tiles
        /// Shared list of index buffers
        BiTerrainBufferCache mIndexCache;
        /// Shared array of IndexData (reuse indexes across tiles)
        LevelArray mLevelIndex;

        /// Internal method for loading configurations settings
        void loadConfig(DataStreamPtr& stream);

        /// Sets up the terrain material
        void setupTerrainMaterial(void);
        /// Sets up the terrain page slots
        void setupTerrainPages(void);
        /// Initialise level indexes
        void initLevelIndexes(void);
        /// Destroy level indexes
        void destroyLevelIndexes(void);


        /// Map of source type -> TerrainPageSource
        BiPageSourceMap mPageSources;
        /// The currently active page source
        BiTerrainPageSource* mActivePageSource;
};

/// Factory for BiTreeSceneManager
class BiTerrainSceneManagerFactory : public SceneManagerFactory
{
protected:
        typedef std::vector<BiTerrainPageSource*> BiTerrainPageSources;
        BiTerrainPageSources mTerrainPageSources;
        GtpVisibility::VisibilityManager *visManager;
        void initMetaData(void) const;
public:
        BiTerrainSceneManagerFactory(GtpVisibility::VisibilityManager * vm);
        ~BiTerrainSceneManagerFactory(void);
        /// Factory type name
        static const String FACTORY_TYPE_NAME;
        SceneManager* createInstance(const String& instanceName);
        void destroyInstance(SceneManager* instance);
};

} // namespace Ogre

#endif // _BiTreeTerrainSceneManager_H__