src/Scenery/FGTileLoader.hxx

   1 // FGTileLoader - Queue scenery tiles for loading.
   2 //
   3 // Written by Bernie Bright, started March 2001.
   4 //
   5 // Copyright (C) 2001  Bernard Bright - bbright@bigpond.net.au
   6 //
   7 // This program is free software; you can redistribute it and/or
   8 // modify it under the terms of the GNU General Public License as
   9 // published by the Free Software Foundation; either version 2 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful, but
  13 // WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 // General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU General Public License
  18 // along with this program; if not, write to the Free Software
  19 // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 //
  21 // $Id$
  22
  23
  24 #ifndef FG_TILE_LOADER_HXX
  25 #define FG_TILE_LOADER_HXX
  26
  27 #include <simgear/bucket/newbucket.hxx>
  28 #include <simgear/misc/sg_path.hxx>
  29
  30 #ifdef ENABLE_THREADS
  31 #  include <simgear/threads/SGThread.hxx>
  32 #  include <simgear/threads/SGQueue.hxx>
  33 #else
  34 #  include <queue>
  35 #endif
  36
  37 // Forward reference.
  38 class FGTileEntry;
  39
  40 /**
  41  * Queues tiles for loading, possibly by a separate thread.
  42  */
  43 class FGTileLoader
  44 {
  45 public:
  46
  47     /**
  48      * Constructor.
  49      */
  50     FGTileLoader();
  51
  52     /**
  53      * Destructor.
  54      */
  55     ~FGTileLoader();
  56
  57     /**
  58      * Add a tile to the end of the load queue.
  59      * @param tile The tile to be loaded from disk.
  60      */
  61     void add( FGTileEntry* tile );
  62
  63     /**
  64      * Remove a tile from memory.
  65      * @param tile The tile to be removed from memory.
  66      */
  67     void remove( FGTileEntry* tile );
  68
  69     /**
  70      * The tile loader thread will only load one tile per call to the
  71      * update() method.  This is a way to spread out the work of the
  72      * tile loader and slow it down so it is less intrusive.  For
  73      * systems built without thead support this is a no-op.
  74      */
  75     void update();
  76
  77     /**
  78      * Returns whether the load queue is empty (contains no elements).
  79      * @return true if load queue is empty otherwise returns false.
  80      */
  81     // bool empty() const { return tile_load_queue.empty(); }
  82
  83 private:
  84
  85 private:
  86
  87 #ifdef ENABLE_THREADS
  88     /**
  89      * FIFO queue of tiles to load from data files.
  90      */
  91     SGBlockingQueue< FGTileEntry * > tile_load_queue;
  92     SGBlockingQueue< FGTileEntry * > tile_free_queue;
  93 #else
  94     queue< FGTileEntry * > tile_load_queue;
  95     queue< FGTileEntry * > tile_free_queue;
  96 #endif
  97
  98     /**
  99      * Base name of directory containing tile data file.
 100      */
 101     SGPath tile_path;
 102
 103 #ifdef ENABLE_THREADS
 104     /**
 105      * Maximum number of threads to create for loading tiles.
 106      */
 107     enum { MAX_THREADS = 1 };
 108
 109     /**
 110      * This class represents the thread of execution responsible for
 111      * loading a tile.
 112      */
 113     class LoaderThread : public SGThread
 114     {
 115     public:
 116         LoaderThread( FGTileLoader* l ) : loader(l) {}
 117         ~LoaderThread() {}
 118
 119         /**
 120          * Reads the tile from disk.
 121          */
 122         void run();
 123
 124     private:
 125         FGTileLoader* loader;
 126
 127     private:
 128         // not implemented.
 129         LoaderThread();
 130         LoaderThread( const LoaderThread& );
 131         LoaderThread& operator=( const LoaderThread& );
 132     };
 133
 134     friend class LoaderThread;
 135
 136     /**
 137      * Array of loading threads.
 138      */
 139     LoaderThread* threads[ MAX_THREADS ];
 140
 141     /**
 142      * Lock and synchronize access to tile queue.
 143      */
 144     SGMutex mutex;
 145     SGCondition frame_cond;
 146
 147     /**
 148      * Thread cleanup handler.
 149      */
 150     friend void cleanup_handler( void* );
 151 #endif // ENABLE_THREADS
 152 };
 153
 154 #endif // FG_TILE_LOADER_HXX