Adds local coords to GrEffect system.

include/gpu/GrPaint.h

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef GrPaint_DEFINED
@@ skipping 151 matching lines @@
         for (int i = 0; i < kMaxColorStages; ++i) {
             if (this->isColorStageEnabled(i)) {
                 return true;
             }
         }
         return false;
     }
 
     bool hasStage() const { return this->hasColorStage() || this->hasCoverageStage(); }
 
-    /**
-     * Called when the source coord system is changing. preConcatInverse is the inverse of the
-     * transformation from the old coord system to the new coord system. Returns false if the matrix
-     * cannot be inverted.
-     */
-    bool sourceCoordChangeByInverse(const SkMatrix& preConcatInverse) {
-        SkMatrix inv;
-        bool computed = false;
-        for (int i = 0; i < kMaxColorStages; ++i) {
-            if (this->isColorStageEnabled(i)) {
-                if (!computed && !preConcatInverse.invert(&inv)) {
-                    return false;
-                } else {
-                    computed = true;
-                }
-                fColorStages[i].preConcatCoordChange(inv);
-            }
-        }
-        for (int i = 0; i < kMaxCoverageStages; ++i) {
-            if (this->isCoverageStageEnabled(i)) {
-                if (!computed && !preConcatInverse.invert(&inv)) {
-                    return false;
-                } else {
-                    computed = true;
-                }
-                fCoverageStages[i].preConcatCoordChange(inv);
-            }
-        }
-        return true;
-    }
-
-    /**
-     * Called when the source coord system is changing. preConcat gives the transformation from the
-     * old coord system to the new coord system.
-     */
-    void sourceCoordChange(const SkMatrix& preConcat) {
-        for (int i = 0; i < kMaxColorStages; ++i) {
-            if (this->isColorStageEnabled(i)) {
-                fColorStages[i].preConcatCoordChange(preConcat);
-            }
-        }
-        for (int i = 0; i < kMaxCoverageStages; ++i) {
-            if (this->isCoverageStageEnabled(i)) {
-                fCoverageStages[i].preConcatCoordChange(preConcat);
-            }
-        }
-    }
-
     GrPaint& operator=(const GrPaint& paint) {
         fSrcBlendCoeff = paint.fSrcBlendCoeff;
         fDstBlendCoeff = paint.fDstBlendCoeff;
         fAntiAlias = paint.fAntiAlias;
         fDither = paint.fDither;
 
         fColor = paint.fColor;
         fCoverage = paint.fCoverage;
 
         fColorFilterColor = paint.fColorFilterColor;
@@ skipping 27 matching lines @@
     // internal use
     // GrPaint's textures and masks map to the first N stages
     // of GrDrawTarget in that order (textures followed by masks)
     enum {
         kFirstColorStage = 0,
         kFirstCoverageStage = kMaxColorStages,
         kTotalStages = kFirstColorStage + kMaxColorStages + kMaxCoverageStages,
     };
 
 private:
+    /**
+     * Called when the source coord system from which geometry is rendered changes. It ensures that
+     * the local coordinates seen by effects remains unchanged. oldToNew gives the transformation
+     * from the previous coord system to the new coord system.
+     */
+    void localCoordChange(const SkMatrix& oldToNew) {
+        for (int i = 0; i < kMaxColorStages; ++i) {
+            if (this->isColorStageEnabled(i)) {
+                fColorStages[i].localCoordChange(oldToNew);
+            }
+        }
+        for (int i = 0; i < kMaxCoverageStages; ++i) {
+            if (this->isCoverageStageEnabled(i)) {
+                fCoverageStages[i].localCoordChange(oldToNew);
+            }
+        }
+    }
+
+    bool localCoordChangeInverse(const SkMatrix& newToOld) {
+        SkMatrix oldToNew;
+        bool computed = false;
+        for (int i = 0; i < kMaxColorStages; ++i) {
+            if (this->isColorStageEnabled(i)) {
+                if (!computed && !newToOld.invert(&oldToNew)) {
+                    return false;
+                } else {
+                    computed = true;
+                }
+                fColorStages[i].localCoordChange(oldToNew);
+            }
+        }
+        for (int i = 0; i < kMaxCoverageStages; ++i) {
+            if (this->isCoverageStageEnabled(i)) {
+                if (!computed && !newToOld.invert(&oldToNew)) {
+                    return false;
+                } else {
+                    computed = true;
+                }
+                fCoverageStages[i].localCoordChange(oldToNew);
+            }
+        }
+        return true;
+    }
+
+    friend GrContext; // To access above two functions
 
     GrEffectStage               fColorStages[kMaxColorStages];
     GrEffectStage               fCoverageStages[kMaxCoverageStages];
 
     GrBlendCoeff                fSrcBlendCoeff;
     GrBlendCoeff                fDstBlendCoeff;
     bool                        fAntiAlias;
     bool                        fDither;
 
     GrColor                     fColor;
@@ skipping 24 matching lines @@
         for (int i = 0; i < kMaxColorStages; ++i) {
             fColorStages[i].reset();
         }
         for (int i = 0; i < kMaxCoverageStages; ++i) {
             fCoverageStages[i].reset();
         }
     }
 };
 
 #endif