Small tidys GrAtlasTextContext

src/gpu/batches/GrAtlasTextBatch.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAtlasTextBatch.h"
 
 #include "GrBatchFontCache.h"
@@ skipping 78 matching lines @@
         SkDebugf("Cannot invert viewmatrix\n");
         return;
     }
 
     GrTexture* texture = fFontCache->getTexture(this->maskFormat());
     if (!texture) {
         SkDebugf("Could not allocate backing texture for atlas\n");
         return;
     }
 
-    bool usesDistanceFields = this->usesDistanceFields();
     GrMaskFormat maskFormat = this->maskFormat();
     bool isLCD = this->isLCD();
 
     SkAutoTUnref<const GrGeometryProcessor> gp;
-    if (usesDistanceFields) {
+    if (this->usesDistanceFields()) {
         gp.reset(this->setupDfProcessor(this->viewMatrix(), fFilteredColor, this->color(),
                                         texture));
     } else {
         GrTextureParams params(SkShader::kClamp_TileMode, GrTextureParams::kNone_FilterMode);
         gp.reset(GrBitmapTextGeoProc::Create(this->color(),
                                              texture,
                                              params,
                                              maskFormat,
                                              localMatrix,
                                              this->usesLocalCoords()));
     }
 
     FlushInfo flushInfo;
     flushInfo.fGlyphsToFlush = 0;
     size_t vertexStride = gp->getVertexStride();
-    SkASSERT(vertexStride == (usesDistanceFields ?
+    SkASSERT(vertexStride == (this->usesDistanceFields() ?
                               GetVertexStrideDf(maskFormat, isLCD) :
                               GetVertexStride(maskFormat)));
 
     target->initDraw(gp, this->pipeline());
 
     int glyphCount = this->numGlyphs();
     const GrVertexBuffer* vertexBuffer;
 
     void* vertices = target->makeVertexSpace(vertexStride,
                                              glyphCount * kVerticesPerGlyph,
@@ skipping 15 matching lines @@
     GrFontScaler* scaler = nullptr;
     SkTypeface* typeface = nullptr;
 
     for (int i = 0; i < fGeoCount; i++) {
         Geometry& args = fGeoData[i];
         Blob* blob = args.fBlob;
         Run& run = blob->fRuns[args.fRun];
         TextInfo& info = run.fSubRunInfo[args.fSubRun];
 
         uint64_t currentAtlasGen = fFontCache->atlasGeneration(maskFormat);
+        bool regenerateGlyphs = info.fStrike->isAbandoned();
         bool regenerateTextureCoords = info.fAtlasGeneration != currentAtlasGen ||
-                                       info.fStrike->isAbandoned();
+                                       regenerateGlyphs;
         bool regenerateColors;
         if (usesDistanceFields) {
             regenerateColors = !isLCD && run.fColor != args.fColor;
         } else {
             regenerateColors = kA8_GrMaskFormat == maskFormat && run.fColor != args.fColor;
         }
         bool regeneratePositions = args.fTransX != 0.f || args.fTransY != 0.f;
         int glyphCount = info.fGlyphEndIndex - info.fGlyphStartIndex;
 
         // We regenerate both texture coords and colors in the blob itself, and update the
         // atlas generation.  If we don't end up purging any unused plots, we can avoid
         // regenerating the coords.  We could take a finer grained approach to updating texture
         // coords but its not clear if the extra bookkeeping would offset any gains.
         // To avoid looping over the glyphs twice, we do one loop and conditionally update color
         // or coords as needed.  One final note, if we have to break a run for an atlas eviction
         // then we can't really trust the atlas has all of the correct data.  Atlas evictions
         // should be pretty rare, so we just always regenerate in those cases
         if (regenerateTextureCoords || regenerateColors || regeneratePositions) {
             // first regenerate texture coordinates / colors if need be
             bool brokenRun = false;
 
             // Because the GrBatchFontCache may evict the strike a blob depends on using for
             // generating its texture coords, we have to track whether or not the strike has
             // been abandoned.  If it hasn't been abandoned, then we can use the GrGlyph*s as is
             // otherwise we have to get the new strike, and use that to get the correct glyphs.
             // Because we do not have the packed ids, and thus can't look up our glyphs in the
             // new strike, we instead keep our ref to the old strike and use the packed ids from
             // it.  These ids will still be valid as long as we hold the ref.  When we are done
             // updating our cache of the GrGlyph*s, we drop our ref on the old strike
-            bool regenerateGlyphs = false;
             GrBatchTextStrike* strike = nullptr;
             if (regenerateTextureCoords) {
                 info.fBulkUseToken.reset();
 
                 // We can reuse if we have a valid strike and our descriptors / typeface are the
                 // same.  The override descriptor is only for the non distance field text within
                 // a run
-                const SkDescriptor* newDesc = (run.fOverrideDescriptor && !usesDistanceFields) ?
+                const SkDescriptor* newDesc = (run.fOverrideDescriptor &&
+                                               !this->usesDistanceFields()) ?
                                               run.fOverrideDescriptor->getDesc() :
                                               run.fDescriptor.getDesc();
                 if (!cache || !SkTypeface::Equal(typeface, run.fTypeface) ||
                               !(desc->equals(*newDesc))) {
                     if (cache) {
                         SkGlyphCache::AttachCache(cache);
                     }
                     desc = newDesc;
                     cache = SkGlyphCache::DetachCache(run.fTypeface, desc);
                     scaler = GrTextContext::GetGrFontScaler(cache);
                     strike = info.fStrike;
                     typeface = run.fTypeface;
                 }
 
-                if (info.fStrike->isAbandoned()) {
-                    regenerateGlyphs = true;
+                if (regenerateGlyphs) {
                     strike = fFontCache->getStrike(scaler);
                 } else {
                     strike = info.fStrike;
                 }
             }
 
             for (int glyphIdx = 0; glyphIdx < glyphCount; glyphIdx++) {
                 if (regenerateTextureCoords) {
                     size_t glyphOffset = glyphIdx + info.fGlyphStartIndex;
 
                     GrGlyph* glyph = blob->fGlyphs[glyphOffset];
                     GrGlyph::PackedID id = glyph->fPackedID;
                     const SkGlyph& skGlyph = scaler->grToSkGlyph(id);
                     if (regenerateGlyphs) {
                         // Get the id from the old glyph, and use the new strike to lookup
                         // the glyph.
                         blob->fGlyphs[glyphOffset] = strike->getGlyph(skGlyph, id, maskFormat,
                                                                       scaler);
                     }
                     glyph = blob->fGlyphs[glyphOffset];
                     SkASSERT(glyph);
                     SkASSERT(id == glyph->fPackedID);
-                    // We want to be able to assert this but cannot for testing purposes.
-                    // once skbug:4143 has landed we can revist this assert
-                    //SkASSERT(glyph->fMaskFormat == this->maskFormat());
+                    SkASSERT(glyph->fMaskFormat == this->maskFormat());
 
                     if (!fFontCache->hasGlyph(glyph) &&
                         !strike->addGlyphToAtlas(target, glyph, scaler, skGlyph, maskFormat)) {
                         this->flush(target, &flushInfo);
                         target->initDraw(gp, this->pipeline());
                         brokenRun = glyphIdx > 0;
 
                         SkDEBUGCODE(bool success =) strike->addGlyphToAtlas(target,
                                                                             glyph,
                                                                             scaler,
                                                                             skGlyph,
                                                                             maskFormat);
                         SkASSERT(success);
                     }
                     fFontCache->addGlyphToBulkAndSetUseToken(&info.fBulkUseToken, glyph,
                                                              target->currentToken());
 
-                    // Texture coords are the last vertex attribute so we get a pointer to the
-                    // first one and then map with stride in regenerateTextureCoords
-                    intptr_t vertex = reinterpret_cast<intptr_t>(blob->fVertices);
-                    vertex += info.fVertexStartIndex;
-                    vertex += vertexStride * glyphIdx * kVerticesPerGlyph;
-                    vertex += vertexStride - sizeof(SkIPoint16);
-
-                    this->regenerateTextureCoords(glyph, vertex, vertexStride);
+                    this->regenerateTextureCoords(glyph, blob->fVertices, glyphIdx,
+                                                  info.fVertexStartIndex, vertexStride);
                 }
 
                 if (regenerateColors) {
-                    intptr_t vertex = reinterpret_cast<intptr_t>(blob->fVertices);
-                    vertex += info.fVertexStartIndex;
-                    vertex += vertexStride * glyphIdx * kVerticesPerGlyph + sizeof(SkPoint);
-                    this->regenerateColors(vertex, vertexStride, args.fColor);
+                    this->regenerateColors(blob->fVertices, glyphIdx, info.fVertexStartIndex,
+                                           vertexStride, args.fColor);
                 }
 
                 if (regeneratePositions) {
-                    intptr_t vertex = reinterpret_cast<intptr_t>(blob->fVertices);
-                    vertex += info.fVertexStartIndex;
-                    vertex += vertexStride * glyphIdx * kVerticesPerGlyph;
-                    SkScalar transX = args.fTransX;
-                    SkScalar transY = args.fTransY;
-                    this->regeneratePositions(vertex, vertexStride, transX, transY);
+                    this->regeneratePositions(blob->fVertices, glyphIdx, info.fVertexStartIndex,
+                                              vertexStride, args.fTransX, args.fTransY);
                 }
                 flushInfo.fGlyphsToFlush++;
             }
 
             // We my have changed the color so update it here
             run.fColor = args.fColor;
             if (regenerateTextureCoords) {
                 if (regenerateGlyphs) {
                     info.fStrike.reset(SkRef(strike));
                 }
@@ skipping 14 matching lines @@
 
         currVertex += byteCount;
     }
     // Make sure to attach the last cache if applicable
     if (cache) {
         SkGlyphCache::AttachCache(cache);
     }
     this->flush(target, &flushInfo);
 }
 
-void GrAtlasTextBatch::regenerateTextureCoords(GrGlyph* glyph, intptr_t vertex,
-                                               size_t vertexStride) {
+void GrAtlasTextBatch::regenerateTextureCoords(const GrGlyph* glyph, void* vertices, int glyphIdx,
+                                               size_t vertexStartIndex, size_t vertexStride) {
     int width = glyph->fBounds.width();
     int height = glyph->fBounds.height();
 
     int u0, v0, u1, v1;
     if (this->usesDistanceFields()) {
         u0 = glyph->fAtlasLocation.fX + SK_DistanceFieldInset;
         v0 = glyph->fAtlasLocation.fY + SK_DistanceFieldInset;
         u1 = u0 + width - 2 * SK_DistanceFieldInset;
         v1 = v0 + height - 2 * SK_DistanceFieldInset;
     } else {
         u0 = glyph->fAtlasLocation.fX;
         v0 = glyph->fAtlasLocation.fY;
         u1 = u0 + width;
         v1 = v0 + height;
     }
 
+    // Texture coords are the last vertex attribute so we get a pointer to the
+    // first one and then map with stride in regenerateTextureCoords
+    intptr_t vertex = reinterpret_cast<intptr_t>(vertices);
+    vertex += vertexStartIndex;
+    vertex += vertexStride * glyphIdx * kVerticesPerGlyph;
+    vertex += vertexStride - sizeof(SkIPoint16);
+
     SkIPoint16* textureCoords;
     // V0
     textureCoords = reinterpret_cast<SkIPoint16*>(vertex);
     textureCoords->set(u0, v0);
     vertex += vertexStride;
 
     // V1
     textureCoords = reinterpret_cast<SkIPoint16*>(vertex);
     textureCoords->set(u0, v1);
     vertex += vertexStride;
 
     // V2
     textureCoords = reinterpret_cast<SkIPoint16*>(vertex);
     textureCoords->set(u1, v1);
     vertex += vertexStride;
 
     // V3
     textureCoords = reinterpret_cast<SkIPoint16*>(vertex);
     textureCoords->set(u1, v0);
 }
 

[robertphillips, 2015/11/20 18:43:02]

can this be static ?

-void GrAtlasTextBatch::regenerateColors(intptr_t vertex, size_t vertexStride, GrColor color) {
+void GrAtlasTextBatch::regenerateColors(void* vertices, int glyphIdx, size_t vertexStartIndex,
+                                        size_t vertexStride, GrColor color) {
+    intptr_t vertex = reinterpret_cast<intptr_t>(vertices);
+    vertex += vertexStartIndex;
+    vertex += vertexStride * glyphIdx * kVerticesPerGlyph + sizeof(SkPoint);
+
     for (int i = 0; i < kVerticesPerGlyph; i++) {
         SkColor* vcolor = reinterpret_cast<SkColor*>(vertex);
         *vcolor = color;
         vertex += vertexStride;
     }
 }
 

[robertphillips, 2015/11/20 18:43:02]

this guy too ?

-void GrAtlasTextBatch::regeneratePositions(intptr_t vertex, size_t vertexStride, SkScalar transX,
-                                           SkScalar transY) {
+void GrAtlasTextBatch::regeneratePositions(void* vertices, int glyphIdx, size_t vertexStartIndex,
+                                           size_t vertexStride, SkScalar transX, SkScalar transY) {
+    intptr_t vertex = reinterpret_cast<intptr_t>(vertices);
+    vertex += vertexStartIndex;
+    vertex += vertexStride * glyphIdx * kVerticesPerGlyph;
     for (int i = 0; i < kVerticesPerGlyph; i++) {
         SkPoint* point = reinterpret_cast<SkPoint*>(vertex);
         point->fX += transX;
         point->fY += transY;
         vertex += vertexStride;
     }
 }
 
 void GrAtlasTextBatch::flush(GrVertexBatch::Target* target, FlushInfo* flushInfo) {
     GrVertices vertices;
@@ skipping 127 matching lines @@
         return GrDistanceFieldA8TextGeoProc::Create(color,
                                                     viewMatrix,
                                                     texture,
                                                     params,
                                                     flags,
                                                     this->usesLocalCoords());
 #endif
     }
 
 }