Make text context responsible for setting GrPaint on GrDrawState.

src/gpu/GrTextContext.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 "GrTextContext.h"
 #include "GrAtlas.h"
 #include "GrContext.h"
 #include "GrDrawTarget.h"
 #include "GrFontScaler.h"
 #include "GrIndexBuffer.h"
 #include "GrTextStrike.h"
 #include "GrTextStrike_impl.h"
 #include "SkPath.h"
 #include "SkStrokeRec.h"
 
 // glyph rendering shares this stage with edge rendering (kEdgeEffectStage in GrContext) && SW path
 // rendering (kPathMaskStage in GrSWMaskHelper)
 static const int kGlyphMaskStage = GrPaint::kTotalStages;
 static const int kGlyphCoordsAttributeIndex = 1;
 
 void GrTextContext::flushGlyphs() {
     if (NULL == fDrawTarget) {
         return;
     }
+    GrDrawTarget::AutoStateRestore asr(fDrawTarget, GrDrawTarget::kPreserve_ASRInit);

[bsalomon, 2013/06/13 14:20:53]

This will be replaced by a lighter weight auto-restore in the final CL.

     GrDrawState* drawState = fDrawTarget->drawState();
+    drawState->setFromPaint(fPaint, SkMatrix::I(), fContext->getRenderTarget());
+
     if (fCurrVertex > 0) {
         // setup our sampler state for our text texture/atlas
         GrAssert(GrIsALIGN4(fCurrVertex));
         GrAssert(fCurrTexture);
         GrTextureParams params(SkShader::kRepeat_TileMode, false);
 
         // This effect could be stored with one of the cache objects (atlas?)
         drawState->setEffect(kGlyphMaskStage,
                              GrSimpleTextureEffect::CreateWithCustomCoords(fCurrTexture, params),
                              kGlyphCoordsAttributeIndex)->unref();
@@ skipping 20 matching lines @@
         fDrawTarget->setIndexSourceToBuffer(fContext->getQuadIndexBuffer());
         fDrawTarget->drawIndexedInstances(kTriangles_GrPrimitiveType,
                                           nGlyphs,
                                           4, 6);
         fDrawTarget->resetVertexSource();
         fVertices = NULL;
         fMaxVertices = 0;
         fCurrVertex = 0;
         GrSafeSetNull(fCurrTexture);
     }
-    drawState->disableStages();
-    fDrawTarget = NULL;
 }
 
 GrTextContext::GrTextContext(GrContext* context, const GrPaint& paint) : fPaint(paint) {
     fContext = context;
     fStrike = NULL;
 
     fCurrTexture = NULL;
     fCurrVertex = 0;
 
     const GrClipData* clipData = context->getClip();
 
     GrRect devConservativeBound;
     clipData->fClipStack->getConservativeBounds(
                                      -clipData->fOrigin.fX,
                                      -clipData->fOrigin.fY,
                                      context->getRenderTarget()->width(),
                                      context->getRenderTarget()->height(),
                                      &devConservativeBound);
 
     devConservativeBound.roundOut(&fClipRect);
 
     fAutoMatrix.setIdentity(fContext, &fPaint);
 
-    fDrawTarget = NULL;
+    fDrawTarget = fContext->getTextTarget();
 
     fVertices = NULL;
     fMaxVertices = 0;
 }
 
 GrTextContext::~GrTextContext() {
     this->flushGlyphs();
-    if (fDrawTarget) {
-        fDrawTarget->drawState()->disableStages();
-    }
 }
 
 void GrTextContext::flush() {
     this->flushGlyphs();
 }
 
 namespace {
 
 // position + texture coord
 extern const GrVertexAttrib gTextVertexAttribs[] = {
     {kVec2f_GrVertexAttribType, 0,               kPosition_GrVertexAttribBinding},
     {kVec2f_GrVertexAttribType, sizeof(GrPoint), kEffect_GrVertexAttribBinding}
 };
 
 };
 
 void GrTextContext::drawPackedGlyph(GrGlyph::PackedID packed,
                                     GrFixed vx, GrFixed vy,
                                     GrFontScaler* scaler) {
+    if (NULL == fDrawTarget) {
+        return;
+    }
     if (NULL == fStrike) {
         fStrike = fContext->getFontCache()->getStrike(scaler);
     }
 
     GrGlyph* glyph = fStrike->getGlyph(packed, scaler);
     if (NULL == glyph || glyph->fBounds.isEmpty()) {
         return;
     }
 
     vx += SkIntToFixed(glyph->fBounds.fLeft);
@@ skipping 61 matching lines @@
 
     if (fCurrTexture != texture || fCurrVertex + 4 > fMaxVertices) {
         this->flushGlyphs();
         fCurrTexture = texture;
         fCurrTexture->ref();
     }
 
     if (NULL == fVertices) {
        // If we need to reserve vertices allow the draw target to suggest
         // a number of verts to reserve and whether to perform a flush.
         fMaxVertices = kMinRequestedVerts;

[robertphillips, 2013/06/13 16:26:08]

overlength

-        bool flush = false;
-        fDrawTarget = fContext->getTextTarget(fPaint);
-        if (NULL != fDrawTarget) {
-            fDrawTarget->drawState()->setVertexAttribs<gTextVertexAttribs>(SK_ARRAY_COUNT(gTextVertexAttribs));
-            flush = fDrawTarget->geometryHints(&fMaxVertices, NULL);
-        }
+        fDrawTarget->drawState()->setVertexAttribs<gTextVertexAttribs>(SK_ARRAY_COUNT(gTextVertexAttribs));
+        bool flush = fDrawTarget->geometryHints(&fMaxVertices, NULL);
         if (flush) {
             this->flushGlyphs();
             fContext->flush();
-            // flushGlyphs() will reset fDrawTarget to NULL.
-            fDrawTarget = fContext->getTextTarget(fPaint);
             fDrawTarget->drawState()->setVertexAttribs<gTextVertexAttribs>(SK_ARRAY_COUNT(gTextVertexAttribs));
         }
         fMaxVertices = kDefaultRequestedVerts;
         // ignore return, no point in flushing again.
         fDrawTarget->geometryHints(&fMaxVertices, NULL);
 
         int maxQuadVertices = 4 * fContext->getQuadIndexBuffer()->maxQuads();
         if (fMaxVertices < kMinRequestedVerts) {
             fMaxVertices = kDefaultRequestedVerts;
         } else if (fMaxVertices > maxQuadVertices) {
             // don't exceed the limit of the index buffer
             fMaxVertices = maxQuadVertices;
         }
-        bool success = fDrawTarget->reserveVertexAndIndexSpace(
-                                                   fMaxVertices,
-                                                   0,
-                                                   GrTCast<void**>(&fVertices),
-                                                   NULL);
+        bool success = fDrawTarget->reserveVertexAndIndexSpace(fMaxVertices,
+                                                               0,
+                                                               GrTCast<void**>(&fVertices),
+                                                               NULL);
         GrAlwaysAssert(success);
         GrAssert(2*sizeof(GrPoint) == fDrawTarget->getDrawState().getVertexSize());
     }
 
     GrFixed tx = SkIntToFixed(glyph->fAtlasLocation.fX);
     GrFixed ty = SkIntToFixed(glyph->fAtlasLocation.fY);
 
     fVertices[2*fCurrVertex].setRectFan(SkFixedToFloat(vx),
                                         SkFixedToFloat(vy),
                                         SkFixedToFloat(vx + width),
                                         SkFixedToFloat(vy + height),
                                         2 * sizeof(SkPoint));
     fVertices[2*fCurrVertex+1].setRectFan(SkFixedToFloat(texture->normalizeFixedX(tx)),
                                           SkFixedToFloat(texture->normalizeFixedY(ty)),
                                           SkFixedToFloat(texture->normalizeFixedX(tx + width)),
                                           SkFixedToFloat(texture->normalizeFixedY(ty + height)),
                                           2 * sizeof(SkPoint));
     fCurrVertex += 4;
 }