Revert of Make all blending up to GrOptDrawState be handled by the xp/xp factory.

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 "GrFragmentStage.h"
 #include "GrXferProcessor.h"
-#include "effects/GrPorterDuffXferProcessor.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 GrProcessor.
  *
@@ skipping 18 matching lines @@
  */
 class GrPaint {
 public:
     GrPaint() { this->reset(); }
 
     GrPaint(const GrPaint& paint) { *this = paint; }
 
     ~GrPaint() {}
 
     /**
+     * Sets the blending coefficients to use to blend the final primitive color with the
+     * destination color. Defaults to kOne for src and kZero for dst (i.e. src mode).
+     */
+    void setBlendFunc(GrBlendCoeff srcCoeff, GrBlendCoeff dstCoeff) {
+        fSrcBlendCoeff = srcCoeff;
+        fDstBlendCoeff = dstCoeff;
+    }
+    GrBlendCoeff getSrcBlendCoeff() const { return fSrcBlendCoeff; }
+    GrBlendCoeff getDstBlendCoeff() const { return fDstBlendCoeff; }
+
+    /**
      * The initial color of the drawn primitive. Defaults to solid white.
      */
     void setColor(GrColor color) { fColor = color; }
     GrColor getColor() const { return fColor; }
 
     /**
      * Should primitives be anti-aliased or not. Defaults to false.
      */
     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; }
 
     const GrXPFactory* setXPFactory(const GrXPFactory* xpFactory) {
         fXPFactory.reset(SkRef(xpFactory));
         return xpFactory;
     }
 
-    void setPorterDuffXPFactory(SkXfermode::Mode mode) {
-        fXPFactory.reset(GrPorterDuffXPFactory::Create(mode));
-    }
-
-    void setPorterDuffXPFactory(GrBlendCoeff src, GrBlendCoeff dst) {
-        fXPFactory.reset(GrPorterDuffXPFactory::Create(src, dst));
-    }
-
     /**
      * Appends an additional color processor to the color computation.
      */
     const GrFragmentProcessor* addColorProcessor(const GrFragmentProcessor* fp) {
         SkASSERT(fp);
         SkNEW_APPEND_TO_TARRAY(&fColorStages, GrFragmentStage, (fp));
         return fp;
     }
 
     /**
@@ skipping 17 matching lines @@
     int numColorStages() const { return fColorStages.count(); }
     int numCoverageStages() const { return fCoverageStages.count(); }
     int numTotalStages() const { return this->numColorStages() + this->numCoverageStages(); }
 
     const GrXPFactory* getXPFactory() const { return fXPFactory.get(); }
 
     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;
 
         fColorStages = paint.fColorStages;
         fCoverageStages = paint.fCoverageStages;
 
         fXPFactory.reset(SkRef(paint.getXPFactory()));
 
         return *this;
     }
 
     /**
      * Resets the paint to the defaults.
      */
     void reset() {
+        this->resetBlend();
         this->resetOptions();
         this->resetColor();
         this->resetStages();
     }
 
     /**
      * Determines whether the drawing with this paint is opaque with respect to both color blending
      * and fractional coverage. It does not consider whether AA has been enabled on the paint or
      * not. Depending upon whether multisampling or coverage-based AA is in use, AA may make the
      * result only apply to the interior of primitives.
@@ skipping 50 matching lines @@
         return true;
     }
 
     friend class GrContext; // To access above two functions
     friend class GrStencilAndCoverTextContext;  // To access above two functions
 
     SkAutoTUnref<const GrXPFactory> fXPFactory;
     SkSTArray<4, GrFragmentStage>   fColorStages;
     SkSTArray<2, GrFragmentStage>   fCoverageStages;
 
+    GrBlendCoeff                    fSrcBlendCoeff;
+    GrBlendCoeff                    fDstBlendCoeff;
     bool                            fAntiAlias;
     bool                            fDither;
 
     GrColor                         fColor;
 
+    void resetBlend() {
+        fSrcBlendCoeff = kOne_GrBlendCoeff;
+        fDstBlendCoeff = kZero_GrBlendCoeff;
+    }
+
     void resetOptions() {
         fAntiAlias = false;
         fDither = false;
     }
 
     void resetColor() {
         fColor = GrColorPackRGBA(0xff, 0xff, 0xff, 0xff);
     }
 
-    void resetStages();
+    void resetStages(); 
 };
 
 #endif