osgEarth::Cache* Registry::getDefaultCache() const { if (!_defaultCache.valid()) { std::string driverName = getDefaultCacheDriverName(); Threading::ScopedMutexLock lock(_regMutex); if (!_defaultCache.valid()) { const char* noCache = ::getenv(OSGEARTH_ENV_NO_CACHE); if (noCache == 0L) { // see if there's a cache in the envvar; if so, create a cache. // Note: the value of the OSGEARTH_CACHE_PATH is not used here; rather // it's used in the driver(s) itself. const char* cachePath = ::getenv(OSGEARTH_ENV_CACHE_PATH); if (cachePath && !driverName.empty()) { CacheOptions cacheOptions; cacheOptions.setDriver(driverName); _defaultCache = CacheFactory::create(cacheOptions); } } } } return _defaultCache.get(); }
LevelDBCacheImpl::LevelDBCacheImpl( const CacheOptions& options ) : osgEarth::Cache( options ), _options ( options ), _active ( true ) { // Force OSG to initialize the image wrapper. Failure to do this can result // in a race condition within OSG when the cache is accessed from multiple threads. osgDB::ObjectWrapperManager* owm = osgDB::Registry::instance()->getObjectWrapperManager(); owm->findWrapper("osg::Image"); owm->findWrapper("osg::HeightField"); if ( _options.rootPath().isSet() ) { _rootPath = URI( *_options.rootPath(), options.referrer() ).full(); } else { // read the root path from ENV is necessary: const char* cachePath = ::getenv(OSGEARTH_ENV_CACHE_PATH); if ( cachePath ) { _rootPath = cachePath; OE_INFO << LC << "Cache location set from environment: \"" << cachePath << "\"" << std::endl; } } const char* maxsize = ::getenv(OSGEARTH_ENV_CACHE_MAX_SIZE_MB); if ( maxsize ) { unsigned mb = as<unsigned>(std::string(maxsize), 0u); if ( mb > 0 ) { _options.maxSizeMB() = mb; OE_INFO << LC << "Set max cache size from environment: " << (_options.maxSizeMB().value()) << " MB" << std::endl; } else { OE_WARN << LC << "Env var \"" OSGEARTH_ENV_CACHE_MAX_SIZE_MB "\" set to an invalid value" << std::endl; } } _tracker = new Tracker(_options, _rootPath); if ( !_rootPath.empty() ) { init(); } else { _active = false; OE_WARN << LC << "Illegal: no root path set for cache!" << std::endl; } }
LevelDBCacheImpl::LevelDBCacheImpl( const CacheOptions& options ) : osgEarth::Cache( options ), _options ( options ), _active ( true ) { if ( _options.rootPath().isSet() ) { _rootPath = URI( *_options.rootPath(), options.referrer() ).full(); } else { // read the root path from ENV is necessary: const char* cachePath = ::getenv(OSGEARTH_ENV_CACHE_PATH); if ( cachePath ) { _rootPath = cachePath; OE_INFO << LC << "Cache location set from environment: \"" << cachePath << "\"" << std::endl; } } const char* maxsize = ::getenv(OSGEARTH_ENV_CACHE_MAX_SIZE_MB); if ( maxsize ) { unsigned mb = as<unsigned>(std::string(maxsize), 0u); if ( mb > 0 ) { _options.maxSizeMB() = mb; OE_INFO << LC << "Set max cache size from environment: " << (_options.maxSizeMB().value()) << " MB" << std::endl; } else { OE_WARN << LC << "Env var \"" OSGEARTH_ENV_CACHE_MAX_SIZE_MB "\" set to an invalid value" << std::endl; } } _tracker = new Tracker(_options, _rootPath); if ( !_rootPath.empty() ) { init(); } else { _active = false; OE_WARN << LC << "Illegal: no root path set for cache!" << std::endl; } }
Registry::Registry() : osg::Referenced ( true ), _gdal_registered ( false ), _numGdalMutexGets ( 0 ), _uidGen ( 0 ), _caps ( 0L ), _defaultFont ( 0L ), _terrainEngineDriver( "mp" ), _cacheDriver ( "filesystem" ) { // set up GDAL and OGR. OGRRegisterAll(); GDALAllRegister(); // support Chinese character in the file name and attributes in ESRI's shapefile CPLSetConfigOption("GDAL_FILENAME_IS_UTF8","NO"); CPLSetConfigOption("SHAPE_ENCODING",""); // global initialization for CURL (not thread safe) HTTPClient::globalInit(); // generates the basic shader code for the terrain engine and model layers. _shaderLib = new ShaderFactory(); // shader generator used internally by osgEarth. Can be replaced. _shaderGen = new ShaderGenerator(); // thread pool for general use _taskServiceManager = new TaskServiceManager(); // optimizes sharing of state attributes and state sets for // performance boost _stateSetCache = new StateSetCache(); // Default unref-after apply policy: _unRefImageDataAfterApply = true; // Default object index for tracking scene object by UID. _objectIndex = new ObjectIndex(); // activate KMZ support osgDB::Registry::instance()->addArchiveExtension ( "kmz" ); osgDB::Registry::instance()->addFileExtensionAlias( "kmz", "kml" ); osgDB::Registry::instance()->addMimeTypeExtensionMapping( "application/vnd.google-earth.kml+xml", "kml" ); osgDB::Registry::instance()->addMimeTypeExtensionMapping( "application/vnd.google-earth.kmz", "kmz" ); osgDB::Registry::instance()->addMimeTypeExtensionMapping( "text/plain", "osgb" ); osgDB::Registry::instance()->addMimeTypeExtensionMapping( "text/xml", "osgb" ); osgDB::Registry::instance()->addMimeTypeExtensionMapping( "application/json", "osgb" ); osgDB::Registry::instance()->addMimeTypeExtensionMapping( "text/json", "osgb" ); osgDB::Registry::instance()->addMimeTypeExtensionMapping( "text/x-json", "osgb" ); osgDB::Registry::instance()->addMimeTypeExtensionMapping( "image/jpg", "jpg" ); osgDB::Registry::instance()->addMimeTypeExtensionMapping( "image/dds", "dds" ); // pre-load OSG's ZIP plugin so that we can use it in URIs std::string zipLib = osgDB::Registry::instance()->createLibraryNameForExtension( "zip" ); if ( !zipLib.empty() ) osgDB::Registry::instance()->loadLibrary( zipLib ); // set up our default r/w options to NOT cache archives! _defaultOptions = new osgDB::Options(); _defaultOptions->setObjectCacheHint( osgDB::Options::CACHE_NONE ); // activate no-cache mode from the environment if ( ::getenv(OSGEARTH_ENV_NO_CACHE) ) { _overrideCachePolicy = CachePolicy::NO_CACHE; OE_INFO << LC << "NO-CACHE MODE set from environment" << std::endl; } else { // activate cache-only mode from the environment if ( ::getenv(OSGEARTH_ENV_CACHE_ONLY) ) { _overrideCachePolicy->usage() = CachePolicy::USAGE_CACHE_ONLY; OE_INFO << LC << "CACHE-ONLY MODE set from environment" << std::endl; } // see if the environment specifies a default caching driver. const char* cacheDriver = ::getenv(OSGEARTH_ENV_CACHE_DRIVER); if ( cacheDriver ) { setDefaultCacheDriverName( cacheDriver ); OE_INFO << LC << "Cache driver set from environment: " << getDefaultCacheDriverName() << std::endl; } // cache max age? const char* cacheMaxAge = ::getenv(OSGEARTH_ENV_CACHE_MAX_AGE); if ( cacheMaxAge ) { TimeSpan maxAge = osgEarth::as<long>( std::string(cacheMaxAge), INT_MAX ); _overrideCachePolicy->maxAge() = maxAge; } // see if there's a cache in the envvar; if so, create a cache. // Note: the value of the OSGEARTH_CACHE_PATH is not used here; rather // it's used in the driver(s) itself. const char* cachePath = ::getenv(OSGEARTH_ENV_CACHE_PATH); if ( cachePath ) { CacheOptions options; options.setDriver( getDefaultCacheDriverName() ); osg::ref_ptr<Cache> cache = CacheFactory::create(options); if ( cache->isOK() ) { setCache( cache.get() ); } else { OE_WARN << LC << "FAILED to initialize cache from environment" << std::endl; } } } const char* teStr = ::getenv(OSGEARTH_ENV_TERRAIN_ENGINE_DRIVER); if ( teStr ) { _terrainEngineDriver = std::string(teStr); } // load a default font const char* envFont = ::getenv("OSGEARTH_DEFAULT_FONT"); if ( envFont ) { _defaultFont = osgText::readFontFile( std::string(envFont) ); } if ( !_defaultFont.valid() ) { #ifdef WIN32 _defaultFont = osgText::readFontFile("arial.ttf"); #endif } if ( _defaultFont.valid() ) { // mitigates mipmapping issues that cause rendering artifacts // for some fonts/placement _defaultFont->setGlyphImageMargin( 2 ); } // register the system stock Units. Units::registerAll( this ); }