Start objectifying GrAtlasTextBlob

src/gpu/GrAtlasTextContext.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 "GrAtlasTextContext.h"
 
 #include "GrBlurUtils.h"
 #include "GrDrawContext.h"
@@ skipping 448 matching lines @@
             continue;
         }
 
         runPaint.setFlags(FilterTextFlags(fSurfaceProps, runPaint));
 
         // setup vertex / glyphIndex for the new run
         if (run > 0) {
             PerSubRunInfo& newRun = cacheBlob->fRuns[run].fSubRunInfo.back();
             PerSubRunInfo& lastRun = cacheBlob->fRuns[run - 1].fSubRunInfo.back();
 
-            newRun.fVertexStartIndex = lastRun.fVertexEndIndex;
-            newRun.fVertexEndIndex = lastRun.fVertexEndIndex;
+            newRun.setVertexStartIndex(lastRun.vertexEndIndex());
+            newRun.setVertexEndIndex(lastRun.vertexEndIndex());
 
-            newRun.fGlyphStartIndex = lastRun.fGlyphEndIndex;
-            newRun.fGlyphEndIndex = lastRun.fGlyphEndIndex;
+            newRun.setGlyphStartIndex(lastRun.glyphEndIndex());
+            newRun.setGlyphEndIndex(lastRun.glyphEndIndex());
         }
 
         if (this->canDrawAsDistanceFields(runPaint, viewMatrix)) {
             cacheBlob->setHasDistanceField();
             SkPaint dfPaint = runPaint;
             SkScalar textRatio;
             this->initDistanceFieldPaint(cacheBlob, &dfPaint, &textRatio, viewMatrix);
             Run& runIdx = cacheBlob->fRuns[run];
             PerSubRunInfo& subRun = runIdx.fSubRunInfo.back();
-            subRun.fUseLCDText = runPaint.isLCDRenderText();
-            subRun.fDrawAsDistanceFields = true;
+            subRun.setUseLCDText(runPaint.isLCDRenderText());
+            subRun.setDrawAsDistanceFields();
 
             SkTDArray<char> fallbackTxt;
             SkTDArray<SkScalar> fallbackPos;
             SkPoint dfOffset;
             int scalarsPerPosition = 2;
             switch (it.positioning()) {
                 case SkTextBlob::kDefault_Positioning: {
                     this->internalDrawDFText(cacheBlob, run, dfPaint, color, viewMatrix,
                                              (const char *)it.glyphs(), textLen,
                                              x + offset.x(), y + offset.y(), textRatio,
@@ skipping 139 matching lines @@
 GrAtlasTextContext::setupDFBlob(int glyphCount, const SkPaint& origPaint,
                                 const SkMatrix& viewMatrix, SkPaint* dfPaint,
                                 SkScalar* textRatio) {
     GrAtlasTextBlob* blob = fCache->createBlob(glyphCount, 1, GrAtlasTextBatch::kGrayTextVASize);
 
     *dfPaint = origPaint;
     this->initDistanceFieldPaint(blob, dfPaint, textRatio, viewMatrix);
     blob->fViewMatrix = viewMatrix;
     Run& run = blob->fRuns[0];
     PerSubRunInfo& subRun = run.fSubRunInfo.back();
-    subRun.fUseLCDText = origPaint.isLCDRenderText();
-    subRun.fDrawAsDistanceFields = true;
+    subRun.setUseLCDText(origPaint.isLCDRenderText());
+    subRun.setDrawAsDistanceFields();
 
     return blob;
 }
 
 inline GrAtlasTextBlob*
 GrAtlasTextContext::createDrawTextBlob(const GrClip& clip,
                                        const GrPaint& paint, const SkPaint& skPaint,
                                        const SkMatrix& viewMatrix,
                                        const char text[], size_t byteLength,
                                        SkScalar x, SkScalar y, const SkIRect& regionClipBounds) {
@@ skipping 344 matching lines @@
 
     // If the glyph is too large we fall back to paths
     if (glyph->fTooLargeForAtlas) {
         this->appendGlyphPath(blob, glyph, scaler, skGlyph, SkIntToScalar(vx), SkIntToScalar(vy));
         return;
     }
 
     GrMaskFormat format = glyph->fMaskFormat;
 
     PerSubRunInfo* subRun = &run.fSubRunInfo.back();
-    if (run.fInitialized && subRun->fMaskFormat != format) {
+    if (run.fInitialized && subRun->maskFormat() != format) {
         subRun = &run.push_back();
-        subRun->fStrike.reset(SkRef(fCurrStrike));
+        subRun->setStrike(fCurrStrike);
     } else if (!run.fInitialized) {
-        subRun->fStrike.reset(SkRef(fCurrStrike));
+        subRun->setStrike(SkRef(fCurrStrike));
     }
 
     run.fInitialized = true;
 
     size_t vertexStride = GrAtlasTextBatch::GetVertexStride(format);
 
     SkRect r;
     r.fLeft = SkIntToScalar(x);
     r.fTop = SkIntToScalar(y);
     r.fRight = r.fLeft + SkIntToScalar(width);
     r.fBottom = r.fTop + SkIntToScalar(height);
-    subRun->fMaskFormat = format;
+    subRun->setMaskFormat(format);
     this->appendGlyphCommon(blob, &run, subRun, r, color, vertexStride, kA8_GrMaskFormat == format,
                             glyph);
 }
 
 bool GrAtlasTextContext::dfAppendGlyph(GrAtlasTextBlob* blob, int runIndex,
                                        const SkGlyph& skGlyph,
                                        SkScalar sx, SkScalar sy, GrColor color,
                                        GrFontScaler* scaler,
                                        SkScalar textRatio, const SkMatrix& viewMatrix) {
     Run& run = blob->fRuns[runIndex];
@@ skipping 31 matching lines @@
 
     // TODO combine with the above
     // If the glyph is too large we fall back to paths
     if (glyph->fTooLargeForAtlas) {
         this->appendGlyphPath(blob, glyph, scaler, skGlyph, sx - dx, sy - dy, scale, true);
         return true;
     }
 
     PerSubRunInfo* subRun = &run.fSubRunInfo.back();
     if (!run.fInitialized) {
-        subRun->fStrike.reset(SkRef(fCurrStrike));
+        subRun->setStrike(fCurrStrike);
     }
     run.fInitialized = true;
     SkASSERT(glyph->fMaskFormat == kA8_GrMaskFormat);
-    subRun->fMaskFormat = kA8_GrMaskFormat;
+    subRun->setMaskFormat(kA8_GrMaskFormat);
 
     size_t vertexStride = GrAtlasTextBatch::GetVertexStrideDf(kA8_GrMaskFormat,
-                                                              subRun->fUseLCDText);
+                                                              subRun->hasUseLCDText());
 
-    bool useColorVerts = !subRun->fUseLCDText;
+    bool useColorVerts = !subRun->hasUseLCDText();
     this->appendGlyphCommon(blob, &run, subRun, glyphRect, color, vertexStride, useColorVerts,
                             glyph);
     return true;
 }
 
 inline void GrAtlasTextContext::appendGlyphPath(GrAtlasTextBlob* blob, GrGlyph* glyph,
                                                 GrFontScaler* scaler, const SkGlyph& skGlyph,
                                                 SkScalar x, SkScalar y, SkScalar scale,
                                                 bool applyVM) {
     if (nullptr == glyph->fPath) {
         const SkPath* glyphPath = scaler->getGlyphPath(skGlyph);
         if (!glyphPath) {
             return;
         }
 
         glyph->fPath = new SkPath(*glyphPath);
     }
     blob->fBigGlyphs.push_back(GrAtlasTextBlob::BigGlyph(*glyph->fPath, x, y, scale, applyVM));
 }
 
 inline void GrAtlasTextContext::appendGlyphCommon(GrAtlasTextBlob* blob, Run* run,
                                                   Run::SubRunInfo* subRun,
                                                   const SkRect& positions, GrColor color,
                                                   size_t vertexStride, bool useVertexColor,
                                                   GrGlyph* glyph) {
-    blob->fGlyphs[subRun->fGlyphEndIndex] = glyph;
+    blob->appendGlyph(subRun, glyph);
     run->fVertexBounds.joinNonEmptyArg(positions);
     run->fColor = color;
 
-    intptr_t vertex = reinterpret_cast<intptr_t>(blob->fVertices + subRun->fVertexEndIndex);
+    intptr_t vertex = reinterpret_cast<intptr_t>(blob->fVertices + subRun->vertexEndIndex());
 
     if (useVertexColor) {
         // V0
         SkPoint* position = reinterpret_cast<SkPoint*>(vertex);
         position->set(positions.fLeft, positions.fTop);
         SkColor* colorPtr = reinterpret_cast<SkColor*>(vertex + sizeof(SkPoint));
         *colorPtr = color;
         vertex += vertexStride;
 
         // V1
@@ skipping 28 matching lines @@
 
         // V2
         position = reinterpret_cast<SkPoint*>(vertex);
         position->set(positions.fRight, positions.fBottom);
         vertex += vertexStride;
 
         // V3
         position = reinterpret_cast<SkPoint*>(vertex);
         position->set(positions.fRight, positions.fTop);
     }
-
-    subRun->fGlyphEndIndex++;
-    subRun->fVertexEndIndex += vertexStride * GrAtlasTextBatch::kVerticesPerGlyph;
+    subRun->appendVertices(vertexStride);
 }
 
 void GrAtlasTextContext::flushRunAsPaths(GrDrawContext* dc,
                                          const SkTextBlobRunIterator& it,
                                          const GrClip& clip, const SkPaint& skPaint,
                                          SkDrawFilter* drawFilter, const SkMatrix& viewMatrix,
                                          const SkIRect& clipBounds, SkScalar x, SkScalar y) {
     SkPaint runPaint = skPaint;
 
     size_t textLen = it.glyphCount() * sizeof(uint16_t);
@@ skipping 25 matching lines @@
                                     textLen, it.pos(), 2, SkPoint::Make(x, y), clipBounds);
             break;
     }
 }
 
 inline GrDrawBatch*
 GrAtlasTextContext::createBatch(GrAtlasTextBlob* cacheBlob, const PerSubRunInfo& info,
                                 int glyphCount, int run, int subRun,
                                 GrColor color, SkScalar transX, SkScalar transY,
                                 const SkPaint& skPaint) {
-    GrMaskFormat format = info.fMaskFormat;
+    GrMaskFormat format = info.maskFormat();
     GrColor subRunColor;
     if (kARGB_GrMaskFormat == format) {
         uint8_t paintAlpha = skPaint.getAlpha();
         subRunColor = SkColorSetARGB(paintAlpha, paintAlpha, paintAlpha, paintAlpha);
     } else {
         subRunColor = color;
     }
 
     GrAtlasTextBatch* batch;
-    if (info.fDrawAsDistanceFields) {
+    if (info.drawAsDistanceFields()) {
         SkColor filteredColor;
         SkColorFilter* colorFilter = skPaint.getColorFilter();
         if (colorFilter) {
             filteredColor = colorFilter->filterColor(skPaint.getColor());
         } else {
             filteredColor = skPaint.getColor();
         }
         bool useBGR = SkPixelGeometryIsBGR(fSurfaceProps.pixelGeometry());
         batch = GrAtlasTextBatch::CreateDistanceField(glyphCount, fContext->getBatchFontCache(),
                                                       fDistanceAdjustTable, filteredColor,
-                                                      info.fUseLCDText, useBGR);
+                                                      info.hasUseLCDText(), useBGR);
     } else {
         batch = GrAtlasTextBatch::CreateBitmap(format, glyphCount, fContext->getBatchFontCache());
     }
     GrAtlasTextBatch::Geometry& geometry = batch->geometry();
     geometry.fBlob = SkRef(cacheBlob);
     geometry.fRun = run;
     geometry.fSubRun = subRun;
     geometry.fColor = subRunColor;
     geometry.fTransX = transX;
     geometry.fTransY = transY;
     batch->init();
 
     return batch;
 }
 
 inline void GrAtlasTextContext::flushRun(GrDrawContext* dc, GrPipelineBuilder* pipelineBuilder,
                                          GrAtlasTextBlob* cacheBlob, int run, GrColor color,
                                          SkScalar transX, SkScalar transY,
                                          const SkPaint& skPaint) {
     for (int subRun = 0; subRun < cacheBlob->fRuns[run].fSubRunInfo.count(); subRun++) {
         const PerSubRunInfo& info = cacheBlob->fRuns[run].fSubRunInfo[subRun];
-        int glyphCount = info.fGlyphEndIndex - info.fGlyphStartIndex;
+        int glyphCount = info.glyphCount();
         if (0 == glyphCount) {
             continue;
         }
 
         SkAutoTUnref<GrDrawBatch> batch(this->createBatch(cacheBlob, info, glyphCount, run,
                                                           subRun, color, transX, transY,
                                                           skPaint));
         dc->drawBatch(pipelineBuilder, batch);
     }
 }
@@ skipping 119 matching lines @@
             gTextContext->createDrawTextBlob(clip, grPaint, skPaint, viewMatrix, text,
                                              static_cast<size_t>(textLen), 0, 0, noClip));
 
     SkScalar transX = static_cast<SkScalar>(random->nextU());
     SkScalar transY = static_cast<SkScalar>(random->nextU());
     const GrAtlasTextBlob::Run::SubRunInfo& info = blob->fRuns[0].fSubRunInfo[0];
     return gTextContext->createBatch(blob, info, textLen, 0, 0, color, transX, transY, skPaint);
 }
 
 #endif