fly/flightgear
1
0
Fork 0
Code Activity

Added copyright to SceneryPager. Removed FGTileLoader

Browse source
This commit is contained in:
timoore 2007-12-15 06:01:24 +00:00
parent 7ca1a60e91
commit f105f47e91
4 changed files with 20 additions and 370 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
projects/VC7.1/FlightGear.vcproj
View file

@ -2128,10 +2128,10 @@
Name="Lib_Scenery"
Filter="">
<File
RelativePath="..\..\src\Scenery\FGTileLoader.cxx">
RelativePath="..\..\src\Scenery\SceneryPager.cxx">
</File>
<File
RelativePath="..\..\src\Scenery\FGTileLoader.hxx">
RelativePath="..\..\src\Scenery\SceneryPager.hxx">
</File>
<File
RelativePath="..\..\src\Scenery\newcache.cxx">

201
src/Scenery/FGTileLoader.cxx
View file

@ -1,201 +0,0 @@
// FGTileLoader - Queue scenery tiles for loading.
//
// Written by Bernie Bright, started March 2001.
//
// Copyright (C) 2001 Bernard Bright - bbright@bigpond.net.au
//
// 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 <config.h>
#endif
#include <simgear/compiler.h>
#include <simgear/structure/exception.hxx>
#include <Main/globals.hxx>
#include "FGTileLoader.hxx"
#include "tileentry.hxx"
#include "tilemgr.hxx"
/**
*
*/
FGTileLoader::FGTileLoader()
{
#if defined(ENABLE_THREADS)
// Create and start the loader threads.
for (int i = 0; i < MAX_THREADS; ++i)
{
threads[i] = new LoaderThread(this);
threads[i]->start( 1 );
}
#endif // ENABLE_THREADS
}
/**
* Terminate all threads.
*/
FGTileLoader::~FGTileLoader()
{
#if defined(ENABLE_THREADS)
// Wake up its time to die.
// queue_cond.broadcast();
for (int i = 0; i < MAX_THREADS; ++i)
{
threads[i]->cancel();
threads[i]->join();
}
#endif // ENABLE_THREADS
}
#if 0 // we don't ever want to do this I don't think
/**
*
*/
void FGTileLoader::reinit() {
while ( !tile_load_queue.empty() ) {
tile_load_queue.pop();
}
}
#endif
/**
*
*/
void
FGTileLoader::add( FGTileEntry* tile )
{
/**
* Initialise tile_path here and not in ctor to avoid problems
* with the initialisation order of global objects.
*/
static bool beenhere = false;
if (!beenhere) {
tile_path = globals->get_fg_scenery();
if (!tile_path.size())
throw sg_throwable(string("No valid scenery path defined!"));
beenhere = true;
}
tile_load_queue.push( tile );
}
#ifdef WISH_PLIB_WAS_THREADED // but it isn't
/**
*
*/
void
FGTileLoader::remove( FGTileEntry* tile )
{
tile_free_queue.push( tile );
}
#endif
/**
*
*/
void
FGTileLoader::update()
{
#if defined(ENABLE_THREADS)
// send a signal to the pager thread that it is allowed to load
// another tile
mutex.lock();
frame_cond.signal();
mutex.unlock();
#else
if ( !tile_load_queue.empty() ) {
// cout << "loading next tile ..." << endl;
// load the next tile in the queue
FGTileEntry* tile = tile_load_queue.front();
tile_load_queue.pop();
tile->load( tile_path, true );
FGTileMgr::ready_to_attach( tile );
}
#ifdef WISH_PLIB_WAS_THREADED // but it isn't
if ( !tile_free_queue.empty() ) {
// cout << "freeing next tile ..." << endl;
// free the next tile in the queue
FGTileEntry* tile = tile_free_queue.front();
tile_free_queue.pop();
tile->free_tile();
delete tile;
}
#endif
#endif // ENABLE_THREADS
}
#if defined(ENABLE_THREADS)
/**
* Ensure mutex is unlocked.
*/
void
cleanup_handler( void* arg )
{
FGTileLoader* loader = (FGTileLoader*) arg;
loader->mutex.unlock();
}
/**
*
*/
void
FGTileLoader::LoaderThread::run()
{
pthread_cleanup_push( cleanup_handler, loader );
while ( true ) {
// Wait for a load request to be placed in the queue.
FGTileEntry* tile = loader->tile_load_queue.pop();
// Wait for the next frame signal before we load a tile from the queue
loader->mutex.lock();
loader->frame_cond.wait( loader->mutex );
loader->mutex.unlock();
set_cancel( SGThread::CANCEL_DISABLE );
tile->load( loader->tile_path, true );
set_cancel( SGThread::CANCEL_DEFERRED );
FGTileMgr::ready_to_attach( tile );
#ifdef WISH_PLIB_WAS_THREADED // but it isn't
// Handle and pending removals
while ( !loader->tile_free_queue.empty() ) {
// cout << "freeing next tile ..." << endl;
// free the next tile in the queue
FGTileEntry* tile = loader->tile_free_queue.pop();
tile->free_tile();
delete tile;
}
#endif
}
pthread_cleanup_pop(1);
}
#endif // ENABLE_THREADS

167
src/Scenery/FGTileLoader.hxx
View file

@ -1,167 +0,0 @@
// FGTileLoader - Queue scenery tiles for loading.
//
// Written by Bernie Bright, started March 2001.
//
// Copyright (C) 2001 Bernard Bright - bbright@bigpond.net.au
//
// 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 FG_TILE_LOADER_HXX
#define FG_TILE_LOADER_HXX
#include <simgear/bucket/newbucket.hxx>
#include <simgear/misc/sg_path.hxx>
#if defined(ENABLE_THREADS)
# include <simgear/threads/SGThread.hxx>
# include <simgear/threads/SGQueue.hxx>
#else
# include <queue>
SG_USING_STD( queue );
#endif
// Forward reference.
class FGTileEntry;
/**
* Queues tiles for loading, possibly by a separate thread.
*/
class FGTileLoader
{
public:
/**
* Constructor.
*/
FGTileLoader();
/**
* Destructor.
*/
~FGTileLoader();
#if 0 // we don't ever want to do this I don't think
/**
* Flush anything in pending load queue without doing the work
* Leave the free queue intact since that's are only record of
* things we need to remove.
*/
void reinit();
#endif
/**
* Add a tile to the end of the load queue.
* @param tile The tile to be loaded from disk.
*/
void add( FGTileEntry* tile );
#ifdef WISH_PLIB_WAS_THREADED // but it isn't
/**
* Remove a tile from memory.
* @param tile The tile to be removed from memory.
*/
void remove( FGTileEntry* tile );
#endif
/**
* The tile loader thread will only load one tile per call to the
* update() method. This is a way to spread out the work of the
* tile loader and slow it down so it is less intrusive. For
* systems built without thead support this is a no-op.
*/
void update();
/**
* Returns whether the load queue is empty (contains no elements).
* @return true if load queue is empty otherwise returns false.
*/
// bool empty() const { return tile_load_queue.empty(); }
private:
private:
#if defined(ENABLE_THREADS)
/**
* FIFO queue of tiles to load from data files.
*/
SGBlockingQueue< FGTileEntry * > tile_load_queue;
// SGBlockingQueue< FGTileEntry * > tile_free_queue;
#else
queue< FGTileEntry * > tile_load_queue;
// queue< FGTileEntry * > tile_free_queue;
#endif
/**
* Base names of directories containing tile data files.
*/
string_list tile_path;
#if defined(ENABLE_THREADS)
/**
* Maximum number of threads to create for loading tiles.
*/
enum { MAX_THREADS = 1 };
/**
* This class represents the thread of execution responsible for
* loading a tile.
*/
class LoaderThread : public SGThread
{
public:
LoaderThread( FGTileLoader* l ) : loader(l) {}
~LoaderThread() {}
/**
* Reads the tile from disk.
*/
void run();
private:
FGTileLoader* loader;
private:
// not implemented.
LoaderThread();
LoaderThread( const LoaderThread& );
LoaderThread& operator=( const LoaderThread& );
};
friend class LoaderThread;
/**
* Array of loading threads.
*/
LoaderThread* threads[ MAX_THREADS ];
/**
* Lock and synchronize access to tile queue.
*/
SGMutex mutex;
SGPthreadCond frame_cond;
/**
* Thread cleanup handler.
*/
friend void cleanup_handler( void* );
#endif // ENABLE_THREADS
};
#endif // FG_TILE_LOADER_HXX

18
src/Scenery/SceneryPager.cxx
View file

@ -1,3 +1,21 @@
// SceneryPager.hxx -- Interface to OSG database pager
//
// Copyright (C) 2007 Tim Moore timoore@redhat.com
//
// 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.
#include "SceneryPager.hxx"
#include <algorithm>
#include <functional>