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

src/gpu/GrDrawState.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 GrDrawState_DEFINED
 #define GrDrawState_DEFINED
 
 
 #include "GrBlend.h"
 #include "GrDrawTargetCaps.h"
 #include "GrGeometryProcessor.h"
 #include "GrGpuResourceRef.h"
 #include "GrFragmentStage.h"
 #include "GrProcOptInfo.h"
 #include "GrRenderTarget.h"
 #include "GrStencil.h"
-#include "GrXferProcessor.h"
 #include "SkMatrix.h"
-#include "effects/GrPorterDuffXferProcessor.h"
 #include "effects/GrSimpleTextureEffect.h"
 
 class GrDrawTargetCaps;
 class GrPaint;
 class GrTexture;
 
 class GrDrawState {
 public:
     GrDrawState() {
         SkDEBUGCODE(fBlockEffectRemovalCnt = 0;)
@@ skipping 176 matching lines @@
     const GrXPFactory* getXPFactory() const { return fXPFactory.get(); }
 
     const GrFragmentStage& getColorStage(int idx) const { return fColorStages[idx]; }
     const GrFragmentStage& getCoverageStage(int idx) const { return fCoverageStages[idx]; }
 
     /**
      * Checks whether any of the effects will read the dst pixel color.
      */
     bool willEffectReadDstColor() const;
 
-    /**
-     * The xfer processor factory.
-     */
-    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));
-    }
-
     const GrFragmentProcessor* addColorProcessor(const GrFragmentProcessor* effect) {
         SkASSERT(effect);
         SkNEW_APPEND_TO_TARRAY(&fColorStages, GrFragmentStage, (effect));
         fColorProcInfoValid = false;
         return effect;
     }
 
     const GrFragmentProcessor* addCoverageProcessor(const GrFragmentProcessor* effect) {
         SkASSERT(effect);
         SkNEW_APPEND_TO_TARRAY(&fCoverageStages, GrFragmentStage, (effect));
@@ skipping 98 matching lines @@
         GrDrawState*       fDrawState;
         GrStencilSettings  fStencilSettings;
     };
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name Blending
     ////
 
+    GrBlendCoeff getSrcBlendCoeff() const { return fSrcBlend; }
+    GrBlendCoeff getDstBlendCoeff() const { return fDstBlend; }
+
+    /**
+     * Retrieves the last value set by setBlendConstant()
+     * @return the blending constant value
+     */
+    GrColor getBlendConstant() const { return fBlendConstant; }
+
     /**
      * Determines whether multiplying the computed per-pixel color by the pixel's fractional
      * coverage before the blend will give the correct final destination color. In general it
      * will not as coverage is applied after blending.
      */
     bool canTweakAlphaForCoverage() const;
 
+    /**
+     * Sets the blending function coefficients.
+     *
+     * The blend function will be:
+     *    D' = sat(S*srcCoef + D*dstCoef)
+     *
+     *   where D is the existing destination color, S is the incoming source
+     *   color, and D' is the new destination color that will be written. sat()
+     *   is the saturation function.
+     *
+     * @param srcCoef coefficient applied to the src color.
+     * @param dstCoef coefficient applied to the dst color.
+     */
+    void setBlendFunc(GrBlendCoeff srcCoeff, GrBlendCoeff dstCoeff) {
+        fSrcBlend = srcCoeff;
+        fDstBlend = dstCoeff;
+    #ifdef SK_DEBUG
+        if (GrBlendCoeffRefsDst(dstCoeff)) {
+            SkDebugf("Unexpected dst blend coeff. Won't work correctly with coverage stages.\n");
+        }
+        if (GrBlendCoeffRefsSrc(srcCoeff)) {
+            SkDebugf("Unexpected src blend coeff. Won't work correctly with coverage stages.\n");
+        }
+    #endif
+    }
+
+    /**
+     * Sets the blending function constant referenced by the following blending
+     * coefficients:
+     *      kConstC_GrBlendCoeff
+     *      kIConstC_GrBlendCoeff
+     *      kConstA_GrBlendCoeff
+     *      kIConstA_GrBlendCoeff
+     *
+     * @param constant the constant to set
+     */
+    void setBlendConstant(GrColor constant) { fBlendConstant = constant; }
+
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name View Matrix
     ////
 
     /**
      * Retrieves the current view matrix
      * @return the current view matrix.
      */
@@ skipping 231 matching lines @@
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
 
     GrDrawState& operator= (const GrDrawState& that);
 
 private:
     bool isEqual(const GrDrawState& that) const;
 
+    /**
+     * Optimizations for blending / coverage to that can be applied based on the current state.
+     */
+    enum BlendOpt {
+        /**
+         * No optimization
+         */
+        kNone_BlendOpt,
+        /**
+         * Don't draw at all
+         */
+        kSkipDraw_BlendOpt,
+        /**
+         * The coverage value does not have to be computed separately from alpha, the the output
+         * color can be the modulation of the two.
+         */
+        kCoverageAsAlpha_BlendOpt,
+        /**
+         * Instead of emitting a src color, emit coverage in the alpha channel and r,g,b are
+         * "don't cares".
+         */
+        kEmitCoverage_BlendOpt,
+        /**
+         * Emit transparent black instead of the src color, no need to compute coverage.
+         */
+        kEmitTransBlack_BlendOpt
+    };
+
+    /**
+     * Determines what optimizations can be applied based on the blend. The coefficients may have
+     * to be tweaked in order for the optimization to work. srcCoeff and dstCoeff are optional
+     * params that receive the tweaked coefficients. Normally the function looks at the current
+     * state to see if coverage is enabled. By setting forceCoverage the caller can speculatively
+     * determine the blend optimizations that would be used if there was partial pixel coverage.
+     *
+     * This is used internally and when constructing a GrOptDrawState.
+     */
+    BlendOpt getBlendOpt(bool forceCoverage = false,
+                         GrBlendCoeff* srcCoeff = NULL,
+                         GrBlendCoeff* dstCoeff = NULL) const;
+
     const GrProcOptInfo& colorProcInfo() const { 
         this->calcColorInvariantOutput();
         return fColorProcInfo;
     }
 
     const GrProcOptInfo& coverageProcInfo() const {
         this->calcCoverageInvariantOutput();
         return fCoverageProcInfo;
     }
 
@@ skipping 18 matching lines @@
 
     // Some of the auto restore objects assume that no effects are removed during their lifetime.
     // This is used to assert that this condition holds.
     SkDEBUGCODE(int fBlockEffectRemovalCnt;)
 
     typedef SkSTArray<4, GrFragmentStage> FragmentStageArray;
 
     SkAutoTUnref<GrRenderTarget>            fRenderTarget;
     GrColor                                 fColor;
     SkMatrix                                fViewMatrix;
+    GrColor                                 fBlendConstant;
     uint32_t                                fFlagBits;
     GrStencilSettings                       fStencilSettings;
     uint8_t                                 fCoverage;
     DrawFace                                fDrawFace;
+    GrBlendCoeff                            fSrcBlend;
+    GrBlendCoeff                            fDstBlend;
     SkAutoTUnref<const GrGeometryProcessor> fGeometryProcessor;
     SkAutoTUnref<const GrXPFactory>         fXPFactory;
     FragmentStageArray                      fColorStages;
     FragmentStageArray                      fCoverageStages;
     uint32_t                                fHints;
 
     mutable GrProcOptInfo fColorProcInfo;
     mutable GrProcOptInfo fCoverageProcInfo;
     mutable bool fColorProcInfoValid;
     mutable bool fCoverageProcInfoValid;
 
     friend class GrOptDrawState;
 };
 
 #endif