initial changes to add local matrix to primitive processor

src/gpu/GrStencilAndCoverTextContext.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrStencilAndCoverTextContext.h"
 #include "GrBitmapTextContext.h"
 #include "GrDrawTarget.h"
@@ skipping 216 matching lines @@
 
 void GrStencilAndCoverTextContext::init(const GrPaint& paint,
                                         const SkPaint& skPaint,
                                         size_t textByteLength,
                                         RenderMode renderMode,
                                         const SkMatrix& viewMatrix) {
     GrTextContext::init(paint, skPaint);
 
     fContextInitialMatrix = viewMatrix;
     fViewMatrix = viewMatrix;
+    fLocalMatrix = SkMatrix::I();
 
     const bool otherBackendsWillDrawAsPaths =
         SkDraw::ShouldDrawTextAsPaths(skPaint, fContextInitialMatrix);
 
     fUsingDeviceSpaceGlyphs = !otherBackendsWillDrawAsPaths &&
                               kMaxAccuracy_RenderMode == renderMode &&
                               SkToBool(fContextInitialMatrix.getType() &
                                        (SkMatrix::kScale_Mask | SkMatrix::kAffine_Mask));
 
     if (fUsingDeviceSpaceGlyphs) {
         // SkDraw::ShouldDrawTextAsPaths takes care of perspective transforms.
         SkASSERT(!fContextInitialMatrix.hasPerspective());
 
         // The whole shape (including stroke) will be baked into the glyph outlines. Make
         // NVPR just fill the baked shapes.
         fStroke = SkStrokeRec(SkStrokeRec::kFill_InitStyle);
 
         fTextRatio = fTextInverseRatio = 1.0f;
 
         // Glyphs loaded by GPU path rendering have an inverted y-direction.
         SkMatrix m;
         m.setScale(1, -1);
         fViewMatrix = m;
 
         // Post-flip the initial matrix so we're left with just the flip after
         // the paint preConcats the inverse.
         m = fContextInitialMatrix;
         m.postScale(1, -1);
-        fPaint.localCoordChangeInverse(m);
+        if (!m.invert(&fLocalMatrix)) {
+            SkDebugf("Not invertible!\n");
+            return;
+        }
 
         fGlyphCache = fSkPaint.detachCache(&fDeviceProperties, &fContextInitialMatrix,
                                            true /*ignoreGamma*/);
         fGlyphs = get_gr_glyphs(fContext, fGlyphCache->getScalerContext()->getTypeface(),
                                 &fGlyphCache->getDescriptor(), fStroke);
     } else {
         // Don't bake strokes into the glyph outlines. We will stroke the glyphs
         // using the GPU instead. This is the fast path.
         fStroke = SkStrokeRec(fSkPaint);
         fSkPaint.setStyle(SkPaint::kFill_Style);
@@ skipping 48 matching lines @@
                              !fSkPaint.isFakeBoldText() &&
                              !fSkPaint.isVerticalText();
         } else {
             fTextRatio = fTextInverseRatio = 1.0f;
             canUseRawPaths = false;
         }
 
         SkMatrix textMatrix;
         // Glyphs loaded by GPU path rendering have an inverted y-direction.
         textMatrix.setScale(fTextRatio, -fTextRatio);
-        fPaint.localCoordChange(textMatrix);
         fViewMatrix.preConcat(textMatrix);
+        fLocalMatrix = textMatrix;
 
         fGlyphCache = fSkPaint.detachCache(&fDeviceProperties, NULL, true /*ignoreGamma*/);
         fGlyphs = canUseRawPaths ?
                       get_gr_glyphs(fContext, fSkPaint.getTypeface(), NULL, fStroke) :
                       get_gr_glyphs(fContext, fGlyphCache->getScalerContext()->getTypeface(),
                                     &fGlyphCache->getDescriptor(), fStroke);
     }
 
     fStateRestore.set(&fDrawState);
 
@@ skipping 49 matching lines @@
 
 static const SkScalar* get_xy_scalar_array(const SkPoint* pointArray) {
     GR_STATIC_ASSERT(2 * sizeof(SkScalar) == sizeof(SkPoint));
     GR_STATIC_ASSERT(0 == offsetof(SkPoint, fX));
 
     return &pointArray[0].fX;
 }
 
 void GrStencilAndCoverTextContext::flush() {
     if (fQueuedGlyphCount > 0) {
-        SkAutoTUnref<GrPathProcessor> pp(GrPathProcessor::Create(fPaint.getColor()));
+        SkAutoTUnref<GrPathProcessor> pp(GrPathProcessor::Create(fPaint.getColor(), fLocalMatrix));
         fDrawTarget->drawPaths(&fDrawState, pp, fGlyphs,
                                fGlyphIndices, GrPathRange::kU16_PathIndexType,
                                get_xy_scalar_array(fGlyphPositions),
                                GrPathRendering::kTranslate_PathTransformType,
                                fQueuedGlyphCount, GrPathRendering::kWinding_FillType);
 
         fQueuedGlyphCount = 0;
     }
 
     if (fFallbackGlyphsIdx < kGlyphBufferSize) {
         int fallbackGlyphCount = kGlyphBufferSize - fFallbackGlyphsIdx;
 
         GrPaint paintFallback(fPaint);
 
         SkPaint skPaintFallback(fSkPaint);
         if (!fUsingDeviceSpaceGlyphs) {
             fStroke.applyToPaint(&skPaintFallback);
         }
         skPaintFallback.setTextAlign(SkPaint::kLeft_Align); // Align has already been accounted for.
         skPaintFallback.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
 
         SkMatrix inverse;
         if (this->mapToFallbackContext(&inverse)) {
-            paintFallback.localCoordChangeInverse(inverse);
             inverse.mapPoints(&fGlyphPositions[fFallbackGlyphsIdx], fallbackGlyphCount);
         }
 
         fFallbackTextContext->drawPosText(paintFallback, skPaintFallback, fViewMatrix,
                                           (char*)&fGlyphIndices[fFallbackGlyphsIdx],
                                           2 * fallbackGlyphCount,
                                           get_xy_scalar_array(&fGlyphPositions[fFallbackGlyphsIdx]),
                                           2, SkPoint::Make(0, 0));
 
         fFallbackGlyphsIdx = kGlyphBufferSize;
     }
 }
 
 void GrStencilAndCoverTextContext::finish() {
     this->flush();
 
     fGlyphs->unref();
     fGlyphs = NULL;
 
     SkGlyphCache::AttachCache(fGlyphCache);
     fGlyphCache = NULL;
 
     fDrawState.stencil()->setDisabled();
     fStateRestore.set(NULL);
     fViewMatrix = fContextInitialMatrix;
     GrTextContext::finish();
 }