GPU Gradients

src/effects/gradients/SkGradientShaderPriv.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkGradientShaderPriv_DEFINED
 #define SkGradientShaderPriv_DEFINED
 
@@ skipping 231 matching lines @@
                      const SkGradientShaderBase& shader,
                      const SkMatrix& matrix,
                      SkShader::TileMode tileMode);
 
     virtual ~GrGradientEffect();
 
     bool useAtlas() const { return SkToBool(-1 != fRow); }
     SkScalar getYCoord() const { return fYCoord; };
     const SkMatrix& getMatrix() const { return fMatrix;}
 
+    int numColors;

[reed1, 2013/08/13 12:33:41]

nit:
- does this guy really need to be public?
- why not name it fNumColors?

[dierk, 2013/08/13 19:50:17]

Done.

+
     virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
 
 protected:
 
     /** Populates a pair of arrays with colors and stop info to construct a random gradient.
         The function decides whether stop values should be used or not. The return value indicates
         the number of colors, which will be capped by kMaxRandomGradientColors. colors should be
         sized to be at least kMaxRandomGradientColors. stops is a pointer to an array of at least
         size kMaxRandomGradientColors. It may be updated to NULL, indicating that NULL should be
         passed to the gradient factory rather than the array.
@@ skipping 32 matching lines @@
 protected:
     /**
      * Subclasses must reserve the lower kMatrixKeyBitCnt of their key for use by
      * GrGLGradientEffect.
      */
     enum {
         kMatrixKeyBitCnt = GrGLEffectMatrix::kKeyBits,
         kMatrixKeyMask = (1 << kMatrixKeyBitCnt) - 1,
     };
 
+    static inline bool is2Color(const GrGradientEffect& e){

[bsalomon, 2013/08/13 14:28:37]

How about an enum named ColorType (or something like that) and values like
kTwoColor, kThreeColor, kTexture and have two functions (one for
GrGradientEffect and one for EffectKey) that return the type.

style-nit: static members have initial caps

Can you make the key values (0x4000 and 0x6000) enum values alongside
kMatrixKeyBitCnt above?  It might also be good to define them in terms of
kMatrixKeyBitCnt to ensure that they don't collide should
GrGLEffectMatrix::kKeyBits ever change.

[dierk, 2013/08/13 19:50:17]

Done.

+        return e.numColors == 2;
+    }
+    static inline bool is3Color(const GrGradientEffect& e){
+        return e.numColors == 3;
+    }
+
+    static inline bool is2Color(const EffectKey key){
+        return (key & 0x4000) == 0x4000;
+    }
+    static inline bool is3Color(const EffectKey key){
+        return (key & 0x6000) == 0x6000;
+    }
+    
+    
     /**
      * Subclasses must call this. It will return a value restricted to the lower kMatrixKeyBitCnt
      * bits.
      */
     static EffectKey GenMatrixKey(const GrDrawEffect&);
 
     /**
      * Inserts code to implement the GrGradientEffect's matrix. This should be called before a
      * subclass emits its own code. The name of the 2D coords is output via fsCoordName and already
      * incorporates any perspective division. The caller can also optionally retrieve the name of
      * the varying inserted in the VS and its type, which may be either vec2f or vec3f depending
      * upon whether the matrix has perspective or not. It is not necessary to mask the key before
      * calling.
      */
     void setupMatrix(GrGLShaderBuilder* builder,
                      EffectKey key,
                      const char** fsCoordName,
                      const char** vsVaryingName = NULL,
                      GrSLType* vsVaryingType = NULL);
 
     // Emits the uniform used as the y-coord to texture samples in derived classes. Subclasses
     // should call this method from their emitCode().
-    void emitYCoordUniform(GrGLShaderBuilder* builder);
+    void emitUniforms(GrGLShaderBuilder* builder, EffectKey key);
 
-    // emit code that gets a fragment's color from an expression for t; for now this always uses the
-    // texture, but for simpler cases we'll be able to lerp. Subclasses should call this method from
+
+    // emit code that gets a fragment's color from an expression for t; Only used if 4 or more

[bsalomon, 2013/08/13 14:28:37]

Do you mean the sampler array is only used for 4+? It seems like this function
is still called for all cases by the subclasses.

[dierk, 2013/08/13 19:50:17]

Done.

+    // colors, a simpler lerp is used for 2 and 3 colors. Subclasses should call this method from
     // their emitCode().
-    void emitColorLookup(GrGLShaderBuilder* builder,
-                         const char* gradientTValue,
-                         const char* outputColor,
-                         const char* inputColor,
-                         const GrGLShaderBuilder::TextureSampler&);
+    void emitColor(GrGLShaderBuilder* builder,
+                   const char* gradientTValue,
+                   EffectKey key,
+                   const char* outputColor,
+                   const char* inputColor,
+                   const GrGLShaderBuilder::TextureSamplerArray& samplers);
 
 private:
     static const GrEffect::CoordsType kCoordsType = GrEffect::kLocal_CoordsType;
 
     SkScalar fCachedYCoord;
     GrGLUniformManager::UniformHandle fFSYUni;
+    GrGLUniformManager::UniformHandle fColorStartUni;
+    GrGLUniformManager::UniformHandle fColorMidUni;
+    GrGLUniformManager::UniformHandle fColorEndUni;
     GrGLEffectMatrix fEffectMatrix;
 
     typedef GrGLEffect INHERITED;
 };
 
 #endif
 
 #endif