PagedGeometry.h

Go to the documentation of this file.

/*-------------------------------------------------------------------------------------
Copyright (c) 2006 John Judnich
 
This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
    1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
    2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
    3. This notice may not be removed or altered from any source distribution.
-------------------------------------------------------------------------------------*/
 
#include "PagedGeometryConfig.h"
 
//PagedGeometry.h
//Main header file for the PagedGeometry engine.
 
// this small snipped disables some warnings under MSVC that can be ignored normally
#ifdef _MSC_VER
// disable MSVC warning "... possible loss of data"
//# pragma warning(disable: 4244)
#endif //_MSC_VER
 
 
#ifndef __PagedGeometry_H__
#define __PagedGeometry_H__
 
#include <limits> // numeric_limits<>
#include <memory>
 
#include <OgreRoot.h>
#include <OgrePrerequisites.h>
#include <OgreRenderSystem.h>
#include <OgreEntity.h>
#include <OgreCommon.h>
#include <OgreCamera.h>
#include <OgreVector3.h>
#include <OgreTimer.h>
#include <OgreMesh.h>
 
namespace Forests {
 
class GeometryPageManager;
class PageLoader;
 
typedef Ogre::TRect<Ogre::Real> TBounds;
 
//-------------------------------------------------------------------------------------
class PagedGeometry
{
public:
    PagedGeometry(Ogre::Camera *cam = NULL, Ogre::Real pageSize = 100, Ogre::SceneNode* groupingSceneNode = NULL, Ogre::RenderQueueGroupID queue = Ogre::RENDER_QUEUE_6);
 
    ~PagedGeometry();
 
    void setCamera(Ogre::Camera *cam);
 
    void setTempDir(Ogre::String dir);
    Ogre::String getTempdir() { return this->tempdir; };
 
    inline Ogre::Camera *getCamera() const
    {
        return sceneCam;
    }
 
    inline Ogre::SceneManager *getSceneManager() const
    {
        return sceneMgr;
    }
 
    inline Ogre::SceneNode *getSceneNode() const
    {
        return m_pagedGroupingNode;
    }
 
    void setBounds(const TBounds bounds);
 
    void setInfinite();
 
    inline const TBounds &getBounds() const
    {
        return m_bounds;
    }
 
    TBounds convertAABToTBounds( const Ogre::AxisAlignedBox & aab ) const;
 
    void setPageSize(Ogre::Real size);
 
    inline Ogre::Real getPageSize()
    {
        return pageSize;
    }
 
 
    template <class PageType> inline GeometryPageManager* addDetailLevel(Ogre::Real maxRange, Ogre::Real transitionLength = 0, const Ogre::Any &data = Ogre::Any());
 
    void removeDetailLevels();
 
    inline const std::list<GeometryPageManager*> &getDetailLevels() { return managerList; }
 
 
    void setPageLoader(PageLoader *loader);
 
    inline PageLoader *getPageLoader()
    {
        return pageLoader;
    }
 
 
    void update();
 
 
    void reloadGeometry();
 
    void reloadGeometryPage(const Ogre::Vector3 &point);
 
    void reloadGeometryPages(const Ogre::Vector3 &center, Ogre::Real radius);
 
    void reloadGeometryPages(const TBounds & area);
 
    void preloadGeometry(const TBounds & area);
 
    void resetPreloadedGeometry();
 
    void setVisible(bool visible) { geometryAllowedVisible = visible; }
 
    bool getVisible() { return geometryAllowedVisible; }
 
    void setShadersEnabled(bool value) { shadersEnabled=value; }
    bool getShadersEnabled() { return shadersEnabled; }
 
    /*
    \brief Immediately loads visible geometry.
    \param maxTime The maximum amount of time (in milliseconds) which cacheGeometry()
    is allowed to use before returning (roughly).
    \returns Whether or not everything was cached.
 
    PagedGeometry automatically loads and caches geometry near the camera in real-time.
    This function allows you to easily pre-load this geometry outside of your render loop.
 
    For example, in your loading code, you might call PagedGeometry::cacheGeometry() to
    load all your trees/etc. managed by PagedGeometry instantly, rather than later on.
 
    If it takes several seconds to cache geometry, you may want to update a progress bar
    more often. The maxTime parameter allows you to split up this task into smaller
    segments for this purpose. Simply call cacheGeometry(maxTime) repeatedly until
    everything is cached (cacheGeometry() will return true when finished ).
    */
    //todo
    //bool cacheGeometry(unsigned long maxTime = 0);
 
   Ogre::uint8 getRenderQueue() const  { return m_nRenderQueue; }
 
protected:
    //Internal function - do not use
    void _addDetailLevel(GeometryPageManager *mgr, Ogre::Real maxRange, Ogre::Real transitionLength);
 
    Ogre::SceneManager *sceneMgr;
    Ogre::SceneNode *m_pagedGroupingNode;
    bool shadersEnabled;
 
    bool geometryAllowedVisible;    //If set to false, all geometry managed by this PagedGeometry is hidden
 
    //Camera data
    Ogre::Camera *sceneCam;
    Ogre::Vector3 oldCamPos;
 
    Ogre::Camera *lastSceneCam;
    Ogre::Vector3 lastOldCamPos;
 
    //This list keeps track of all the GeometryPageManager's added with addPageManager()
    std::list<GeometryPageManager*> managerList;
 
    //The assigned PageLoader used to load entities
    PageLoader *pageLoader;
 
    //The bounds and page size
    TBounds m_bounds;
    //The page size
    Ogre::Real pageSize;
   Ogre::uint8 m_nRenderQueue;   
 
    //Time-related data
    Ogre::Timer timer;
    unsigned long lastTime;
    Ogre::String tempdir;
};
 
 
 
//-------------------------------------------------------------------------------------
class GeometryPage
{
    friend class GeometryPageManager;
 
public:
    virtual void init(PagedGeometry *geom, const Ogre::Any &data) = 0;
 
    virtual void setRegion(Ogre::Real left, Ogre::Real top, Ogre::Real right, Ogre::Real bottom) {};
 
    virtual void addEntity(Ogre::Entity *ent, const Ogre::Vector3 &position, const Ogre::Quaternion &rotation, const Ogre::Vector3 &scale, const Ogre::ColourValue &color) = 0;
 
    virtual void build() {}
 
    virtual void removeEntities() = 0;
 
    virtual void setFade(bool enabled, Ogre::Real visibleDist = 0, Ogre::Real invisibleDist = 0) = 0;
 
    virtual void setVisible(bool visible) = 0;
 
    virtual void update() {}
 
    inline Ogre::Vector3 &getCenterPoint() { return _centerPoint; }
 
    inline bool isVisible() { return (_visible && _loaded); }
 
    virtual const Ogre::AxisAlignedBox &getBoundingBox();
 
    virtual void addEntityToBoundingBox(Ogre::Entity *ent, const Ogre::Vector3 &position, const Ogre::Quaternion &rotation, const Ogre::Vector3 &scale);
 
    virtual void clearBoundingBox();
 
    virtual ~GeometryPage() {}
 
    GeometryPage();
 
private:
    //These values and functions are used by the GeometryPageManager internally.
    Ogre::Vector3 _centerPoint;     //The central point of this page (used to visibility calculation)
    int _xIndex, _zIndex;           //The absolute grid position of this page
    unsigned long _inactiveTime;    //How long this page has been inactive (used to calculate expired pages)
    bool _visible;      //Flag indicating if page is visible
    bool _fadeEnable;   //Flag indicating if page fading is enabled
 
    bool _pending;      //Flag indicating if page needs loading
    bool _loaded;       //Flag indicating if page is loaded
    bool _needsUnload;  //Flag indicating if page needs unloading before next load
    bool _keepLoaded;   //Flag indicating if the page should not be unloaded
    std::list<GeometryPage*>::iterator _iter;   //Iterator in loadedList
 
    Ogre::AxisAlignedBox _trueBounds;   //Actual bounding box of the 3D geometry added to this page
    bool _trueBoundsUndefined;          //Flag indicating if _trueBounds has not been defined yet
};
 
 
 
//-------------------------------------------------------------------------------------
struct PageInfo
{
    TBounds bounds;
 
    Ogre::Vector3 centerPoint;
 
    int xIndex;
 
    int zIndex;
 
    std::vector<Ogre::Mesh*> meshList;
};
 
class PageLoader
{
public:
    virtual void loadPage(PageInfo &page) = 0;
 
    virtual void unloadPage(PageInfo &page) {}
 
    virtual void frameUpdate() {}
 
    virtual ~PageLoader() {}
 
protected:
    void addEntity(Ogre::Entity *ent, const Ogre::Vector3 &position, const Ogre::Quaternion &rotation, const Ogre::Vector3 &scale = Ogre::Vector3::UNIT_SCALE, const Ogre::ColourValue &color = Ogre::ColourValue::White)
    {
        geomPage->addEntity(ent, position, rotation, scale, color);
        geomPage->addEntityToBoundingBox(ent, position, rotation, scale);
    }
 
private:
    friend class GeometryPageManager;
 
    //Do NOT modify or use this variable - it is used internally by addEntity()
    GeometryPage *geomPage;
};
 
 
 
//-------------------------------------------------------------------------------------
class GeometryPageManager
{
public:
    typedef std::list<GeometryPage*> TPGeometryPages;
 
    GeometryPageManager(PagedGeometry *mainGeom);
 
    ~GeometryPageManager();
 
    inline void setNearRange(Ogre::Real nearRange)
    {
        nearDist = nearRange;
        nearDistSq = nearDist * nearDist;
    }
 
    inline void setFarRange(Ogre::Real farRange)
    {
        farDist = farRange;
        farDistSq = farDist * farDist;
 
        farTransDist = farDist + fadeLength;
        farTransDistSq = farTransDist * farTransDist;
    }
 
    inline Ogre::Real getNearRange() const
    {
        return nearDist;
    }
 
    inline Ogre::Real getFarRange() const
    {
        return farDist;
    }
 
    inline void setCacheSpeed(unsigned long maxCacheInterval = 200, unsigned long inactivePageLife = 2000)
    {
        GeometryPageManager::maxCacheInterval = maxCacheInterval;
        GeometryPageManager::inactivePageLife = inactivePageLife;
    }
 
    inline void setTransition(Ogre::Real transitionLength)
    {
        if (transitionLength > 0) {
            //Setup valid transition
            fadeLength = transitionLength;
            fadeLengthSq = fadeLength * fadeLength;
            fadeEnabled = true;
        } else {
            //<= 0 indicates disabled transition
            fadeLength = 0;
            fadeLengthSq = 0;
            fadeEnabled = false;
        }
 
        farTransDist = farDist + fadeLength;
        farTransDistSq = farTransDist * farTransDist;
    }
 
    inline Ogre::Real getTransition() const
    {
        return fadeLength;
    }
 
 
    inline TPGeometryPages getLoadedPages() const { return loadedList; }
 
    template <class PageType> void initPages(const TBounds& bounds, const Ogre::Any &data = Ogre::Any());
 
    void update(unsigned long deltaTime, Ogre::Vector3 &camPos, Ogre::Vector3 &camSpeed, bool &enableCache, GeometryPageManager *prevManager);
 
    void reloadGeometry();
 
    void reloadGeometryPage(const Ogre::Vector3 &point);
 
    void reloadGeometryPages(const Ogre::Vector3 &center, Ogre::Real radius);
 
    void reloadGeometryPages(const TBounds & area);
 
    void preloadGeometry(const TBounds & area);
 
    void resetPreloadedGeometry();
 
private:
    PagedGeometry *mainGeom;
 
    //geomGrid is a 2D array storing all the GeometryPage instances managed by this object.
    GeometryPage **geomGrid;    //A dynamic 2D array of pointers (2D grid of GeometryPage's)
    GeometryPage **scrollBuffer; //A dynamic 1D array of pointers (temporary GeometryPage's used in scrolling geomGrid)
    int geomGridX, geomGridZ;   //The dimensions of the dynamic array
    TBounds      gridBounds;        //Current grid bounds
 
    //Fade transitions
    Ogre::Real fadeLength, fadeLengthSq;
    bool fadeEnabled;
 
    //Inline function used to get geometry page tiles
    inline GeometryPage *_getGridPage(const int x, const int z)
    {
        #ifdef _DEBUG
        if(x >= geomGridX || z >= geomGridZ )
            OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS,
                "Grid dimension is out of bounds",
                "GeometryPageManager::_getGridPage()");
        #endif
 
        return geomGrid[z * geomGridX + x];
    }
    inline void _setGridPage(const int x, const int z, GeometryPage *page)
    {
        #ifdef _DEBUG
        if(x >= geomGridX || z >= geomGridZ )
            OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS,
                "Grid dimension is out of bounds",
                "GeometryPageManager::_setGridPage()");
        #endif
 
        geomGrid[z * geomGridX + x] = page;
    }
 
    //Utility functions for loading/unloading geometry pages (see source for detailed descriptions)
    void _loadPage(GeometryPage *page);
    void _unloadPage(GeometryPage *page);
    void _unloadPageDelayed(GeometryPage *page);
 
    //Utility function for scrolling pages in the grid by the given amount
    void _scrollGridPages(int shiftX, int shiftZ);
 
 
    //Timer counting how long it has been since the last page has been cached
    unsigned long cacheTimer;
 
    TPGeometryPages pendingList;    //Pages of geometry to be loaded
    TPGeometryPages loadedList; //Pages of geometry already loaded
 
    //Cache settings
    unsigned long maxCacheInterval;
    unsigned long inactivePageLife;
 
    //Near and far visibility ranges for this type of geometry
    Ogre::Real nearDist, nearDistSq;
    Ogre::Real farDist, farDistSq;
    Ogre::Real farTransDist, farTransDistSq;    //farTransDist = farDist + fadeLength
};
 
 
 
//-------------------------------------------------------------------------------------
 
template <class PageType> inline GeometryPageManager* PagedGeometry::addDetailLevel(Ogre::Real maxRange, Ogre::Real transitionLength, const Ogre::Any &data)
{
    //Create a new page manager
    GeometryPageManager *mgr = new GeometryPageManager(this);
 
    //If vertex shaders aren't supported, don't use transitions
    Ogre::Root *root = root->getSingletonPtr(); //Work-around for Linux compiler bug
    if (!root->getRenderSystem()->getCapabilities()->hasCapability(Ogre::RSC_VERTEX_PROGRAM))
        transitionLength = 0;
 
    //Add it to the list (also initializing maximum viewing distance)
    _addDetailLevel(mgr, maxRange, transitionLength);
 
    //And initialize the paged (dependent on maximum viewing distance)
    mgr->initPages<PageType>(getBounds(), data);
 
    return mgr;
}
 
template <class PageType> inline void GeometryPageManager::initPages(const TBounds& bounds, const Ogre::Any &data)
{
    // Calculate grid size, if left is Real minimum, it means that bounds are infinite
    // scrollBuffer is used as a flag. If it is allocated than infinite bounds are used
    // !!! Two cases are required because of the way scrolling is implemented
    // if it is redesigned it would allow to use the same functionality.
    if(bounds.width() < 0.00001)
    {
        // In case of infinite bounds bounding rect needs to be calculated in a different manner, since
        // it represents local bounds, which are shifted along with the player's movements around the world.
        geomGridX = (2 * farTransDist / mainGeom->getPageSize()) + 4;
        gridBounds.top = 0;
        gridBounds.left = 0;
        gridBounds.right = geomGridX * mainGeom->getPageSize();
        gridBounds.bottom = geomGridX * mainGeom->getPageSize();
        // Allocate scroll buffer (used in scrolling the grid)
        scrollBuffer = new GeometryPage *[geomGridX];
 
        //Note: All this padding and transition preparation is performed because even in infinite
        //mode, a local grid size must be chosen. Unfortunately, this also means that view ranges
        //and transition lengths cannot be exceeded dynamically with set functions.
    }
    else
    {
        //Bounded mode
        gridBounds = bounds;
        // In case the devision does not give the round number use the next largest integer
        geomGridX = std::ceil(gridBounds.width() / mainGeom->getPageSize());
    }
    geomGridZ = geomGridX; //Note: geomGridX == geomGridZ; Need to merge.
 
 
    //Allocate grid array
    geomGrid = new GeometryPage *[geomGridX * geomGridZ];
 
    int xioffset = Ogre::Math::Floor(gridBounds.left / mainGeom->getPageSize());
    int zioffset = Ogre::Math::Floor(gridBounds.top / mainGeom->getPageSize());
    for (int x = 0; x < geomGridX; ++x)
    {
        for (int z = 0; z < geomGridZ; ++z)
        {
            GeometryPage* page = new PageType();
            page->init(mainGeom, data);
            // 0,0 page is located at (gridBounds.left,gridBounds.top) corner of the bounds
            page->_centerPoint.x = ((x + 0.5f) * mainGeom->getPageSize()) + gridBounds.left;
            page->_centerPoint.z = ((z + 0.5f) * mainGeom->getPageSize()) + gridBounds.top;
            page->_centerPoint.y = 0.0f;
            page->_xIndex = x + xioffset;
            page->_zIndex = z + zioffset;
            page->_inactiveTime = 0;
            page->_loaded = false;
            page->_needsUnload = false;
            page->_pending = false;
            page->_keepLoaded = false;
            page->_visible = false;
            page->_fadeEnable = false;
 
            page->clearBoundingBox();
 
            _setGridPage(x, z, page);
        }
    }
}
 
 
}
 
 
 
 
#endif