Options.h

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 OSGDB_OPTIONS
#define OSGDB_OPTIONS 1

#include <osgDB/Callbacks>
#include <osgDB/ObjectCache>
#include <osg/ObserverNodePath>

#include <deque>
#include <list>
#include <iosfwd>

namespace osgDB {


class OSGDB_EXPORT Options : public osg::Object
{
    public:

        enum CacheHintOptions
        {   
            CACHE_NONE          = 0,

            CACHE_NODES         = 1<<0,

            CACHE_IMAGES        = 1<<1,

            CACHE_HEIGHTFIELDS  = 1<<2,

            CACHE_ARCHIVES      = 1<<3,

            CACHE_OBJECTS       = 1<<4,

            CACHE_SHADERS       = 1<<5,

            CACHE_ALL           = CACHE_NODES |
                                    CACHE_IMAGES |
                                    CACHE_HEIGHTFIELDS |
                                    CACHE_ARCHIVES |
                                    CACHE_OBJECTS |
                                    CACHE_SHADERS
        };

        enum PrecisionHint
        {
            FLOAT_PRECISION_ALL              = 0,

            DOUBLE_PRECISION_VERTEX          = 1<<0,
            DOUBLE_PRECISION_NORMAL          = 1<<1,
            DOUBLE_PRECISION_COLOR           = 1<<2,
            DOUBLE_PRECISION_SECONDARY_COLOR = 1<<3,
            DOUBLE_PRECISION_FOG_COORD       = 1<<4,
            DOUBLE_PRECISION_TEX_COORD       = 1<<5,
            DOUBLE_PRECISION_VERTEX_ATTRIB   = 1<<6,

            DOUBLE_PRECISION_ALL = DOUBLE_PRECISION_VERTEX |
                                   DOUBLE_PRECISION_NORMAL |
                                   DOUBLE_PRECISION_COLOR |
                                   DOUBLE_PRECISION_SECONDARY_COLOR |
                                   DOUBLE_PRECISION_FOG_COORD |
                                   DOUBLE_PRECISION_TEX_COORD |
                                   DOUBLE_PRECISION_VERTEX_ATTRIB
        };

        enum BuildKdTreesHint
        {
            NO_PREFERENCE,
            DO_NOT_BUILD_KDTREES,
            BUILD_KDTREES
        };


        Options():
            osg::Object(true),
            _objectCacheHint(CACHE_ARCHIVES),
            _precisionHint(FLOAT_PRECISION_ALL),
            _buildKdTreesHint(NO_PREFERENCE) {}

        Options(const std::string& str):
            osg::Object(true),
            _str(str),
            _objectCacheHint(CACHE_ARCHIVES),
            _precisionHint(FLOAT_PRECISION_ALL),
            _buildKdTreesHint(NO_PREFERENCE)
        {
            parsePluginStringData(str);
        }

        Options(const Options& options,const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY);

        META_Object(osgDB,Options);

        Options* cloneOptions(const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY) const { return static_cast<Options*>(clone(copyop)); }

        void setOptionString(const std::string& str) { _str = str; parsePluginStringData(str); }

        const std::string& getOptionString() const { return _str; }

        void setDatabasePath(const std::string& str) { _databasePaths.clear();  _databasePaths.push_back(str); }

        FilePathList& getDatabasePathList() { return _databasePaths; }

        const FilePathList& getDatabasePathList() const { return _databasePaths; }


        void setObjectCacheHint(CacheHintOptions useObjectCache) { _objectCacheHint = useObjectCache; }

        CacheHintOptions getObjectCacheHint() const { return _objectCacheHint; }

        void setObjectCache(ObjectCache* objectCache) { _objectCache = objectCache; }

        ObjectCache* getObjectCache() const { return _objectCache.get(); }


        void setPrecisionHint(PrecisionHint hint) { _precisionHint = hint; }

        PrecisionHint getPrecisionHint() const { return _precisionHint; }

        void setBuildKdTreesHint(BuildKdTreesHint hint) { _buildKdTreesHint = hint; }

        BuildKdTreesHint getBuildKdTreesHint() const { return _buildKdTreesHint; }


        void setAuthenticationMap(AuthenticationMap* authenticationMap) { _authenticationMap = authenticationMap; }

        const AuthenticationMap* getAuthenticationMap() const { return _authenticationMap.get(); }


        void setPluginData(const std::string& s, void* v) const { _pluginData[s] = v; }

        void* getPluginData(const std::string& s) { return _pluginData[s]; }

        const void* getPluginData(const std::string& s) const
        {
            PluginDataMap::const_iterator itr = _pluginData.find(s);
            return (itr == _pluginData.end()) ? 0 : itr->second;
        }

        void removePluginData(const std::string& s) const { _pluginData.erase(s); }

        unsigned int getNumPluginData() const { return static_cast<unsigned int>(_pluginData.size()); }


        void setPluginStringData(const std::string& s, const std::string& v) const { _pluginStringData[s] = v; }

        std::string& getPluginStringData(const std::string& s) { return _pluginStringData[s]; }

        const std::string getPluginStringData(const std::string& s) const
        {
            PluginStringDataMap::const_iterator itr = _pluginStringData.find(s);
            return (itr == _pluginStringData.end()) ? std::string("") : itr->second;
        }

        void removePluginStringData(const std::string& s) const { _pluginStringData.erase(s); }

        unsigned int getNumPluginStringData() const { return static_cast<unsigned int>(_pluginStringData.size()); }

        void parsePluginStringData(const std::string& str, char separator1=' ', char separator2='=');


        void setFindFileCallback( FindFileCallback* cb) { _findFileCallback = cb; }

        FindFileCallback* getFindFileCallback() const { return _findFileCallback.get(); }


        void setReadFileCallback( ReadFileCallback* cb) { _readFileCallback = cb; }

        ReadFileCallback* getReadFileCallback() const { return _readFileCallback.get(); }


        void setWriteFileCallback( WriteFileCallback* cb) { _writeFileCallback = cb; }

        WriteFileCallback* getWriteFileCallback() const { return _writeFileCallback.get(); }


        void setFileLocationCallback( FileLocationCallback* cb) { _fileLocationCallback = cb; }

        FileLocationCallback* getFileLocationCallback() const { return _fileLocationCallback.get(); }

        void setFileCache(FileCache* fileCache) { _fileCache = fileCache; }

        FileCache* getFileCache() const { return _fileCache.get(); }


        void setTerrain(osg::observer_ptr<osg::Node>& terrain) { _terrain = terrain; }

        const osg::observer_ptr<osg::Node>& getTerrain() const { return _terrain; }

        void setParentGroup(osg::observer_ptr<osg::Group>& parentGroup) { _parentGroup= parentGroup; }

        const osg::observer_ptr<osg::Group>& getParentGroup() const { return _parentGroup; }

    protected:

        virtual ~Options() {}

        std::string                     _str;
        FilePathList                    _databasePaths;

        CacheHintOptions                _objectCacheHint;
        osg::ref_ptr<ObjectCache>       _objectCache;

        PrecisionHint                   _precisionHint;
        BuildKdTreesHint                _buildKdTreesHint;
        osg::ref_ptr<AuthenticationMap> _authenticationMap;

        typedef std::map<std::string,void*> PluginDataMap;
        mutable PluginDataMap _pluginData;
        typedef std::map<std::string,std::string> PluginStringDataMap;
        mutable PluginStringDataMap _pluginStringData;

        osg::ref_ptr<FindFileCallback>      _findFileCallback;
        osg::ref_ptr<ReadFileCallback>      _readFileCallback;
        osg::ref_ptr<WriteFileCallback>     _writeFileCallback;
        osg::ref_ptr<FileLocationCallback>  _fileLocationCallback;

        osg::ref_ptr<FileCache>             _fileCache;

        osg::observer_ptr<osg::Node>        _terrain;
        osg::observer_ptr<osg::Group>       _parentGroup; // Set by the DatabasePager to the node where the requested file will be inserted. NOTE: observer since prent can be dettached whilst DB thread is loading the object
};

}

#endif // OSGDB_OPTIONS