GPU Gradients

src/effects/gradients/SkTwoPointConicalGradient.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 "SkTwoPointConicalGradient.h"
 
 static int valid_divide(float numer, float denom, float* ratio) {
@@ skipping 479 matching lines @@
                                     const GrDrawEffect&,
                                     EffectKey key,
                                     const char* outputColor,
                                     const char* inputColor,
                                     const TextureSamplerArray& samplers) {
     const char* fsCoords;
     const char* vsCoordsVarying;
     GrSLType coordsVaryingType;
     this->setupMatrix(builder, key, &fsCoords, &vsCoordsVarying, &coordsVaryingType);
 
-    this->emitYCoordUniform(builder);
+    this->emitUniforms(builder, key);
     // 2 copies of uniform array, 1 for each of vertex & fragment shader,
     // to work around Xoom bug. Doesn't seem to cause performance decrease
     // in test apps, but need to keep an eye on it.
     fVSParamUni = builder->addUniformArray(GrGLShaderBuilder::kVertex_ShaderType,
                                            kFloat_GrSLType, "Conical2VSParams", 6);
     fFSParamUni = builder->addUniformArray(GrGLShaderBuilder::kFragment_ShaderType,
                                            kFloat_GrSLType, "Conical2FSParams", 6);
 
     // For radial gradients without perspective we can pass the linear
     // part of the quadratic as a varying.
@@ skipping 99 matching lines @@
 
             // so we'll look at the larger one first:
             builder->fsCodeAppendf("\t\tfloat %s = max(%s, %s);\n", tName.c_str(),
                                    r0Name.c_str(), r1Name.c_str());
 
             // if r(t) > 0, then we're done; t will be our x coordinate
             builder->fsCodeAppendf("\t\tif (%s * %s + %s > 0.0) {\n", tName.c_str(),
                                    p5.c_str(), p3.c_str());
 
             builder->fsCodeAppend("\t\t");
-            this->emitColorLookup(builder, tName.c_str(), outputColor, inputColor, samplers[0]);
+            this->emitColor(builder, tName.c_str(), key, outputColor, inputColor, samplers);
 
             // otherwise, if r(t) for the larger root was <= 0, try the other root
             builder->fsCodeAppend("\t\t} else {\n");
             builder->fsCodeAppendf("\t\t\t%s = min(%s, %s);\n", tName.c_str(),
                                    r0Name.c_str(), r1Name.c_str());
 
             // if r(t) > 0 for the smaller root, then t will be our x coordinate
             builder->fsCodeAppendf("\t\t\tif (%s * %s + %s > 0.0) {\n",
                                    tName.c_str(), p5.c_str(), p3.c_str());
 
             builder->fsCodeAppend("\t\t\t");
-            this->emitColorLookup(builder, tName.c_str(), outputColor, inputColor, samplers[0]);
+            this->emitColor(builder, tName.c_str(), key, outputColor, inputColor, samplers);
 
             // end if (r(t) > 0) for smaller root
             builder->fsCodeAppend("\t\t\t}\n");
             // end if (r(t) > 0), else, for larger root
             builder->fsCodeAppend("\t\t}\n");
             // end if (discriminant >= 0)
             builder->fsCodeAppend("\t}\n");
         } else {
 
             // linear case: t = -c/b
             builder->fsCodeAppendf("\tfloat %s = -(%s / %s);\n", tName.c_str(),
                                    cName.c_str(), bVar.c_str());
 
             // if r(t) > 0, then t will be the x coordinate
             builder->fsCodeAppendf("\tif (%s * %s + %s > 0.0) {\n", tName.c_str(),
                                    p5.c_str(), p3.c_str());
             builder->fsCodeAppend("\t");
-            this->emitColorLookup(builder, tName.c_str(), outputColor, inputColor, samplers[0]);
+            this->emitColor(builder, tName.c_str(), key, outputColor, inputColor, samplers);
             builder->fsCodeAppend("\t}\n");
         }
     }
 }
 
 void GrGLConical2Gradient::setData(const GrGLUniformManager& uman,
                                    const GrDrawEffect& drawEffect) {
     INHERITED::setData(uman, drawEffect);
     const GrConical2Gradient& data = drawEffect.castEffect<GrConical2Gradient>();
     GrAssert(data.isDegenerate() == fIsDegenerate);
@@ skipping 28 matching lines @@
         fCachedDiffRadius = diffRadius;
     }
 }
 
 GrGLEffect::EffectKey GrGLConical2Gradient::GenKey(const GrDrawEffect& drawEffect,
                                                    const GrGLCaps&) {
     enum {
         kIsDegenerate = 1 << kMatrixKeyBitCnt,
     };
 
-    EffectKey key = GenMatrixKey(drawEffect);
+    EffectKey key = GenBaseGradientKey(drawEffect);
     if (drawEffect.castEffect<GrConical2Gradient>().isDegenerate()) {
         key |= kIsDegenerate;
     }
     return key;
 }
 
 /////////////////////////////////////////////////////////////////////
 
 GrEffectRef* SkTwoPointConicalGradient::asNewEffect(GrContext* context, const SkPaint&) const {
     SkASSERT(NULL != context);
@@ skipping 45 matching lines @@
     str->appendScalar(fCenter2.fY);
     str->append(") radius2: ");
     str->appendScalar(fRadius2);
     str->append(" ");
 
     this->INHERITED::toString(str);
 
     str->append(")");
 }
 #endif