Implement osg native scenery paging.

[simgear.git] / simgear / scene / tgdb / TileEntry.cxx

diff --git a/simgear/scene/tgdb/TileEntry.cxx b/simgear/scene/tgdb/TileEntry.cxx
index 927829621b46bffa113df80c60169d8c48c32f16..a04b01645d8546914ec43abb3f577c457b995c5f 100644 (file)
--- a/simgear/scene/tgdb/TileEntry.cxx
+++ b/simgear/scene/tgdb/TileEntry.cxx
@@ -49,8 +49,9 @@
 #include <simgear/scene/model/ModelRegistry.hxx>
 #include <simgear/scene/tgdb/apt_signs.hxx>
 #include <simgear/scene/tgdb/obj.hxx>
-#include <simgear/scene/tgdb/SGReaderWriterBTGOptions.hxx>
+#include <simgear/scene/util/SGReaderWriterOptions.hxx>
 
+#include "ReaderWriterSPT.hxx"
 #include "ReaderWriterSTG.hxx"
 #include "TileEntry.hxx"
 
@@ -62,63 +63,21 @@ ModelLoadHelper *TileEntry::_modelLoader=0;
 namespace {
 osgDB::RegisterReaderWriterProxy<ReaderWriterSTG> g_readerWriterSTGProxy;
 ModelRegistryCallbackProxy<LoadOnlyCallback> g_stgCallbackProxy("stg");
-}
-
-namespace
-{
-// Update the timestamp on a tile whenever it is in view.
 
-class TileCullCallback : public osg::NodeCallback
-{
-public:
-    TileCullCallback() : _timeStamp(0) {}
-    TileCullCallback(const TileCullCallback& tc, const osg::CopyOp& copyOp) :
-        NodeCallback(tc, copyOp), _timeStamp(tc._timeStamp)
-    {
-    }
-
-    virtual void operator()(osg::Node* node, osg::NodeVisitor* nv);
-    double getTimeStamp() const { return _timeStamp; }
-    void setTimeStamp(double timeStamp) { _timeStamp = timeStamp; }
-protected:
-    double _timeStamp;
-};
+osgDB::RegisterReaderWriterProxy<ReaderWriterSPT> g_readerWriterSPTProxy;
+ModelRegistryCallbackProxy<LoadOnlyCallback> g_sptCallbackProxy("spt");
 }
 
-void TileCullCallback::operator()(osg::Node* node, osg::NodeVisitor* nv)
-{
-    if (nv->getFrameStamp())
-        _timeStamp = nv->getFrameStamp()->getReferenceTime();
-    traverse(node, nv);
-}
-
-double TileEntry::get_timestamp() const
-{
-    if (_node.valid()) {
-        return (dynamic_cast<TileCullCallback*>(_node->getCullCallback()))
-            ->getTimeStamp();
-    } else
-        return DBL_MAX;
-}
-
-void TileEntry::set_timestamp(double time_ms)
-{
-    if (_node.valid()) {
-        TileCullCallback* cb
-            = dynamic_cast<TileCullCallback*>(_node->getCullCallback());
-        if (cb)
-            cb->setTimeStamp(time_ms);
-    }
-}
 
 // Constructor
 TileEntry::TileEntry ( const SGBucket& b )
     : tile_bucket( b ),
       tileFileName(b.gen_index_str()),
       _node( new osg::LOD ),
-      is_inner_ring(false)
+      _priority(-FLT_MAX),
+      _current_view(false),
+      _time_expired(-1.0)
 {
-    _node->setCullCallback(new TileCullCallback);
     tileFileName += ".stg";
     _node->setName(tileFileName);
     // Give a default LOD range so that traversals that traverse
@@ -127,6 +86,20 @@ TileEntry::TileEntry ( const SGBucket& b )
     _node->setRange(0, 0.0, 10000.0);
 }
 
+TileEntry::TileEntry( const TileEntry& t )
+: tile_bucket( t.tile_bucket ),
+  tileFileName(t.tileFileName),
+  _node( new osg::LOD ),
+  _priority(t._priority),
+  _current_view(t._current_view),
+  _time_expired(t._time_expired)
+{
+    _node->setName(tileFileName);
+    // Give a default LOD range so that traversals that traverse
+    // active children (like the groundcache lookup) will work before
+    // tile manager has had a chance to update this node.
+    _node->setRange(0, 0.0, 10000.0);
+}
 
 // Destructor
 TileEntry::~TileEntry ()
@@ -319,27 +292,26 @@ TileEntry::loadTileByFileName(const string& fileName,
         }
     }
 
-    const SGReaderWriterBTGOptions* btgOpt;
-    btgOpt = dynamic_cast<const SGReaderWriterBTGOptions *>(options);
-    osg::ref_ptr<SGReaderWriterBTGOptions> opt;
+    const SGReaderWriterOptions* btgOpt;
+    btgOpt = dynamic_cast<const SGReaderWriterOptions*>(options);
+    osg::ref_ptr<SGReaderWriterOptions> opt;
     if (btgOpt)
-        opt = new SGReaderWriterBTGOptions(*btgOpt);
+        opt = new SGReaderWriterOptions(*btgOpt);
     else
-        opt = new SGReaderWriterBTGOptions;
+        opt = new SGReaderWriterOptions;
 
     // obj_load() will generate ground lighting for us ...
     osg::Group* new_tile = new osg::Group;
 
     if (found_tile_base) {
         // load tile if found ...
-        opt->setCalcLights(true);
-        obj_load( object_base.str(), new_tile, true, opt);
+        obj_load( object_base.str(), new_tile, true, opt.get());
 
     } else {
         // ... or generate an ocean tile on the fly
         SG_LOG(SG_TERRAIN, SG_INFO, "  Generating ocean tile");
         if ( !SGGenTile( path_list[0], tile_bucket,
-                        opt->getMatlib(), new_tile ) ) {
+                        opt->getMaterialLib(), new_tile ) ) {
             SG_LOG( SG_TERRAIN, SG_ALERT,
                     "Warning: failed to generate ocean tile!" );
         }
@@ -353,8 +325,7 @@ TileEntry::loadTileByFileName(const string& fileName,
         if (obj->type == OBJECT) {
             SGPath custom_path = obj->path;
             custom_path.append( obj->name );
-            opt->setCalcLights(true);
-            obj_load( custom_path.str(), new_tile, false, opt);
+            obj_load( custom_path.str(), new_tile, false, opt.get());
 
         } else if (obj->type == OBJECT_SHARED || obj->type == OBJECT_STATIC) {
             // object loading is deferred to main render thread,
@@ -397,9 +368,9 @@ TileEntry::loadTileByFileName(const string& fileName,
 
             osg::Node *custom_obj = 0;
             if (obj->type == OBJECT_SIGN)
-                custom_obj = SGMakeSign(opt->getMatlib(), custom_path.str(), obj->name);
+                custom_obj = SGMakeSign(opt->getMaterialLib(), custom_path.str(), obj->name);
             else
-                custom_obj = SGMakeRunwaySign(opt->getMatlib(), custom_path.str(), obj->name);
+                custom_obj = SGMakeRunwaySign(opt->getMaterialLib(), custom_path.str(), obj->name);
 
             // wire the pieces together
             if ( custom_obj != NULL ) {
@@ -447,3 +418,19 @@ TileEntry::removeFromSceneGraph()
     }
 }
 
+void
+TileEntry::refresh()
+{
+    osg::Group *parent = NULL;
+    // find the nodes branch parent
+    if ( _node->getNumParents() > 0 ) {
+        // find the first parent (should only be one)
+        parent = _node->getParent( 0 ) ;
+        if( parent ) {
+            parent->removeChild( _node.get() );
+        }
+    }
+    _node = new osg::LOD;
+    if (parent)
+        parent->addChild(_node.get());
+}