Gradient shaders: make fPtsToUnit const, pre-cache getType().

src/effects/gradients/SkTwoPointRadialGradient.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkTwoPointRadialGradient.h"
 
@@ skipping 149 matching lines @@
         *dstC++ = cache[index >> SkGradientShaderBase::kCache32Shift];
         fx += dx;
         fy += dy;
         b += db;
     }
 }
 }
 
 /////////////////////////////////////////////////////////////////////
 
+static SkMatrix pts_to_unit(const SkPoint& start, SkScalar diffRadius) {
+    SkScalar inv = diffRadius ? SkScalarInvert(diffRadius) : 0;
+    SkMatrix matrix;
+    matrix.setTranslate(-start.fX, -start.fY);
+    matrix.postScale(inv, inv);
+    return matrix;
+}
+
 SkTwoPointRadialGradient::SkTwoPointRadialGradient(const SkPoint& start, SkScalar startRadius,
                                                    const SkPoint& end, SkScalar endRadius,
                                                    const Descriptor& desc)
-    : SkGradientShaderBase(desc)
+    : SkGradientShaderBase(desc, pts_to_unit(start, endRadius - startRadius))
     , fCenter1(start)
     , fCenter2(end)
     , fRadius1(startRadius)
     , fRadius2(endRadius)
 {
-    init();
+    fDiff = fCenter1 - fCenter2;
+    fDiffRadius = fRadius2 - fRadius1;
+    // hack to avoid zero-divide for now
+    SkScalar inv = fDiffRadius ? SkScalarInvert(fDiffRadius) : 0;
+    fDiff.fX = SkScalarMul(fDiff.fX, inv);
+    fDiff.fY = SkScalarMul(fDiff.fY, inv);
+    fStartRadius = SkScalarMul(fRadius1, inv);
+    fSr2D2 = SkScalarSquare(fStartRadius);
+    fA = SkScalarSquare(fDiff.fX) + SkScalarSquare(fDiff.fY) - SK_Scalar1;
+    fOneOverTwoA = fA ? SkScalarInvert(fA * 2) : 0;
 }
 
 SkShader::BitmapType SkTwoPointRadialGradient::asABitmap(
     SkBitmap* bitmap,
     SkMatrix* matrix,
     SkShader::TileMode* xy) const {
     if (bitmap) {
         this->getGradientTableBitmap(bitmap);
     }
     SkScalar diffL = 0; // just to avoid gcc warning
@@ skipping 169 matching lines @@
 
 void SkTwoPointRadialGradient::flatten(
     SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     buffer.writePoint(fCenter1);
     buffer.writePoint(fCenter2);
     buffer.writeScalar(fRadius1);
     buffer.writeScalar(fRadius2);
 }
 
-void SkTwoPointRadialGradient::init() {
-    fDiff = fCenter1 - fCenter2;
-    fDiffRadius = fRadius2 - fRadius1;
-    // hack to avoid zero-divide for now
-    SkScalar inv = fDiffRadius ? SkScalarInvert(fDiffRadius) : 0;
-    fDiff.fX = SkScalarMul(fDiff.fX, inv);
-    fDiff.fY = SkScalarMul(fDiff.fY, inv);
-    fStartRadius = SkScalarMul(fRadius1, inv);
-    fSr2D2 = SkScalarSquare(fStartRadius);
-    fA = SkScalarSquare(fDiff.fX) + SkScalarSquare(fDiff.fY) - SK_Scalar1;
-    fOneOverTwoA = fA ? SkScalarInvert(fA * 2) : 0;
-
-    fPtsToUnit.setTranslate(-fCenter1.fX, -fCenter1.fY);
-    fPtsToUnit.postScale(inv, inv);
-}
-
 /////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
 
 #include "SkGr.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 
 // For brevity
 typedef GrGLProgramDataManager::UniformHandle UniformHandle;
 
@@ skipping 315 matching lines @@
 
 #else
 
 bool SkTwoPointRadialGradient::asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix*,
                                                    GrColor*, GrFragmentProcessor**)  const {
     SkDEBUGFAIL("Should not call in GPU-less build");
     return false;
 }
 
 #endif