Enable getting a default tile from TileProviders. Used e.g. when no tiles are in memory

modules/globebrowsing/chunk/chunkrenderer.cpp

@@ -218,9 +218,9 @@ namespace openspace {
                 // Get the texture that should be used for rendering
                 TileAndTransform tileAndTransform = TileSelector::getHighestResolutionTile(tileProvider, chunkIndex);
                 if (tileAndTransform.tile.status == Tile::Status::Unavailable) {
-                    // don't render if no tile was available
-                    programObject->deactivate();
-                    return nullptr;
+                    tileAndTransform.tile = tileProvider->getDefaultTile();
+                    tileAndTransform.uvTransform.uvOffset = { 0, 0 };
+                    tileAndTransform.uvTransform.uvScale = { 1, 1 };
                 }
 
                 activateTileAndSetTileUniforms(

modules/globebrowsing/shaders/globalchunkedlodpatch_fs.glsl

@@ -157,6 +157,7 @@ Fragment getFragment() {
 
 	frag.depth = fs_position.w;
 
+	
 	return frag;
 }
 

modules/globebrowsing/tile/temporaltileprovider.cpp

@@ -109,48 +109,43 @@ namespace openspace {
     }
 
     TileDepthTransform TemporalTileProvider::depthTransform() {
-        if (_currentTileProvider == nullptr) {
-            LDEBUG("Warning: had to call update from depthTransform()");
-            update();
-        }
-
+        ensureUpdated();
         return _currentTileProvider->depthTransform();
     }
 
     Tile::Status TemporalTileProvider::getTileStatus(const ChunkIndex& chunkIndex) {
-        if (_currentTileProvider == nullptr) {
-            LDEBUG("Warning: had to call update from getTileStatus()");
-            update();
-        }
-
+        ensureUpdated();
         return _currentTileProvider->getTileStatus(chunkIndex);
     }
 
     Tile TemporalTileProvider::getTile(const ChunkIndex& chunkIndex) {
-        if (_currentTileProvider == nullptr) {
-            LDEBUG("Warning: had to call update from getTile()");
-            update();
-        }
-
+        ensureUpdated();
         return _currentTileProvider->getTile(chunkIndex);
     }
 
+    Tile TemporalTileProvider::getDefaultTile() {
+        ensureUpdated();
+        return _currentTileProvider->getDefaultTile();
+    }
 
 
+    int TemporalTileProvider::maxLevel() {
+        ensureUpdated();
+        return _currentTileProvider->maxLevel();
+    }
+
+    void TemporalTileProvider::ensureUpdated() {
+        if (_currentTileProvider == nullptr) {
+            LDEBUG("Warning: update was done lazily");
+            update();
+        }
+    }
+
     void TemporalTileProvider::update() {
         _currentTileProvider = getTileProvider();
         _currentTileProvider->update();
     }
 
-    int TemporalTileProvider::maxLevel() {
-        if (_currentTileProvider == nullptr) {
-            LDEBUG("Warning: had to call update from getAsyncTileReader()");
-            update();
-        }
-
-        return _currentTileProvider->maxLevel();
-    }
-
 
     std::shared_ptr<TileProvider> TemporalTileProvider::getTileProvider(Time t) {
         Time tCopy(t);

modules/globebrowsing/tile/temporaltileprovider.h

@@ -121,6 +121,7 @@ namespace openspace {
 
         // These methods implements TileProvider
         virtual Tile getTile(const ChunkIndex& chunkIndex);
+        virtual Tile getDefaultTile();
         virtual Tile::Status getTileStatus(const ChunkIndex& chunkIndex);
         virtual TileDepthTransform depthTransform();
         virtual void update();
@@ -148,6 +149,8 @@ namespace openspace {
         std::string consumeTemporalMetaData(const std::string &xml);
         std::string getXMLValue(CPLXMLNode*, const std::string& key, const std::string& defaultVal);
 
+        void ensureUpdated();
+
         //////////////////////////////////////////////////////////////////////////////////
         //                                Members variables                             //
         //////////////////////////////////////////////////////////////////////////////////

modules/globebrowsing/tile/tiledataset.h

@@ -116,9 +116,6 @@ namespace openspace {
         const static glm::ivec2 tilePixelSizeDifference;
         const static PixelRegion padding; // same as the two above
 
-        
-
-
 
     private:
 

modules/globebrowsing/tile/tileprovider.cpp

@@ -65,6 +65,11 @@ namespace openspace {
         return _tile;
     }
 
+    Tile SingleImagePrivoder::getDefaultTile() {
+        return _tile;
+    }
+
+
     Tile::Status SingleImagePrivoder::getTileStatus(const ChunkIndex& index) {
         return _tile.status;
     }
@@ -99,7 +104,7 @@ namespace openspace {
         , _framesUntilRequestFlush(framesUntilFlushRequestQueue)
         , _framesSinceLastRequestFlush(0)
     {
-        
+        _defaultTile = createTile(_asyncTextureDataProvider->getTextureDataProvider()->defaultTileData());
     }
 
 
@@ -140,10 +145,17 @@ namespace openspace {
         return tile;
     }
 
+    Tile CachingTileProvider::getDefaultTile() {
+        return _defaultTile;
+    }
+
+
     void CachingTileProvider::initTexturesFromLoadedData() {
         while (_asyncTextureDataProvider->hasLoadedTextureData()) {
             std::shared_ptr<TileIOResult> tileIOResult = _asyncTextureDataProvider->nextTileIOResult();
-            initializeAndAddToCache(tileIOResult);
+            ChunkHashKey key = tileIOResult->chunkIndex.hashKey();
+            Tile tile = createTile(tileIOResult);
+            _tileCache->put(key, tile);
         }
     }
 
@@ -184,7 +196,7 @@ namespace openspace {
     }
 
 
-    void CachingTileProvider::initializeAndAddToCache(std::shared_ptr<TileIOResult> tileIOResult) {
+    Tile CachingTileProvider::createTile(std::shared_ptr<TileIOResult> tileIOResult) {
         ChunkHashKey key = tileIOResult->chunkIndex.hashKey();
         TileDataLayout dataLayout = _asyncTextureDataProvider->getTextureDataProvider()->getDataLayout();
         Texture* texturePtr = new Texture(
@@ -209,7 +221,7 @@ namespace openspace {
             tileIOResult->error == CE_None ? Tile::Status::OK : Tile::Status::IOError
         };
 
-        _tileCache->put(key, tile);
+        return tile;
     }
 
 

modules/globebrowsing/tile/tileprovider.h

@@ -68,6 +68,7 @@ namespace openspace {
         virtual ~TileProvider() { }
 
         virtual Tile getTile(const ChunkIndex& chunkIndex) = 0;
+        virtual Tile getDefaultTile() = 0;
         virtual Tile::Status getTileStatus(const ChunkIndex& index) = 0;
         virtual TileDepthTransform depthTransform() = 0;
         virtual void update() = 0;
@@ -84,6 +85,7 @@ namespace openspace {
         virtual ~SingleImagePrivoder() { }
 
         virtual Tile getTile(const ChunkIndex& chunkIndex);
+        virtual Tile getDefaultTile();
         virtual Tile::Status getTileStatus(const ChunkIndex& index);
         virtual TileDepthTransform depthTransform();
         virtual void update();
@@ -110,6 +112,7 @@ namespace openspace {
         virtual ~CachingTileProvider();
         
         virtual Tile getTile(const ChunkIndex& chunkIndex);
+        virtual Tile getDefaultTile();
         virtual Tile::Status getTileStatus(const ChunkIndex& index);
         virtual TileDepthTransform depthTransform();
         virtual void update();
@@ -130,7 +133,8 @@ namespace openspace {
         /**
             Creates an OpenGL texture and pushes the data to the GPU.
         */
-        void initializeAndAddToCache(std::shared_ptr<TileIOResult> uninitedTexture);
+
+        Tile createTile(std::shared_ptr<TileIOResult> res);
 
         void clearRequestQueue();
 
@@ -143,6 +147,7 @@ namespace openspace {
         //////////////////////////////////////////////////////////////////////////////////
 
         std::shared_ptr<TileCache> _tileCache;
+        Tile _defaultTile;
 
         int _framesSinceLastRequestFlush;
         int _framesUntilRequestFlush;

modules/globebrowsing/tile/tileselector.cpp

@@ -66,7 +66,8 @@ namespace openspace {
             }
             else return { tile, uvTransform };
         }
-        return {Tile::TileUnavailable, uvTransform};
+        
+        return{ Tile::TileUnavailable, uvTransform };
     }
 
     void TileSelector::ascendToParent(ChunkIndex& chunkIndex, TileUvTransform& uv) {