add local-matrix to shader::context

src/core/SkDraw.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDraw.h"
 #include "SkBlitter.h"
 #include "SkBounder.h"
@@ skipping 2385 matching lines @@
     m.reset();
     m.set(0, pts[index1].fX - pts[index0].fX);
     m.set(1, pts[index2].fX - pts[index0].fX);
     m.set(2, pts[index0].fX);
     m.set(3, pts[index1].fY - pts[index0].fY);
     m.set(4, pts[index2].fY - pts[index0].fY);
     m.set(5, pts[index0].fY);
     if (!m.invert(&im)) {
         return false;
     }
-    fDstToUnit.setConcat(im, this->getTotalInverse());
+    SkMatrix ctmInv;
+    if (!this->getCTM().invert(&ctmInv)) {
+        return false;
+    }
+    fDstToUnit.setConcat(im, ctmInv);
     return true;
 }
 
 #include "SkColorPriv.h"
 #include "SkComposeShader.h"
 
 static int ScalarTo256(SkScalar v) {
     int scale = SkScalarToFixed(v) >> 8;
     if (scale < 0) {
         scale = 0;
@@ skipping 132 matching lines @@
     // Abort early if we failed to create a shader context.
     if (blitter->isNullBlitter()) {
         return;
     }
 
     // setup our state and function pointer for iterating triangles
     VertState       state(count, indices, indexCount);
     VertState::Proc vertProc = state.chooseProc(vmode);
 
     if (NULL != textures || NULL != colors) {
-        SkMatrix  tempM;
-        SkMatrix  savedLocalM;
-        if (shader) {
-            savedLocalM = shader->getLocalMatrix();
-        }
-
         while (vertProc(&state)) {
             if (NULL != textures) {
+                SkMatrix tempM;
                 if (texture_to_matrix(state, vertices, textures, &tempM)) {
-                    tempM.postConcat(savedLocalM);
-                    shader->setLocalMatrix(tempM);
-                    if (!blitter->resetShaderContext(*fBitmap, p, *fMatrix)) {
+                    SkShader::ContextRec rec(*fBitmap, p, *fMatrix);
+                    rec.fLocalMatrix = &tempM;
+                    if (!blitter->resetShaderContext(rec)) {

[Dominik Grewe, 2014/05/06 13:48:51]

'shader->setLocalMatrix()' is changing the LM of the paint's original shader.
This is not necessarily the shader referred to by the blitter. If we've created
the compose shader above, we're only changing the compose shader's LM but not
that of 'shader'.

[reed1, 2014/05/06 14:07:58]

Correct, but composeshader forwards that LM to its children, so we still draw
correctly.
Note that TriColorShader ignores *all* local-matrices (as it should).

                         continue;
                     }
                 }
             }
             if (NULL != colors) {
                 // Find the context for triShader.
                 SkTriColorShader::TriColorShaderContext* triColorShaderContext;
 
                 SkShader::Context* shaderContext = blitter->getShaderContext();
                 SkASSERT(shaderContext);
@@ skipping 15 matching lines @@
                                                   state.f0, state.f1, state.f2)) {
                     continue;
                 }
             }
 
             SkPoint tmp[] = {
                 devVerts[state.f0], devVerts[state.f1], devVerts[state.f2]
             };
             SkScan::FillTriangle(tmp, *fRC, blitter.get());
         }
-
-        // now restore the shader's original local matrix
-        if (NULL != shader) {
-            shader->setLocalMatrix(savedLocalM);
-        }
     } else {
         // no colors[] and no texture
         HairProc hairProc = ChooseHairProc(paint.isAntiAlias());
         const SkRasterClip& clip = *fRC;
         while (vertProc(&state)) {
             hairProc(devVerts[state.f0], devVerts[state.f1], clip, blitter.get());
             hairProc(devVerts[state.f1], devVerts[state.f2], clip, blitter.get());
             hairProc(devVerts[state.f2], devVerts[state.f0], clip, blitter.get());
         }
     }
@@ skipping 211 matching lines @@
         mask->fImage = SkMask::AllocImage(size);
         memset(mask->fImage, 0, mask->computeImageSize());
     }
 
     if (SkMask::kJustComputeBounds_CreateMode != mode) {
         draw_into_mask(*mask, devPath, style);
     }
 
     return true;
 }