FGFS-4.1/simgear
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

scenery: TileEntry and TileCache have moved back to flightgear.

Browse Source
This commit is contained in:
Mathias Froehlich
2012-03-15 20:43:31 +01:00
parent 43fceaf3a4
commit b5fb829468
5 changed files with 0 additions and 659 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
simgear/scene/tgdb/CMakeLists.txt
View File

@@ -14,8 +14,6 @@ set(HEADERS
SGVasiDrawable.hxx
SGVertexArrayBin.hxx
ShaderGeometry.hxx
TileCache.hxx
TileEntry.hxx
TreeBin.hxx
apt_signs.hxx
obj.hxx
@@ -31,8 +29,6 @@ set(SOURCES
SGReaderWriterBTG.cxx
SGVasiDrawable.cxx
ShaderGeometry.cxx
TileCache.cxx
TileEntry.cxx
TreeBin.cxx
apt_signs.cxx
obj.cxx

221
simgear/scene/tgdb/TileCache.cxx
View File

@@ -1,221 +0,0 @@
// TileCache.cxx -- routines to handle scenery tile caching
//
// Written by Curtis Olson, started December 2000.
//
// Copyright (C) 2000 Curtis L. Olson - http://www.flightgear.org/~curt
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation; either version 2 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//
// $Id$
#ifdef HAVE_CONFIG_H
# include <simgear_config.h>
#endif
#include <simgear/bucket/newbucket.hxx>
#include <simgear/debug/logstream.hxx>
#include <simgear/misc/sg_path.hxx>
#include "TileEntry.hxx"
#include "TileCache.hxx"
using simgear::TileEntry;
using simgear::TileCache;
TileCache::TileCache( void ) :
max_cache_size(100), current_time(0.0)
{
tile_cache.clear();
}
TileCache::~TileCache( void ) {
clear_cache();
}
// Free a tile cache entry
void TileCache::entry_free( long tile_index ) {
SG_LOG( SG_TERRAIN, SG_DEBUG, "FREEING CACHE ENTRY = " << tile_index );
TileEntry *tile = tile_cache[tile_index];
tile->removeFromSceneGraph();
tile_cache.erase( tile_index );
delete tile;
}
// Initialize the tile cache subsystem
void TileCache::init( void ) {
SG_LOG( SG_TERRAIN, SG_INFO, "Initializing the tile cache." );
SG_LOG( SG_TERRAIN, SG_INFO, " max cache size = "
<< max_cache_size );
SG_LOG( SG_TERRAIN, SG_INFO, " current cache size = "
<< tile_cache.size() );
clear_cache();
SG_LOG( SG_TERRAIN, SG_INFO, " done with init()" );
}
// Search for the specified "bucket" in the cache
bool TileCache::exists( const SGBucket& b ) const {
long tile_index = b.gen_index();
const_tile_map_iterator it = tile_cache.find( tile_index );
return ( it != tile_cache.end() );
}
// Return the index of a tile to be dropped from the cache, return -1 if
// nothing available to be removed.
long TileCache::get_drop_tile() {
long min_index = -1;
double min_time = DBL_MAX;
float priority = FLT_MAX;
tile_map_iterator current = tile_cache.begin();
tile_map_iterator end = tile_cache.end();
for ( ; current != end; ++current ) {
long index = current->first;
TileEntry *e = current->second;
if (( !e->is_current_view() )&&
( e->is_expired(current_time) ))
{
if (e->is_expired(current_time - 1.0)&&
!e->is_loaded())
{
/* Immediately drop "empty" tiles which are no longer used/requested, and were last requested > 1 second ago...
* Allow a 1 second timeout since an empty tiles may just be loaded...
*/
SG_LOG( SG_TERRAIN, SG_DEBUG, " dropping an unused and empty tile");
break;
}
if (( e->get_time_expired() < min_time )||
(( e->get_time_expired() == min_time)&&
( priority > e->get_priority())))
{
// drop oldest tile with lowest priority
min_time = e->get_time_expired();
priority = e->get_priority();
min_index = index;
}
}
}
SG_LOG( SG_TERRAIN, SG_DEBUG, " index = " << min_index );
SG_LOG( SG_TERRAIN, SG_DEBUG, " min_time = " << min_time );
return min_index;
}
// Clear all flags indicating tiles belonging to the current view
void TileCache::clear_current_view()
{
tile_map_iterator current = tile_cache.begin();
tile_map_iterator end = tile_cache.end();
for ( ; current != end; ++current ) {
TileEntry *e = current->second;
if (e->is_current_view())
{
// update expiry time for tiles belonging to most recent position
e->update_time_expired( current_time );
e->set_current_view( false );
}
}
}
// Clear a cache entry, note that the cache only holds pointers
// and this does not free the object which is pointed to.
void TileCache::clear_entry( long tile_index ) {
tile_cache.erase( tile_index );
}
// Clear all completely loaded tiles (ignores partially loaded tiles)
void TileCache::clear_cache() {
std::vector<long> indexList;
tile_map_iterator current = tile_cache.begin();
tile_map_iterator end = tile_cache.end();
for ( ; current != end; ++current ) {
long index = current->first;
SG_LOG( SG_TERRAIN, SG_DEBUG, "clearing " << index );
TileEntry *e = current->second;
if ( e->is_loaded() ) {
e->tile_bucket.make_bad();
// entry_free modifies tile_cache, so store index and call entry_free() later;
indexList.push_back( index);
}
}
for (unsigned int it = 0; it < indexList.size(); it++) {
entry_free( indexList[ it]);
}
}
/**
* Create a new tile and schedule it for loading.
*/
bool TileCache::insert_tile( TileEntry *e ) {
// register tile in the cache
long tile_index = e->get_tile_bucket().gen_index();
tile_cache[tile_index] = e;
e->update_time_expired(current_time);
return true;
}
/**
* Reloads a tile when it's already in memory.
*/
void TileCache::refresh_tile(long tile_index)
{
const_tile_map_iterator it = tile_cache.find( tile_index );
if ( it == tile_cache.end() )
return;
SG_LOG( SG_TERRAIN, SG_DEBUG, "REFRESHING CACHE ENTRY = " << tile_index );
if (it->second)
it->second->refresh();
}
// update tile's priority and expiry time according to current request
void TileCache::request_tile(TileEntry* t,float priority,bool current_view,double request_time)
{
if ((!current_view)&&(request_time<=0.0))
return;
// update priority when higher - or old request has expired
if ((t->is_expired(current_time))||
(priority > t->get_priority()))
{
t->set_priority( priority );
}
if (current_view)
{
t->update_time_expired( current_time );
t->set_current_view( true );
}
else
{
t->update_time_expired( current_time+request_time );
}
}

138
simgear/scene/tgdb/TileCache.hxx
View File

@@ -1,138 +0,0 @@
// TileCache.hxx -- routines to handle scenery tile caching
//
// Written by Curtis Olson, started December 2000.
//
// Copyright (C) 2000 Curtis L. Olson - http://www.flightgear.org/~curt
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation; either version 2 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//
// $Id$
#ifndef _TILECACHE_HXX
#define _TILECACHE_HXX
#include <map>
#include <simgear/bucket/newbucket.hxx>
#include <simgear/scene/tgdb/TileEntry.hxx>
using std::map;
namespace simgear {
// A class to store and manage a pile of tiles
class TileCache {
public:
typedef map < long, simgear::TileEntry * > tile_map;
typedef tile_map::iterator tile_map_iterator;
typedef tile_map::const_iterator const_tile_map_iterator;
private:
// cache storage space
tile_map tile_cache;
// maximum cache size
int max_cache_size;
// pointers to allow an external linear traversal of cache entries
tile_map_iterator current;
double current_time;
// Free a tile cache entry
void entry_free( long cache_index );
public:
tile_map_iterator begin() { return tile_cache.begin(); }
tile_map_iterator end() { return tile_cache.end(); }
const_tile_map_iterator begin() const { return tile_cache.begin(); }
const_tile_map_iterator end() const { return tile_cache.end(); }
// Constructor
TileCache();
// Destructor
~TileCache();
// Initialize the tile cache subsystem
void init( void );
// Check if the specified "bucket" exists in the cache
bool exists( const SGBucket& b ) const;
// Return the index of a tile to be dropped from the cache, return -1 if
// nothing available to be removed.
long get_drop_tile();
// Clear all flags indicating tiles belonging to the current view
void clear_current_view();
// Clear a cache entry, note that the cache only holds pointers
// and this does not free the object which is pointed to.
void clear_entry( long cache_entry );
// Refresh/reload a tile when it's already in memory.
void refresh_tile(long tile_index);
// Clear all completely loaded tiles (ignores partially loaded tiles)
void clear_cache();
// Return a pointer to the specified tile cache entry
inline simgear::TileEntry *get_tile( const long tile_index ) const {
const_tile_map_iterator it = tile_cache.find( tile_index );
if ( it != tile_cache.end() ) {
return it->second;
} else {
return NULL;
}
}
// Return a pointer to the specified tile cache entry
inline simgear::TileEntry *get_tile( const SGBucket& b ) const {
return get_tile( b.gen_index() );
}
// Return the cache size
inline size_t get_size() const { return tile_cache.size(); }
// External linear traversal of cache
inline void reset_traversal() { current = tile_cache.begin(); }
inline bool at_end() { return current == tile_cache.end(); }
inline simgear::TileEntry *get_current() const {
// cout << "index = " << current->first << endl;
return current->second;
}
inline void next() { ++current; }
inline int get_max_cache_size() const { return max_cache_size; }
inline void set_max_cache_size( int m ) { max_cache_size = m; }
/**
* Create a new tile and enqueue it for loading.
* @param b
* @return success/failure
*/
bool insert_tile( simgear::TileEntry* e );
void set_current_time(double val) { current_time = val; }
double get_current_time() const { return current_time; }
// update tile's priority and expiry time according to current request
void request_tile(TileEntry* t,float priority,bool current_view,double requesttime);
};
}
#endif // _TILECACHE_HXX

138
simgear/scene/tgdb/TileEntry.cxx
View File

@@ -1,138 +0,0 @@
// tileentry.cxx -- routines to handle a scenery tile
//
// Written by Curtis Olson, started May 1998.
//
// Copyright (C) 1998 - 2001 Curtis L. Olson - http://www.flightgear.org/~curt
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation; either version 2 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#ifdef HAVE_CONFIG_H
# include <simgear_config.h>
#endif
#include <simgear/compiler.h>
#include <string>
#include <sstream>
#include <istream>
#include <osg/LOD>
#include <simgear/bucket/newbucket.hxx>
#include <simgear/debug/logstream.hxx>
#include "TileEntry.hxx"
using std::string;
using namespace simgear;
// Constructor
TileEntry::TileEntry ( const SGBucket& b )
: tile_bucket( b ),
tileFileName(b.gen_index_str()),
_node( new osg::LOD ),
_priority(-FLT_MAX),
_current_view(false),
_time_expired(-1.0)
{
tileFileName += ".stg";
_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);
}
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 ()
{
}
// Update the ssg transform node for this tile so it can be
// properly drawn relative to our (0,0,0) point
void TileEntry::prep_ssg_node(float vis) {
if (!is_loaded())
return;
// visibility can change from frame to frame so we update the
// range selector cutoff's each time.
float bounding_radius = _node->getChild(0)->getBound().radius();
_node->setRange( 0, 0, vis + bounding_radius );
}
void
TileEntry::addToSceneGraph(osg::Group *terrain_branch)
{
terrain_branch->addChild( _node.get() );
SG_LOG( SG_TERRAIN, SG_DEBUG,
"connected a tile into scene graph. _node = "
<< _node.get() );
SG_LOG( SG_TERRAIN, SG_DEBUG, "num parents now = "
<< _node->getNumParents() );
}
void
TileEntry::removeFromSceneGraph()
{
SG_LOG( SG_TERRAIN, SG_DEBUG, "disconnecting TileEntry nodes" );
if (! is_loaded()) {
SG_LOG( SG_TERRAIN, SG_DEBUG, "removing a not-fully loaded tile!" );
} else {
SG_LOG( SG_TERRAIN, SG_DEBUG, "removing a fully loaded tile! _node = " << _node.get() );
}
// find the nodes branch parent
if ( _node->getNumParents() > 0 ) {
// find the first parent (should only be one)
osg::Group *parent = _node->getParent( 0 ) ;
if( parent ) {
parent->removeChild( _node.get() );
}
}
}
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());
}

158
simgear/scene/tgdb/TileEntry.hxx
View File

@@ -1,158 +0,0 @@
// tileentry.hxx -- routines to handle an individual scenery tile
//
// Written by Curtis Olson, started May 1998.
//
// Copyright (C) 1998 - 2001 Curtis L. Olson - http://www.flightgear.org/~curt
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation; either version 2 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//
// $Id$
#ifndef _TILEENTRY_HXX
#define _TILEENTRY_HXX
#ifndef __cplusplus
# error This library requires C++
#endif
#include <simgear/compiler.h>
#include <vector>
#include <string>
#include <simgear/bucket/newbucket.hxx>
#include <simgear/misc/sg_path.hxx>
#include <osg/ref_ptr>
#include <osgDB/ReaderWriter>
#include <osg/Group>
#include <osg/LOD>
#if defined( sgi )
#include <strings.h>
#endif
namespace simgear {
/**
* A class to encapsulate everything we need to know about a scenery tile.
*/
class TileEntry {
public:
// this tile's official location in the world
SGBucket tile_bucket;
std::string tileFileName;
private:
// pointer to ssg range selector for this tile
osg::ref_ptr<osg::LOD> _node;
// Reference to DatabaseRequest object set and used by the
// osgDB::DatabasePager.
osg::ref_ptr<osg::Referenced> _databaseRequest;
/**
* This value is used by the tile scheduler/loader to load tiles
* in a useful sequence. The priority is set to reflect the tiles
* distance from the center, so all tiles are loaded in an innermost
* to outermost sequence.
*/
float _priority;
/** Flag indicating if tile belongs to current view. */
bool _current_view;
/** Time when tile expires. */
double _time_expired;
public:
// Constructor
TileEntry( const SGBucket& b );
TileEntry( const TileEntry& t );
// Destructor
~TileEntry();
// Update the ssg transform node for this tile so it can be
// properly drawn relative to our (0,0,0) point
void prep_ssg_node(float vis);
/**
* Transition to OSG database pager
*/
static osg::Node* loadTileByFileName(const std::string& index_str,
const osgDB::Options*);
/**
* Return true if the tile entry is loaded, otherwise return false
* indicating that the loading thread is still working on this.
*/
inline bool is_loaded() const
{
return _node->getNumChildren() > 0;
}
/**
* Return the "bucket" for this tile
*/
inline const SGBucket& get_tile_bucket() const { return tile_bucket; }
/**
* Add terrain mesh and ground lighting to scene graph.
*/
void addToSceneGraph( osg::Group *terrain_branch);
/**
* disconnect terrain mesh and ground lighting nodes from scene
* graph for this tile.
*/
void removeFromSceneGraph();
/**
* Refresh a tile, reload the node from disk.
*/
void refresh();
/**
* return the scenegraph node for the terrain
*/
osg::LOD *getNode() const { return _node.get(); }
inline double get_time_expired() const { return _time_expired; }
inline void update_time_expired( double time_expired ) { if (_time_expired<time_expired) _time_expired = time_expired; }
inline void set_priority(float priority) { _priority=priority; }
inline float get_priority() const { return _priority; }
inline void set_current_view(bool current_view) { _current_view = current_view; }
inline bool is_current_view() const { return _current_view; }
/**
* Return true if the tile entry is still needed, otherwise return false
* indicating that the tile is no longer in active use.
*/
inline bool is_expired(double current_time) const { return (_current_view) ? false : (current_time > _time_expired); }
// Get the ref_ptr to the DatabaseRequest object, in order to pass
// this to the pager.
osg::ref_ptr<osg::Referenced>& getDatabaseRequest()
{
return _databaseRequest;
}
};
}
#endif // _TILEENTRY_HXX