Feature/globebrowsing optimization (#310)

* Simplest possible PBO implementation.

* Add PBO class

* TileLoadJob owns raw tile data

* Working on a soluton to cache textures and reuse them

* PBO and cached textures working for one texture type. Color textures.

* Threadpool for tile requests uses LRU cache as queue

* Remove framesUntilRequestFlush

* Clean up

* Clean up

* Use prioritizing concurrent job manager

* Use TileTextureInitData to initialize RawTileDataReader.

* Class TextureContainer owns the textures to use for tiles.

* Using TileTextureInitData to determine if new caches need to be created.

* Remove WriteDataDescription

* Remove TileDataLayout

* Rendering many different layer types again

* TileProviderByLevel gives layergroup id to tile providers

* Comment away use of PBO

* Erase unfinished requests to make room for new ones

* Enable choice of PBO or not.

* Enable resetting of asynctiledataprovider

* Add the ability to use PBO and also load to CPU

* Update ghoul

* Solve culling issue.

* Texture pointer of Tile is now a raw pointer. Currently break single image tile provider and text tile provider.

* Add gpudata

* Move fetching of shader preprocessing data to LayerManager

* No comparisons to determine shader recompilation.

* Show the tile cache size in the GUI

* Clean up and comment.

* Solve bug where float is interpreted as NaN

* Enable ability to blend between layers again

* Fix single image provider

* Fix windows build error

* Fix OSX compile issue.

* Some clean up

* Showing correct texture data size

* Enable use of text tile providers again. No backgroupd image path however.

* Change cache size from GUI

* Clean up

* Solve osx compilation error.

* Update ghoul

* Make it possible to switch between PBO and not during runtime.

* Enable resetting of tile datasets

* change function module in moduleengine to identify module by name

* MemoryAwareTileCache is no longer a singleton

* Update ownership of properties for globe browsing

* Logging info about resetting tile reader.

* Logging info

* Fix requested changes

* Fix some compile warnings.

* Fix compilation warnings

* Add ability to blend values with blend parameter. Also define settings through lua dict.

* Fix some comments on pull request.

* Change formatting

* Change formatting

* Change formatting

* Fix pull request comments.

* Those are details

* Make Mercury great again.

* Make Earth great again.

* Solve conflict

* Test to sometimes use valueblending and sometimes not

* Not always use value blending

* Update ghoul

* Change from auto to explicit type.

* Update test for LRU Cache

* Include algorithm.

modules/globebrowsing/globebrowsingmodule.cpp

@@ -50,39 +50,20 @@
 
 namespace openspace {
 
+const std::string GlobeBrowsingModule::name = "GlobeBrowsing";
+
 GlobeBrowsingModule::GlobeBrowsingModule()
-    : OpenSpaceModule("GlobeBrowsing")
-    , _openSpaceMaximumTileCacheSize(
-        "maximumTileCacheSize", "Maximum tile cache size",
-        512,    // Default: 512 MB
-        0,      // Minimum: No caching
-        1024,   // Maximum: 1024 MB
-        1)      // Step: One MB
-    , _clearTileCache("clearTileCache", "Clear tile cache") {}
+    : OpenSpaceModule(name)
+{ }
 
 void GlobeBrowsingModule::internalInitialize() {
     using namespace globebrowsing;
 
     OsEng.registerModuleCallback(OpenSpaceEngine::CallbackOption::Initialize, [&] {
-        // Set maximum cache size to 25% of total RAM
-        _openSpaceMaximumTileCacheSize.setMaxValue(CpuCap.installedMainMemory() * 0.25);
-        
-        // Convert from MB to KB
-        cache::MemoryAwareTileCache::create(_openSpaceMaximumTileCacheSize * 1024);
-        _openSpaceMaximumTileCacheSize.onChange(
-        [&]{
-            // Convert from MB to KB
-            cache::MemoryAwareTileCache::ref().setMaximumSize(
-                _openSpaceMaximumTileCacheSize * 1024);
-        });
-        _clearTileCache.onChange(
-        [&]{
-            cache::MemoryAwareTileCache::ref().clear();
-        });
 
-        addProperty(_openSpaceMaximumTileCacheSize);
-        addProperty(_clearTileCache);
-      
+    _tileCache = std::make_unique<globebrowsing::cache::MemoryAwareTileCache>();
+    addPropertySubOwner(*_tileCache);
+
 #ifdef GLOBEBROWSING_USE_GDAL
         // Convert from MB to Bytes
         GdalWrapper::create(
@@ -92,9 +73,12 @@ void GlobeBrowsingModule::internalInitialize() {
 #endif // GLOBEBROWSING_USE_GDAL
     });
   
+    OsEng.registerModuleCallback(OpenSpaceEngine::CallbackOption::Render, [&]{
+        _tileCache->update();
+    });
+
+  
     OsEng.registerModuleCallback(OpenSpaceEngine::CallbackOption::Deinitialize, [&]{
-        cache::MemoryAwareTileCache::ref().clear();
-        cache::MemoryAwareTileCache::ref().destroy();
 #ifdef GLOBEBROWSING_USE_GDAL
         GdalWrapper::ref().destroy();
 #endif // GLOBEBROWSING_USE_GDAL
@@ -123,4 +107,8 @@ void GlobeBrowsingModule::internalInitialize() {
     FactoryManager::ref().addFactory(std::move(fTileProvider));
 }
 
+globebrowsing::cache::MemoryAwareTileCache* GlobeBrowsingModule::tileCache() {
+    return _tileCache.get();
+}
+
 } // namespace openspace