Solo gp

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
 #define GrPaint_DEFINED
 
 #include "GrColor.h"
-#include "GrEffectStage.h"
+#include "GrProcessorStage.h"
 
 #include "SkXfermode.h"
 
 /**
  * The paint describes how color and coverage are computed at each pixel by GrContext draw
  * functions and the how color is blended with the destination pixel.
  *
  * The paint allows installation of custom color and coverage stages. New types of stages are
- * created by subclassing GrEffect.
+ * created by subclassing GrProcessor.
  *
  * The primitive color computation starts with the color specified by setColor(). This color is the
  * input to the first color stage. Each color stage feeds its output to the next color stage. The
  * final color stage's output color is input to the color filter specified by
  * setXfermodeColorFilter which produces the final source color, S.
  *
  * Fractional pixel coverage follows a similar flow. The coverage is initially the value specified
  * by setCoverage(). This is input to the first coverage stage. Coverage stages are chained
  * together in the same manner as color stages. The output of the last stage is modulated by any
  * fractional coverage produced by anti-aliasing. This last step produces the final coverage, C.
  *
  * setBlendFunc() specifies blending coefficients for S (described above) and D, the initial value
  * of the destination pixel, labeled Bs and Bd respectively. The final value of the destination
  * pixel is then D' = (1-C)*D + C*(Bd*D + Bs*S).
  *
  * Note that the coverage is applied after the blend. This is why they are computed as distinct
  * values.
  *
- * TODO: Encapsulate setXfermodeColorFilter in a GrEffect and remove from GrPaint.
+ * TODO: Encapsulate setXfermodeColorFilter in a GrProcessor and remove from GrPaint.
  */
 class GrPaint {
 public:
     GrPaint() { this->reset(); }
 
     GrPaint(const GrPaint& paint) { *this = paint; }
 
     ~GrPaint() {}
 
     /**
@@ skipping 25 matching lines @@
     void setAntiAlias(bool aa) { fAntiAlias = aa; }
     bool isAntiAlias() const { return fAntiAlias; }
 
     /**
      * Should dithering be applied. Defaults to false.
      */
     void setDither(bool dither) { fDither = dither; }
     bool isDither() const { return fDither; }
 
     /**
-     * Appends an additional color effect to the color computation.
+     * Appends an additional color processor to the color computation.
      */
-    const GrEffect* addColorEffect(const GrEffect* effect) {
-        SkASSERT(effect);
-        SkASSERT(!effect->requiresVertexShader());
-        if (!effect->willUseInputColor()) {
+    const GrFragmentProcessor* addColorProcessor(const GrFragmentProcessor* fp) {
+        SkASSERT(fp);
+        if (!fp->willUseInputColor()) {
             fColorStages.reset();
         }
-        SkNEW_APPEND_TO_TARRAY(&fColorStages, GrEffectStage, (effect));
-        return effect;
+        SkNEW_APPEND_TO_TARRAY(&fColorStages, GrProcessorStage, (fp));
+        return fp;
     }
 
     /**
-     * Appends an additional coverage effect to the coverage computation.
+     * Appends an additional coverage processor to the coverage computation.
      */
-    const GrEffect* addCoverageEffect(const GrEffect* effect) {
-        SkASSERT(effect);
-        SkASSERT(!effect->requiresVertexShader());
-        if (!effect->willUseInputColor()) {
+    const GrFragmentProcessor* addCoverageProcessor(const GrFragmentProcessor* fp) {
+        SkASSERT(fp);
+        if (!fp->willUseInputColor()) {
             fCoverageStages.reset();
         }
-        SkNEW_APPEND_TO_TARRAY(&fCoverageStages, GrEffectStage, (effect));
-        return effect;
+        SkNEW_APPEND_TO_TARRAY(&fCoverageStages, GrProcessorStage, (fp));
+        return fp;
     }
 
     /**
      * Helpers for adding color or coverage effects that sample a texture. The matrix is applied
      * to the src space position to compute texture coordinates.
      */
-    void addColorTextureEffect(GrTexture* texture, const SkMatrix& matrix);
-    void addCoverageTextureEffect(GrTexture* texture, const SkMatrix& matrix);
-
-    void addColorTextureEffect(GrTexture* texture,
-                               const SkMatrix& matrix,
-                               const GrTextureParams& params);
-    void addCoverageTextureEffect(GrTexture* texture,
-                                  const SkMatrix& matrix,
-                                  const GrTextureParams& params);
+    void addColorTextureProcessor(GrTexture*, const SkMatrix&);
+    void addCoverageTextureProcessor(GrTexture*, const SkMatrix&);
+    void addColorTextureProcessor(GrTexture*, const SkMatrix&, const GrTextureParams&);
+    void addCoverageTextureProcessor(GrTexture*, const SkMatrix&, const GrTextureParams&);
 
     int numColorStages() const { return fColorStages.count(); }
     int numCoverageStages() const { return fCoverageStages.count(); }
     int numTotalStages() const { return this->numColorStages() + this->numCoverageStages(); }
 
-    const GrEffectStage& getColorStage(int s) const { return fColorStages[s]; }
-    const GrEffectStage& getCoverageStage(int s) const { return fCoverageStages[s]; }
+    const GrFragmentStage& getColorStage(int s) const { return fColorStages[s]; }
+    const GrFragmentStage& getCoverageStage(int s) const { return fCoverageStages[s]; }
 
     GrPaint& operator=(const GrPaint& paint) {
         fSrcBlendCoeff = paint.fSrcBlendCoeff;
         fDstBlendCoeff = paint.fDstBlendCoeff;
         fAntiAlias = paint.fAntiAlias;
         fDither = paint.fDither;
 
         fColor = paint.fColor;
         fCoverage = paint.fCoverage;
 
@@ skipping 68 matching lines @@
                 computed = true;
             }
             fCoverageStages[i].localCoordChange(oldToNew);
         }
         return true;
     }
 
     friend class GrContext; // To access above two functions
     friend class GrStencilAndCoverTextContext;  // To access above two functions
 
-    SkSTArray<4, GrEffectStage> fColorStages;
-    SkSTArray<2, GrEffectStage> fCoverageStages;
+    SkSTArray<4, GrFragmentStage> fColorStages;
+    SkSTArray<2, GrFragmentStage> fCoverageStages;
 
     GrBlendCoeff                fSrcBlendCoeff;
     GrBlendCoeff                fDstBlendCoeff;
     bool                        fAntiAlias;
     bool                        fDither;
 
     GrColor                     fColor;
     uint8_t                     fCoverage;
 
     void resetBlend() {
@@ skipping 14 matching lines @@
         fCoverage = 0xff;
     }
 
     void resetStages() {
         fColorStages.reset();
         fCoverageStages.reset();
     }
 };
 
 #endif