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/GrSimpleTextureEffect.h"
 
 class GrDrawTargetCaps;
 class GrPaint;
 class GrTexture;
 
 class GrDrawState {
 public:
     GrDrawState() {
@@ skipping 177 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;
+    }
+
     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