OgreTerrainSceneManager.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.
-----------------------------------------------------------------------------
*/
/***************************************************************************
terrainscenemanager.h  -  description
---------------------
  begin                : Mon Sep 23 2002
  copyright            : (C) 2002 by Jon Anderson
  email                : janders@users.sf.net

  Enhancements 2003 - 2004 (C) The OGRE Team

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

#ifndef TERRAINSCENEMANAGER_H
#define TERRAINSCENEMANAGER_H

#include "OgreTerrainPrerequisites.h"
#include "OgreOctreeSceneManager.h"
#include "OgreOctreeSceneQuery.h"
#include "OgreTerrainRenderable.h"
#include "OgreTerrainPageSource.h"
#include "OgreIteratorWrappers.h"


namespace Ogre
{

class Image;

typedef std::vector < TerrainPage * > TerrainPageRow;
typedef std::vector < TerrainPageRow > TerrainPage2D;

class _OgreTerrainExport TerrainRaySceneQuery : public OctreeRaySceneQuery
{
protected:
    WorldFragment mWorldFrag;
public:
    TerrainRaySceneQuery(SceneManager* creator);
    ~TerrainRaySceneQuery();

    void execute(RaySceneQueryListener* listener);
};



class _OgreTerrainExport TerrainSceneManager : public OctreeSceneManager
{
public:
    TerrainSceneManager(const String& name);
    virtual ~TerrainSceneManager( );

    const String& getTypeName(void) const;

    void setWorldGeometry( const String& filename );
    virtual void setWorldGeometry(DataStreamPtr& stream, 
        const String& typeName = StringUtil::BLANK);

    virtual void _renderVisibleObjects( void );

    float getHeightAt( float x, float y );


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

    void setWorldTexture(const String& textureName);
    void setDetailTexture(const String& textureName);
    void setDetailTextureRepeat(int repeat);
    void setTileSize(int size); 
    void setPageSize(int size); 
    void setMaxPixelError(int pixelError); 
    void setScale(const Vector3& scale);
    void setMaxGeoMipMapLevel(int maxMip);
    
    const String& getWorldTexture(void) { return mWorldTextureName; }
    const String& getDetailTexture(void) { return mDetailTextureName; }
    int getDetailTextureRepeat(void);
    int getTileSize(void); 
    int getPageSize(void); 
    int getMaxPixelError(void); 
    const Vector3& getScale(void);
    int getMaxGeoMipMapLevel(void);



    void setUseTriStrips(bool useStrips);
    void setUseLODMorph(bool useMorph);
    void setUseVertexNormals(bool useNormals);
    void setUseVertexColours(bool useColours);

    void setCustomMaterial(const String& materialName);
    void setCustomMaterialMorphFactorParam(const String& paramName);
    void setCustomMaterialMorphFactorParam(size_t paramIndex);
    void setLODMorphStart(Real morphStart);

    virtual TerrainRenderable * getTerrainTile( const Vector3 & pt );

    virtual TerrainPage* getTerrainPage( const Vector3 & pt );

    RaySceneQuery* 
        createRayQuery(const Ray& ray, unsigned long mask = 0xFFFFFFFF);

    Camera* createCamera( const String &name );
    const TerrainOptions& getOptions(void) { return mOptions; }

    virtual bool setOption( const String &, const void * );

    virtual void setPrimaryCamera(const Camera* cam);
    typedef std::map<String, TerrainPageSource*> PageSourceMap;

    typedef ConstMapIterator<PageSourceMap> PageSourceIterator;
    PageSourceIterator getPageSourceIterator(void);
    virtual void registerPageSource(const String& typeName, TerrainPageSource* source);
    virtual void selectPageSource(const String& typeName, 
        TerrainPageSourceOptionList& optionList);

    virtual void attachPage(ushort pageX, ushort pageZ, TerrainPage* page);
    MaterialPtr& getTerrainMaterial(void);
    // Overridden from basic scene manager
    void _renderScene(Camera *cam, Viewport *vp, bool includeOverlays);

    SceneNode* getTerrainRootNode(void) const { return mTerrainRoot; }
    void clearScene(void);
    void setWorldGeometryRenderQueue(uint8 qid);

    TerrainBufferCache& _getIndexCache(void) {return mIndexCache;}

    LevelArray& _getLevelIndex(void) { return mLevelIndex; }

    size_t _getPageCount(void) { return mTerrainPages.size(); }

    void shutdown(void);


protected:

    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;

    }

    SceneNode * mTerrainRoot;
    TerrainOptions mOptions;
    bool mUseCustomMaterial;
    String mCustomMaterialName;
    String mWorldTextureName;
    String mDetailTextureName;
    bool mUseNamedParameterLodMorph;
    String mLodMorphParamName;
    size_t mLodMorphParamIndex;
    bool mPagingEnabled;
    unsigned short mLivePageMargin;
    unsigned short mBufferedPageMargin;
    TerrainPage2D mTerrainPages;
    //-- attributes to share across tiles
    TerrainBufferCache mIndexCache;
    LevelArray mLevelIndex;
    
    void loadConfig(DataStreamPtr& stream);

    void setupTerrainMaterial(void);
    void setupTerrainPages(void);
    void initLevelIndexes(void);
    void destroyLevelIndexes(void);


    PageSourceMap mPageSources;
    TerrainPageSource* mActivePageSource;

};
class TerrainSceneManagerFactory : public SceneManagerFactory
{
protected:
    typedef std::vector<TerrainPageSource*> TerrainPageSources;
    TerrainPageSources mTerrainPageSources;
    void initMetaData(void) const;
public:
    TerrainSceneManagerFactory();
    ~TerrainSceneManagerFactory();
    static const String FACTORY_TYPE_NAME;
    SceneManager* createInstance(const String& instanceName);
    void destroyInstance(SceneManager* instance);
};

}

#endif

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Mar 12 14:37:51 2006