Minor changes to GrFontCache system

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"
 
-#if 0
-#define GR_PLOT_WIDTH   8
-#define GR_PLOT_HEIGHT  4
-#define GR_ATLAS_WIDTH  256
-#define GR_ATLAS_HEIGHT 256
-
-#define GR_ATLAS_TEXTURE_WIDTH  (GR_PLOT_WIDTH * GR_ATLAS_WIDTH)
-#define GR_ATLAS_TEXTURE_HEIGHT (GR_PLOT_HEIGHT * GR_ATLAS_HEIGHT)
-
-#else
-
-#define GR_ATLAS_TEXTURE_WIDTH  1024
-#define GR_ATLAS_TEXTURE_HEIGHT 2048
-
-#define GR_ATLAS_WIDTH  256
-#define GR_ATLAS_HEIGHT 256
-
-#define GR_PLOT_WIDTH   (GR_ATLAS_TEXTURE_WIDTH / GR_ATLAS_WIDTH)
-#define GR_PLOT_HEIGHT  (GR_ATLAS_TEXTURE_HEIGHT / GR_ATLAS_HEIGHT)
-
-#endif
-
 ///////////////////////////////////////////////////////////////////////////////
 
 // 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)
                  , fBytesPerPixel(1)
 {
-    fRects = GrRectanizer::Factory(GR_ATLAS_WIDTH,
-                                   GR_ATLAS_HEIGHT);
     fOffset.set(0, 0);
 }
 
 GrPlot::~GrPlot() {
     delete fRects;
 }
 
+void GrPlot::init(GrAtlasMgr* mgr, int offX, int offY, int width, int height, size_t bpp) {
+    fRects = GrRectanizer::Factory(width, height);
+    fAtlasMgr = mgr;
+    fOffset.set(offX * width, offY * height);
+    fBytesPerPixel = bpp;
+}
+
 static inline void adjust_for_offset(GrIPoint16* loc, const GrIPoint16& offset) {
-    loc->fX += offset.fX * GR_ATLAS_WIDTH;
-    loc->fY += offset.fY * GR_ATLAS_HEIGHT;
+    loc->fX += offset.fX;
+    loc->fY += offset.fY;
 }
 
 bool GrPlot::addSubImage(int width, int height, const void* image,
                           GrIPoint16* loc) {
     if (!fRects->addRect(width, height, loc)) {
         return false;
     }
 
     SkAutoSMalloc<1024> storage;
     adjust_for_offset(loc, fOffset);
@@ skipping 13 matching lines @@
     return true;
 }
 
 void GrPlot::resetRects() {
     SkASSERT(NULL != fRects);
     fRects->reset();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-GrAtlasMgr::GrAtlasMgr(GrGpu* gpu, GrPixelConfig config) {
-    fGpu = gpu;
+GrAtlasMgr::GrAtlasMgr(GrGpu* gpu, GrPixelConfig config, 
+                       int backingTextureWidth, int backingTextureHeight,

[jvanverth1, 2014/04/01 15:32:43]

One thing that might be worth considering is whether it'd be better to use an
SkISIze here (and change fBackingTexture{Width|Height} to fBackingTextureSize).
On one hand, it would reduce the need to push the later arguments on the stack
for Android (the first four or five end up in registers). On the other, you'd
have to create an SkISize in GrTextStrike to pass in. 

[robertphillips, 2014/04/01 15:45:54]

Done.

+                       int numPlotsX, int numPlotsY) {
+    fGpu = SkRef(gpu);
     fPixelConfig = config;
-    gpu->ref();
+    fBackingTextureWidth = backingTextureWidth;
+    fBackingTextureHeight = backingTextureHeight;
+    fNumPlotsX = numPlotsX;
+    fNumPlotsY = numPlotsY;
     fTexture = NULL;
 
+    int plotWidth = fBackingTextureWidth / fNumPlotsX;
+    int plotHeight = fBackingTextureHeight / fNumPlotsY;
+
+    SkASSERT(plotWidth * fNumPlotsX == fBackingTextureWidth);
+    SkASSERT(plotHeight * fNumPlotsY == fBackingTextureHeight);
+
     // set up allocated plots
     size_t bpp = GrBytesPerPixel(fPixelConfig);
-    fPlotArray = SkNEW_ARRAY(GrPlot, (GR_PLOT_WIDTH*GR_PLOT_HEIGHT));
+    fPlotArray = SkNEW_ARRAY(GrPlot, (fNumPlotsX*fNumPlotsY));
 
     GrPlot* currPlot = fPlotArray;
-    for (int y = GR_PLOT_HEIGHT-1; y >= 0; --y) {
-        for (int x = GR_PLOT_WIDTH-1; x >= 0; --x) {
-            currPlot->fAtlasMgr = this;
-            currPlot->fOffset.set(x, y);
-            currPlot->fBytesPerPixel = bpp;
+    for (int y = numPlotsY-1; y >= 0; --y) {
+        for (int x = numPlotsX-1; x >= 0; --x) {
+            currPlot->init(this, x, y, plotWidth, plotHeight, bpp);
 
             // build LRU list
             fPlotList.addToHead(currPlot);
             ++currPlot;
         }
     }
 }
 
 GrAtlasMgr::~GrAtlasMgr() {
     SkSafeUnref(fTexture);
@@ skipping 25 matching lines @@
             this->moveToHead(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 = GR_ATLAS_TEXTURE_WIDTH;
-        desc.fHeight = GR_ATLAS_TEXTURE_HEIGHT;
+        desc.fWidth = fBackingTextureWidth;
+        desc.fHeight = fBackingTextureHeight;
         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;
@@ skipping 35 matching lines @@
     GrPlot* plot;
     while (NULL != (plot = plotIter.get())) {
         if (plot->drawToken().isIssued()) {
             return plot;
         }
         plotIter.prev();
     }
 
     return NULL;
 }