]> git.mxchange.org Git - flightgear.git/blobdiff - src/Scenery/tilemgr.cxx
Boris Koenig:
[flightgear.git] / src / Scenery / tilemgr.cxx
index 371b45eafac559bb72fc1859b86c6c3cc9f83af1..6730eaea211dee6863007d2e8aab7a975bde6995 100644 (file)
@@ -61,8 +61,7 @@ bool FGTileMgr::tile_filter = true;
 FGTileMgr::FGTileMgr():
     state( Start ),
     current_tile( NULL ),
-    vis( 16000 ),
-    counter_hack(0)
+    vis( 16000 )
 {
 }
 
@@ -262,6 +261,15 @@ void FGTileMgr::initialize_queue()
 #endif
 }
 
+/**
+ * return current status of queues
+ *
+ */
+
+bool FGTileMgr::all_queues_empty() {
+       return attach_queue.empty() && model_queue.empty();
+}
+
 
 /**
  * Update the various queues maintained by the tilemagr (private
@@ -271,47 +279,57 @@ void FGTileMgr::update_queues()
 {
     // load the next model in the load queue.  Currently this must
     // happen in the render thread because model loading can trigger
-    // texture loading which involves use of the opengl api.
+    // texture loading which involves use of the opengl api.  Skip any
+    // models belonging to not loaded tiles (i.e. the tile was removed
+    // before we were able to load some of the associated models.)
     if ( !model_queue.empty() ) {
-        // cout << "loading next model ..." << endl;
-        // load the next tile in the queue
+        bool processed_one = false;
+
+        while ( model_queue.size() > 200 || processed_one == false ) {
+            processed_one = true;
+
+            if ( model_queue.size() > 200 ) {
+                SG_LOG( SG_TERRAIN, SG_INFO,
+                        "Alert: catching up on model load queue" );
+            }
+
+            // cout << "loading next model ..." << endl;
+            // load the next tile in the queue
 #if defined(ENABLE_THREADS) && ENABLE_THREADS
-        FGDeferredModel* dm = model_queue.pop();
+            FGDeferredModel* dm = model_queue.pop();
 #else
-        FGDeferredModel* dm = model_queue.front();
-        model_queue.pop();
+            FGDeferredModel* dm = model_queue.front();
+            model_queue.pop();
 #endif
 
-        ssgTexturePath( (char *)(dm->get_texture_path().c_str()) );
-        try
-        {
-            ssgEntity *obj_model =
-                globals->get_model_lib()->load_model( ".",
-                                                      dm->get_model_path(),
-                                                      globals->get_props(),
-                                                      globals->get_sim_time_sec() );
-            if ( obj_model != NULL ) {
-                dm->get_obj_trans()->addKid( obj_model );
+            // only load the model if the tile still exists in the
+            // tile cache
+            FGTileEntry *t = tile_cache.get_tile( dm->get_bucket() );
+            if ( t != NULL ) {
+                ssgTexturePath( (char *)(dm->get_texture_path().c_str()) );
+                try {
+                    ssgEntity *obj_model =
+                        globals->get_model_lib()->load_model( ".",
+                                                  dm->get_model_path(),
+                                                  globals->get_props(),
+                                                  globals->get_sim_time_sec() );
+                    if ( obj_model != NULL ) {
+                        dm->get_obj_trans()->addKid( obj_model );
+                    }
+                } catch (const sg_exception& exc) {
+                    SG_LOG( SG_ALL, SG_ALERT, exc.getMessage() );
+                }
+                
+                dm->get_tile()->dec_pending_models();
             }
+            delete dm;
         }
-        catch (const sg_exception& exc)
-        {
-            SG_LOG( SG_ALL, SG_ALERT, exc.getMessage() );
-        }
-
-        dm->get_tile()->dec_pending_models();
-        delete dm;
     }
     
     // cout << "current elevation (ssg) == " << scenery.get_cur_elev() << endl;
 
-    // activate loader thread one out of every 5 frames
-    if ( counter_hack == 0 ) {
-        // Notify the tile loader that it can load another tile
-        loader.update();
-    } else {
-        counter_hack = (counter_hack + 1) % 5;
-    }
+    // Notify the tile loader that it can load another tile
+    loader.update();
 
     if ( !attach_queue.empty() ) {
 #if defined(ENABLE_THREADS) && ENABLE_THREADS
@@ -330,26 +348,26 @@ void FGTileMgr::update_queues()
 
     if ( !delete_queue.empty() ) {
         // cout << "delete queue = " << delete_queue.size() << endl;
+        bool processed_one = false;
 
-        while ( delete_queue.size() > 30 ) {
-            // uh oh, delete queue is blowing up, we aren't clearing
-            // it fast enough.  Let's just panic, well not panic, but
-            // get real serious and agressively free up some tiles so
-            // we don't explode our memory usage.
+        while ( delete_queue.size() > 30 || processed_one == false ) {
+            processed_one = true;
 
-            SG_LOG( SG_TERRAIN, SG_ALERT,
-                    "Alert: catching up on tile delete queue" );
+            if ( delete_queue.size() > 30 ) {
+                // uh oh, delete queue is blowing up, we aren't clearing
+                // it fast enough.  Let's just panic, well not panic, but
+                // get real serious and agressively free up some tiles so
+                // we don't explode our memory usage.
 
-            FGTileEntry* e = delete_queue.front();
-            while ( !e->free_tile() );
-            delete_queue.pop();
-            delete e;
-        }
+                SG_LOG( SG_TERRAIN, SG_ALERT,
+                        "Alert: catching up on tile delete queue" );
+            }
 
-        FGTileEntry* e = delete_queue.front();
-        if ( e->free_tile() ) {
-            delete_queue.pop();
-            delete e;
+            FGTileEntry* e = delete_queue.front();
+            if ( e->free_tile() ) {
+                delete_queue.pop();
+                delete e;
+            }
         }
     }
 }