PagedLOD

Go to the documentation of this file.

/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
 *
 * This library is open source and may be redistributed and/or modified under
 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
 * (at your option) any later version.  The full license is in LICENSE file
 * included with this distribution, and on the openscenegraph.org website.
 *
 * This library 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
 * OpenSceneGraph Public License for more details.
*/
 
#ifndef OSG_PagedLOD
#define OSG_PagedLOD 1
 
#include <osg/LOD>
 
namespace osg {

class OSG_EXPORT PagedLOD : public LOD
{
    public :

        PagedLOD();

        PagedLOD(const PagedLOD&,const CopyOp& copyop=CopyOp::SHALLOW_COPY);
 
        META_Node(osg, PagedLOD);
 
        virtual void traverse(NodeVisitor& nv);
 
        using osg::Group::addChild;
 
        virtual bool addChild(Node *child);
 
        virtual bool addChild(Node *child, float rmin, float rmax);
 
        template<class T> bool addChild( const ref_ptr<T>& child, float rmin, float rmax) { return addChild(child.get(), rmin, rmax); }
 
        virtual bool addChild(Node *child, float rmin, float rmax, const std::string& filename, float priorityOffset=0.0f, float priorityScale=1.0f);
 
        template<class T> bool addChild( const ref_ptr<T>& child, float rmin, float rmax, const std::string& filename, float priorityOffset=0.0f, float priorityScale=1.0f) { return addChild(child.get(), rmin, rmax, filename, priorityOffset, priorityScale); }
 
        virtual bool removeChildren(unsigned int pos,unsigned int numChildrenToRemove=1);
 

        void setDatabaseOptions(osg::Referenced* options) { _databaseOptions = options; }

        osg::Referenced* getDatabaseOptions() { return _databaseOptions.get(); }

        const osg::Referenced* getDatabaseOptions() const { return _databaseOptions.get(); }
 

        void setDatabasePath(const std::string& path);

        inline const std::string& getDatabasePath() const { return _databasePath; }
 
 
        struct OSG_EXPORT PerRangeData
        {
            PerRangeData();
            PerRangeData(const PerRangeData& prd);
            PerRangeData& operator = (const PerRangeData& prd);
 
            std::string                     _filename;
            float                           _priorityOffset;
            float                           _priorityScale;
            double                          _minExpiryTime;
            unsigned int                    _minExpiryFrames;
            double                          _timeStamp;
            unsigned int                    _frameNumber;
            unsigned int                    _frameNumberOfLastReleaseGLObjects;
            osg::ref_ptr<osg::Referenced>   _databaseRequest;
        };
 
        typedef std::vector<PerRangeData> PerRangeDataList;
 
        void setFileName(unsigned int childNo, const std::string& filename) { expandPerRangeDataTo(childNo); _perRangeDataList[childNo]._filename=filename; }
        const std::string& getFileName(unsigned int childNo) const { return _perRangeDataList[childNo]._filename; }
        unsigned int getNumFileNames() const { return static_cast<unsigned int>(_perRangeDataList.size()); }
 
 
        void setPriorityOffset(unsigned int childNo, float priorityOffset) { expandPerRangeDataTo(childNo); _perRangeDataList[childNo]._priorityOffset=priorityOffset; }
        float getPriorityOffset(unsigned int childNo) const { return _perRangeDataList[childNo]._priorityOffset; }
        unsigned int getNumPriorityOffsets() const { return static_cast<unsigned int>(_perRangeDataList.size()); }
 
        void setPriorityScale(unsigned int childNo, float priorityScale) { expandPerRangeDataTo(childNo); _perRangeDataList[childNo]._priorityScale=priorityScale; }
        float getPriorityScale(unsigned int childNo) const { return _perRangeDataList[childNo]._priorityScale; }
        unsigned int getNumPriorityScales() const { return static_cast<unsigned int>(_perRangeDataList.size()); }

        void setMinimumExpiryTime(unsigned int childNo, double minTime) { expandPerRangeDataTo(childNo); _perRangeDataList[childNo]._minExpiryTime=minTime; }
        double getMinimumExpiryTime(unsigned int childNo) const { return _perRangeDataList[childNo]._minExpiryTime; }
        unsigned int getNumMinimumExpiryTimes() const { return static_cast<unsigned int>(_perRangeDataList.size()); }

        void setMinimumExpiryFrames(unsigned int childNo, unsigned int minFrames) { expandPerRangeDataTo(childNo); _perRangeDataList[childNo]._minExpiryFrames=minFrames; }
        unsigned int getMinimumExpiryFrames(unsigned int childNo) const { return _perRangeDataList[childNo]._minExpiryFrames; }
        unsigned int getNumMinimumExpiryFrames() const { return static_cast<unsigned int>(_perRangeDataList.size()); }
 
 
        void setTimeStamp(unsigned int childNo, double timeStamp) { expandPerRangeDataTo(childNo); _perRangeDataList[childNo]._timeStamp=timeStamp; }
        double getTimeStamp(unsigned int childNo) const { return _perRangeDataList[childNo]._timeStamp; }
        unsigned int getNumTimeStamps() const { return static_cast<unsigned int>(_perRangeDataList.size()); }
 
        void setFrameNumber(unsigned int childNo, unsigned int frameNumber) { expandPerRangeDataTo(childNo); _perRangeDataList[childNo]._frameNumber=frameNumber; }
        unsigned getFrameNumber(unsigned int childNo) const { return _perRangeDataList[childNo]._frameNumber; }
        unsigned int getNumFrameNumbers() const { return static_cast<unsigned int>(_perRangeDataList.size()); }
 

        osg::ref_ptr<osg::Referenced>& getDatabaseRequest(unsigned int childNo) { return _perRangeDataList[childNo]._databaseRequest; }

        const osg::ref_ptr<osg::Referenced>& getDatabaseRequest(unsigned int childNo) const { return _perRangeDataList[childNo]._databaseRequest; }
 

        inline void setFrameNumberOfLastTraversal(unsigned int frameNumber) { _frameNumberOfLastTraversal=frameNumber; }

        inline unsigned int getFrameNumberOfLastTraversal() const { return _frameNumberOfLastTraversal; }
 

        inline void setNumChildrenThatCannotBeExpired(unsigned int num) { _numChildrenThatCannotBeExpired = num; }

        unsigned int getNumChildrenThatCannotBeExpired() const { return _numChildrenThatCannotBeExpired; }

        void setDisableExternalChildrenPaging(bool flag) { _disableExternalChildrenPaging = flag; }
 
        bool getDisableExternalChildrenPaging() const { return _disableExternalChildrenPaging; }
 
 

        virtual bool removeExpiredChildren(double expiryTime, unsigned int expiryFrame, NodeList& removedChildren);
 
    protected :
 
        virtual ~PagedLOD();
 
        void expandPerRangeDataTo(unsigned int pos);
 
        ref_ptr<Referenced> _databaseOptions;
        std::string         _databasePath;
 
        unsigned int        _frameNumberOfLastTraversal;
        unsigned int        _numChildrenThatCannotBeExpired;
        bool                _disableExternalChildrenPaging;
 
        PerRangeDataList    _perRangeDataList;
};
 
}
 
#endif