New approach for GPU font atlas

src/gpu/GrAtlas.h

 
 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrAtlas_DEFINED
 #define GrAtlas_DEFINED
@@ skipping 13 matching lines @@
 // or more GrPlots. The GrPlots keep track of subimage placement via their GrRectanizer. Once a
 // GrPlot is "full" (i.e. there is no room for the new subimage according to the GrRectanizer), the
 // GrAtlas can request a new GrPlot via GrAtlasMgr::addToAtlas().
 //
 // If all GrPlots are allocated, the replacement strategy is up to the client. The drawToken is
 // available to ensure that all draw calls are finished for that particular GrPlot.
 // GrAtlasMgr::removeUnusedPlots() will free up any finished plots for a given GrAtlas.
 
 class GrPlot {
 public:
+    SK_DECLARE_INTERNAL_LLIST_INTERFACE(GrPlot);
+    
     int getOffsetX() const { return fOffset.fX; }
     int getOffsetY() const { return fOffset.fY; }
 
     GrTexture* texture() const { return fTexture; }
 
     bool addSubImage(int width, int height, const void*, GrIPoint16*);
 
     GrDrawTarget::DrawToken drawToken() const { return fDrawToken; }
     void setDrawToken(GrDrawTarget::DrawToken draw) { fDrawToken = draw; }
 
+    void resetRects();
+
 private:
     GrPlot();
     ~GrPlot(); // does not try to delete the fNext field
 
     // for recycling
     GrDrawTarget::DrawToken fDrawToken;
 
-    GrPlot*                 fNext;
-
     GrTexture*              fTexture;
     GrRectanizer*           fRects;
     GrAtlasMgr*             fAtlasMgr;
     GrIPoint16              fOffset;
     size_t                  fBytesPerPixel;
 
     friend class GrAtlasMgr;
 };
 
+typedef SkTInternalLList<GrPlot> GrPlotList;
+
 class GrAtlasMgr {
 public:
     GrAtlasMgr(GrGpu*, GrPixelConfig);
     ~GrAtlasMgr();
 
     // add subimage of width, height dimensions to atlas
     // returns the containing GrPlot and location relative to the backing texture
     GrPlot* addToAtlas(GrAtlas*, int width, int height, const void*, GrIPoint16*);
 
-    // free up any plots that are not waiting on a draw call
-    bool removeUnusedPlots(GrAtlas* atlas);
+    // remove reference to this plot
+    bool removePlot(GrAtlas* atlas, const GrPlot* plot);
 
-    // to be called by ~GrAtlas()
-    void deletePlotList(GrPlot* plot);
+    // get a plot that's not being used by the current draw
+    // this allows us to overwrite this plot without flushing
+    GrPlot* getUnusedPlot();
 
     GrTexture* getTexture() const {
         return fTexture;
     }
 
 private:
-    GrPlot* allocPlot();
-    void freePlot(GrPlot* plot);
+    void moveToHead(GrPlot* plot);
 
     GrGpu*        fGpu;
     GrPixelConfig fPixelConfig;
     GrTexture*    fTexture;
 
     // allocated array of GrPlots
-    GrPlot*       fPlots;
-    // linked list of free GrPlots
-    GrPlot*       fFreePlots;
+    GrPlot*       fPlotArray;
+    // LRU list of GrPlots
+    GrPlotList    fPlotList;
 };
 
 class GrAtlas {
 public:
-    GrAtlas(GrAtlasMgr* mgr) : fPlots(NULL), fAtlasMgr(mgr) { }
-    ~GrAtlas() { fAtlasMgr->deletePlotList(fPlots); }
+    GrAtlas() { }
+    ~GrAtlas() { }
 
-    bool isEmpty() { return NULL == fPlots; }
+    bool isEmpty() { return 0 == fPlots.count(); }
 
     SkISize getSize() const;
 
 private:
-    GrPlot*     fPlots;
-    GrAtlasMgr* fAtlasMgr;
+    SkTDArray<GrPlot*> fPlots;
 
     friend class GrAtlasMgr;
 };
 
 #endif