New approach for GPU font atlas

src/gpu/GrTextStrike.cpp

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAtlas.h"
 #include "GrGpu.h"
 #include "GrRectanizer.h"
@@ skipping 92 matching lines @@
     fTail = NULL;
 }
 
 void GrFontCache::purgeStrike(GrTextStrike* strike) {
     const GrFontCache::Key key(strike->fFontScalerKey);
     fCache.remove(key, strike);
     this->detachStrikeFromList(strike);
     delete strike;
 }
 
-void GrFontCache::purgeExceptFor(GrTextStrike* preserveStrike) {
+bool GrFontCache::freeUnusedPlot(GrTextStrike* preserveStrike) {
     SkASSERT(NULL != preserveStrike);
-    GrTextStrike* strike = fTail;
-    bool purge = true;
+
+    GrAtlasMgr* atlasMgr = preserveStrike->fAtlasMgr;
+    GrPlot* plot = atlasMgr->getUnusedPlot();
+    if (NULL == plot) {
+        return false;
+    }
+    plot->resetRects();
+
+    GrTextStrike* strike = fHead;
     GrMaskFormat maskFormat = preserveStrike->fMaskFormat;
     while (strike) {
-        if (strike == preserveStrike || maskFormat != strike->fMaskFormat) {
-            strike = strike->fPrev;
+        if (maskFormat != strike->fMaskFormat) {
+            strike = strike->fNext;
             continue;
         }
+
         GrTextStrike* strikeToPurge = strike;
-        strike = strikeToPurge->fPrev;
-        if (purge) {
-            // keep purging if we won't free up any atlases with this strike.
-            purge = strikeToPurge->fAtlas.isEmpty();
+        strike = strikeToPurge->fNext;
+        strikeToPurge->removePlot(plot);
+
+        // clear out any empty strikes (except this one)
+        if (strikeToPurge != preserveStrike && strikeToPurge->fAtlas.isEmpty()) {
             this->purgeStrike(strikeToPurge);
         }
     }
+
 #if FONT_CACHE_STATS
     ++g_PurgeCount;
 #endif
-}
 
-void GrFontCache::freePlotExceptFor(GrTextStrike* preserveStrike) {
-    SkASSERT(NULL != preserveStrike);
-    GrTextStrike* strike = fTail;
-    GrMaskFormat maskFormat = preserveStrike->fMaskFormat;
-    while (strike) {
-        if (strike == preserveStrike || maskFormat != strike->fMaskFormat) {
-            strike = strike->fPrev;
-            continue;
-        }
-        GrTextStrike* strikeToPurge = strike;
-        strike = strikeToPurge->fPrev;
-        if (strikeToPurge->removeUnusedPlots()) {
-            if (strikeToPurge->fAtlas.isEmpty()) {
-                this->purgeStrike(strikeToPurge);
-            }
-            break;
-        }
-    }
+    return true;
 }
 
 #ifdef SK_DEBUG
 void GrFontCache::validate() const {
     int count = fCache.count();
     if (0 == count) {
         SkASSERT(!fHead);
         SkASSERT(!fTail);
     } else if (1 == count) {
         SkASSERT(fHead == fTail);
@@ skipping 50 matching lines @@
 /*
     The text strike is specific to a given font/style/matrix setup, which is
     represented by the GrHostFontScaler object we are given in getGlyph().
 
     We map a 32bit glyphID to a GrGlyph record, which in turn points to a
     atlas and a position within that texture.
  */
 
 GrTextStrike::GrTextStrike(GrFontCache* cache, const GrKey* key,
                            GrMaskFormat format,
-                           GrAtlasMgr* atlasMgr) : fPool(64), fAtlas(atlasMgr) {
+                           GrAtlasMgr* atlasMgr) : fPool(64) {
     fFontScalerKey = key;
     fFontScalerKey->ref();
 
     fFontCache = cache;     // no need to ref, it won't go away before we do
     fAtlasMgr = atlasMgr;   // no need to ref, it won't go away before we do
 
     fMaskFormat = format;
 
 #ifdef SK_DEBUG
 //    GrPrintf(" GrTextStrike %p %d\n", this, gCounter);
     gCounter += 1;
 #endif
 }
 
-// these signatures are needed because they're used with
-// SkTDArray::visitAll() (see destructor & removeUnusedAtlases())
+// this signature is needed because it's used with
+// SkTDArray::visitAll() (see destructor)
 static void free_glyph(GrGlyph*& glyph) { glyph->free(); }
 
-static void invalidate_glyph(GrGlyph*& glyph) {
-    if (glyph->fPlot && glyph->fPlot->drawToken().isIssued()) {
-        glyph->fPlot = NULL;
-    }
-}
-
 GrTextStrike::~GrTextStrike() {
     fFontScalerKey->unref();
     fCache.getArray().visitAll(free_glyph);
 
 #ifdef SK_DEBUG
     gCounter -= 1;
 //    GrPrintf("~GrTextStrike %p %d\n", this, gCounter);
 #endif
 }
 
@@ skipping 12 matching lines @@
         bounds.fRight  += DISTANCE_FIELD_PAD;
         bounds.fTop    -= DISTANCE_FIELD_PAD;
         bounds.fBottom += DISTANCE_FIELD_PAD;
     }
 #endif
     glyph->init(packed, bounds);
     fCache.insert(packed, glyph);
     return glyph;
 }
 
-bool GrTextStrike::removeUnusedPlots() {
-    fCache.getArray().visitAll(invalidate_glyph);
-    return fAtlasMgr->removeUnusedPlots(&fAtlas);
+void GrTextStrike::removePlot(const GrPlot* plot) {
+    SkTDArray<GrGlyph*>& glyphArray = fCache.getArray();
+    for (int i = 0; i < glyphArray.count(); ++i) {
+        if (plot == glyphArray[i]->fPlot) {
+            glyphArray[i]->fPlot = NULL;
+        }
+    }
+
+    fAtlasMgr->removePlot(&fAtlas, plot);
 }
 
 
-bool GrTextStrike::getGlyphAtlas(GrGlyph* glyph, GrFontScaler* scaler) {
+bool GrTextStrike::addGlyphToAtlas(GrGlyph* glyph, GrFontScaler* scaler) {
 #if 0   // testing hack to force us to flush our cache often
     static int gCounter;
     if ((++gCounter % 10) == 0) return false;
 #endif
 
     SkASSERT(glyph);
     SkASSERT(scaler);
     SkASSERT(fCache.contains(glyph));
     SkASSERT(NULL == glyph->fPlot);
 
@@ skipping 112 matching lines @@
     }
 #endif
 
     if (NULL == plot) {
         return false;
     }
 
     glyph->fPlot = plot;
     return true;
 }