Rename GrAtlasMgr to GrAtlas (and other cleanup)

src/gpu/GrAtlas.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 "GrContext.h"
 #include "GrGpu.h"
 #include "GrRectanizer.h"
 #include "GrTracing.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // for testing
 #define FONT_CACHE_STATS 0
 #if FONT_CACHE_STATS
 static int g_UploadCount = 0;
 #endif
 
 GrPlot::GrPlot() : fDrawToken(NULL, 0)
                  , fTexture(NULL)
                  , fRects(NULL)
-                 , fAtlasMgr(NULL)
+                 , fAtlas(NULL)
                  , fBytesPerPixel(1)
                  , fDirty(false)
                  , fBatchUploads(false)
 {
     fOffset.set(0, 0);
 }
 
 GrPlot::~GrPlot() {
     SkDELETE_ARRAY(fPlotData);
     fPlotData = NULL;
     delete fRects;
 }
 
-void GrPlot::init(GrAtlasMgr* mgr, int offX, int offY, int width, int height, size_t bpp,
+void GrPlot::init(GrAtlas* atlas, int offX, int offY, int width, int height, size_t bpp,
                   bool batchUploads) {
     fRects = GrRectanizer::Factory(width, height);
-    fAtlasMgr = mgr;
+    fAtlas = atlas;
     fOffset.set(offX * width, offY * height);
     fBytesPerPixel = bpp;
     fPlotData = NULL;
     fDirtyRect.setEmpty();
     fDirty = false;
     fBatchUploads = batchUploads;
 }
 
 static inline void adjust_for_offset(SkIPoint16* loc, const SkIPoint16& offset) {
     loc->fX += offset.fX;
@@ skipping 85 matching lines @@
     }
 }
 
 void GrPlot::resetRects() {
     SkASSERT(NULL != fRects);
     fRects->reset();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-GrAtlasMgr::GrAtlasMgr(GrGpu* gpu, GrPixelConfig config,
-                       const SkISize& backingTextureSize,
-                       int numPlotsX, int numPlotsY, bool batchUploads) {
+GrAtlas::GrAtlas(GrGpu* gpu, GrPixelConfig config,
+                 const SkISize& backingTextureSize,
+                 int numPlotsX, int numPlotsY, bool batchUploads) {
     fGpu = SkRef(gpu);
     fPixelConfig = config;
     fBackingTextureSize = backingTextureSize;
     fNumPlotsX = numPlotsX;
     fNumPlotsY = numPlotsY;
     fBatchUploads = batchUploads;
     fTexture = NULL;
 
     int textureWidth = fBackingTextureSize.width();
     int textureHeight = fBackingTextureSize.height();
@@ skipping 16 matching lines @@
         for (int x = numPlotsX-1; x >= 0; --x) {
             currPlot->init(this, x, y, plotWidth, plotHeight, bpp, batchUploads);
 
             // build LRU list
             fPlotList.addToHead(currPlot);
             ++currPlot;
         }
     }
 }
 
-GrAtlasMgr::~GrAtlasMgr() {
+GrAtlas::~GrAtlas() {
     SkSafeUnref(fTexture);
     SkDELETE_ARRAY(fPlotArray);
 
     fGpu->unref();
 #if FONT_CACHE_STATS
       GrPrintf("Num uploads: %d\n", g_UploadCount);
 #endif
 }
 
-void GrAtlasMgr::moveToHead(GrPlot* plot) {
+void GrAtlas::makeMRU(GrPlot* plot) {
     if (fPlotList.head() == plot) {
         return;
     }
 
     fPlotList.remove(plot);
     fPlotList.addToHead(plot);
 };
 
-GrPlot* GrAtlasMgr::addToAtlas(GrAtlas* atlas,
-                               int width, int height, const void* image,
-                               SkIPoint16* loc) {
+GrPlot* GrAtlas::addToAtlas(ClientPlotUsage* usage,
+                            int width, int height, const void* image,
+                            SkIPoint16* loc) {
     // iterate through entire plot list for this atlas, see if we can find a hole
     // last one was most recently added and probably most empty
-    for (int i = atlas->fPlots.count()-1; i >= 0; --i) {
-        GrPlot* plot = atlas->fPlots[i];
+    for (int i = usage->fPlots.count()-1; i >= 0; --i) {
+        GrPlot* plot = usage->fPlots[i];
         if (plot->addSubImage(width, height, image, loc)) {
-            this->moveToHead(plot);
+            this->makeMRU(plot);
             return plot;
         }
     }
 
     // before we get a new plot, make sure we have a backing texture
     if (NULL == fTexture) {
         // TODO: Update this to use the cache rather than directly creating a texture.
         GrTextureDesc desc;
         desc.fFlags = kDynamicUpdate_GrTextureFlagBit;
         desc.fWidth = fBackingTextureSize.width();
         desc.fHeight = fBackingTextureSize.height();
         desc.fConfig = fPixelConfig;
 
         fTexture = fGpu->createTexture(desc, NULL, 0);
         if (NULL == fTexture) {
             return NULL;
         }
     }
 
     // now look through all allocated plots for one we can share, in MRU order
     GrPlotList::Iter plotIter;
     plotIter.init(fPlotList, GrPlotList::Iter::kHead_IterStart);
     GrPlot* plot;
     while (NULL != (plot = plotIter.get())) {
         // make sure texture is set for quick lookup
         plot->fTexture = fTexture;
         if (plot->addSubImage(width, height, image, loc)) {
-            this->moveToHead(plot);
+            this->makeMRU(plot);
             // new plot for atlas, put at end of array
-            *(atlas->fPlots.append()) = plot;
+            SkASSERT(!usage->fPlots.contains(plot));
+            *(usage->fPlots.append()) = plot;
             return plot;
         }
         plotIter.next();
     }
 
     // If the above fails, then the current plot list has no room
     return NULL;
 }
 
-bool GrAtlasMgr::removePlot(GrAtlas* atlas, const GrPlot* plot) {
-    // iterate through plot list for this atlas
-    int count = atlas->fPlots.count();
-    for (int i = 0; i < count; ++i) {
-        if (plot == atlas->fPlots[i]) {
-            atlas->fPlots.remove(i);
-            return true;
-        }
+void GrAtlas::removePlot(ClientPlotUsage* usage, const GrPlot* plot) {
+    int index = usage->fPlots.find(const_cast<GrPlot*>(plot));
+    if (index >= 0) {
+        usage->fPlots.remove(index);
     }
-
-    return false;
 }
 
 // get a plot that's not being used by the current draw
-GrPlot* GrAtlasMgr::getUnusedPlot() {
+GrPlot* GrAtlas::getUnusedPlot() {
     GrPlotList::Iter plotIter;
     plotIter.init(fPlotList, GrPlotList::Iter::kTail_IterStart);
     GrPlot* plot;
     while (NULL != (plot = plotIter.get())) {
         if (plot->drawToken().isIssued()) {
             return plot;
         }
         plotIter.prev();
     }
 
     return NULL;
 }
 
-void GrAtlasMgr::uploadPlotsToTexture() {
+void GrAtlas::uploadPlotsToTexture() {
     if (fBatchUploads) {
         GrPlotList::Iter plotIter;
         plotIter.init(fPlotList, GrPlotList::Iter::kHead_IterStart);
         GrPlot* plot;
         while (NULL != (plot = plotIter.get())) {
             plot->uploadToTexture();
             plotIter.next();
         }
     }
 }