TGLDisplayListCache

class TGLDisplayListCache

    private:

                                     TGLDisplayListCache(Bool_t enable = true, UInt_t size = 10000)
                             virtual ~TGLDisplayListCache()
                              UInt_t Find(TGLDisplayListCache::CacheID_t cacheID) const
                                void Init()
      TGLDisplayListCache::CacheID_t MakeCacheID(const TGLDrawable& drawable, const TGLDrawFlags& flags) const

    public:

                                  TGLDisplayListCache(const TGLDisplayListCache&)
                           Bool_t CaptureIsOpen()
                   static TClass* Class()
                           Bool_t CloseCapture()
                           Bool_t Draw(const TGLDrawable& drawable, const TGLDrawFlags& flags) const
                             void Dump() const
                             void Enable(Bool_t enable)
      static TGLDisplayListCache& Instance()
                  virtual TClass* IsA() const
                           Bool_t IsEnabled()
                           Bool_t OpenCapture(const TGLDrawable& drawable, const TGLDrawFlags& flags)
             TGLDisplayListCache& operator=(const TGLDisplayListCache&)
                             void Purge()
                             void Purge(const TGLDrawable& drawable)
                             void Purge(const TGLDrawable& drawable, const TGLDrawFlags& flags)
                     virtual void ShowMembers(TMemberInspector& insp, char* parent)
                     virtual void Streamer(TBuffer& b)
                             void StreamerNVirtual(TBuffer& b)

Data Members

    private:

                                                                                                                                                                             UInt_t fSize            !
                                                                                                                                                                             Bool_t fInit            !
                                                                                                                                                                             Bool_t fEnabled         !
                                                                                                                                                                             Bool_t fCaptureOpen     !
                                                                                                                                                                             UInt_t fDLBase          !
                                                                                                                                                                             UInt_t fDLNextFree      !
      map<pair<const TGLDrawable*,const short>,unsigned int,less<pair<const TGLDrawable*,const short> >,allocator<pair<const pair<const TGLDrawable*,const short>,unsigned int> > > fCacheDLMap      !
                                                                                                                                                        static TGLDisplayListCache* fgInstance       ! the singleton cache instance
                                                                                                                                                                static const UInt_t fgInvalidDLName  

                                                                      
 TGLDisplayListCache                                                  
                                                                      
 Singleton cache of GL display lists. Provides lazy automatic GL      
 display list capture of draws by a TGLDrawable at a certain 'LOD'    
 which can be disable on a global, per drawable or LOD basis.         
                                                                      
 Internally the cache creates a block of GL display lists of fSize,   
 and maintains a stl::map, mapping CacheID_t ids (created from        
 TGLDrawable and LOD draw flag) to 'name' entries in the GL display   
 list block.                                                          
                                                                      
 See TGLDrawable::Draw() for use.                                     
 NOTE: Purging of individual TGLDrawables not currently implemented:  
       Purge(const TGLDrawable & drawable)                            
       Purge(const TGLDrawable & drawable, UInt_t LOD)                

 Create (if required) and return the singleton display list cache

 Construct display list cache.
 Private constructor - cache is singleton obtained through
 TGLDisplayListCache::Instance()

 Destroy display list cache - deleting internal GL display list block

 Initialise the cache - create the internal GL display list block of size
 fSize

 Draw (call) the GL dislay list entry associated with the drawable / LOD
 flag pair, and return kTRUE. If no list item associated, return KFALSE.

 Open capture of GL draw commands into cache entry, associated with
 drawable / LOD pair. Capture is done in GL_COMPILE mode - so the cache
 entry has to be drawn using TGLDisplayListCache::Draw() after capture close.

 Return kTRUE if opened, kFALSE if not. Capture is not opened if cache not
 enabled or cache if full.
 GL display lists can be nested at 'run' (draw) time, but cannot be nested
 in capture - so attempting to nest captures is rejected.

 Close currently open capture - return kTRUE if one open and successfully
 closed.

 Purge all entries for all drawable/LOD pairs from cache

 Return the GL display list block name associated with 'cacheID'
 cacheID is generated from drawable/flags pair - see
 TGLDisplayListCache::MakeCacheID()

 Dump usage count of cache

 Methods

 Cache manipulators

void   Resize(UInt_t size)     {}; //TODO