Initial CL to move color / coverage off of drawstate

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
 
@@ skipping 75 matching lines @@
     /**
      * Depending on features available in the underlying 3D API and the color blend mode requested
      * it may or may not be possible to correctly blend with fractional pixel coverage generated by
      * the fragment shader.
      *
      * This function considers the current draw state and the draw target's capabilities to
      * determine whether coverage can be handled correctly. This function assumes that the caller
      * intends to specify fractional pixel coverage (via setCoverage(), through a coverage vertex
      * attribute, or a coverage effect) but may not have specified it yet.
      */
-    bool couldApplyCoverage(const GrDrawTargetCaps& caps) const;
+    bool couldApplyCoverage(GrColor color, GrColor coverage, const GrDrawTargetCaps& caps) const;

[bsalomon, 2014/12/08 19:42:13]

Do we really need the coverage field here? If someone is asking this question
than they want to try applying non-solid coverage. Or is there some way this can
go away in the future?

I'm wondering if there is a way to recast this to be less complicated. Would
something like this work:

couldInstallCoverageGP(bool gpColorWillBeOpaque, const GrDrawTargetCaps&)

?

[joshualitt, 2014/12/08 20:19:20]

So, this function is called in context before we have a GP, and its also called
before path rendering, oval rendering, etc.

I'm really not sure what the best thing to do here is, but it calls
calcInvariantCoverage which needs an input coverage.  Whatever we choose to do,
I think its not going to be that simple and I'd rather do it in a follow up cl.

[bsalomon, 2014/12/08 20:28:15]

Right that's why I think we should rephrase the question it asks as "could I
install a GP that produces fractional coverage". It covers both of those points.
We'd seed the first coverage fp with unkown single channel and seed color with
the passed in color (and perhaps allow for kInvalid for color).


If we land this as is I'd like to clean it up real soon. This is already a
confusing function and adding the params makes it even harder to understand.

 
     /**
      * Determines whether the output coverage is guaranteed to be one for all pixels hit by a draw.
      */
-    bool hasSolidCoverage() const;
+    bool hasSolidCoverage(GrColor coverage) const;

[bsalomon, 2014/12/08 19:42:13]

I assume this goes away when the GP outputs an invariant coverage? or no?

[joshualitt, 2014/12/08 20:19:20]

I think so yes

 
     /**
      * This function returns true if the render target destination pixel values will be read for
      * blending during draw.
      */
-    bool willBlendWithDst() const;
+    bool willBlendWithDst(GrColor color, GrColor coverage) const;
 
     /// @}
 
-    ///////////////////////////////////////////////////////////////////////////
-    /// @name Color
-    ////
-
-    GrColor getColor() const { return fColor; }
-
-    /**
-     *  Sets color for next draw to a premultiplied-alpha color.
-     *
-     *  @param color    the color to set.
-     */
-    void setColor(GrColor color) {
-        if (color != fColor) {
-            fColor = color;
-            fColorProcInfoValid = false;
-        }
-    }
-
-    /**
-     *  Sets the color to be used for the next draw to be
-     *  (r,g,b,a) = (alpha, alpha, alpha, alpha).
-     *
-     *  @param alpha The alpha value to set as the color.
-     */
-    void setAlpha(uint8_t a) { this->setColor((a << 24) | (a << 16) | (a << 8) | a); }
-
-    /// @}
-
-    ///////////////////////////////////////////////////////////////////////////
-    /// @name Coverage
-    ////
-
-    uint8_t getCoverage() const { return fCoverage; }
-
-    GrColor getCoverageColor() const {
-        return GrColorPackRGBA(fCoverage, fCoverage, fCoverage, fCoverage);
-    }
-
-    /**
-     * Sets a constant fractional coverage to be applied to the draw. The
-     * initial value (after construction or reset()) is 0xff. The constant
-     * coverage is ignored when per-vertex coverage is provided.
-     */
-    void setCoverage(uint8_t coverage) {
-        if (coverage != fCoverage) {
-            fCoverage = coverage;
-            fCoverageProcInfoValid = false;
-        }
-    }
-
-    /// @}
-
     /**
      * The geometry processor is the sole element of the skia pipeline which can use the vertex,
      * geometry, and tesselation shaders.  The GP may also compute a coverage in its fragment shader
      * but is never put in the color processing pipeline.
      */
 
     const GrGeometryProcessor* setGeometryProcessor(const GrGeometryProcessor* geometryProcessor) {
         SkASSERT(geometryProcessor);
         SkASSERT(!this->hasGeometryProcessor());
         fGeometryProcessor.reset(SkRef(geometryProcessor));
@@ skipping 32 matching lines @@
     const GrGeometryProcessor* getGeometryProcessor() const { return fGeometryProcessor.get(); }
 
     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;
+    bool willEffectReadDstColor(GrColor color, GrColor coverage) const;

[bsalomon, 2014/12/08 19:42:13]

Add a TODO to remove this function once only XP can read dst color?

[joshualitt, 2014/12/08 20:19:20]

Acknowledged.

 
     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);
@@ skipping 441 matching lines @@
 
     /**
      * 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,
+    BlendOpt getBlendOpt(GrColor color,
+                         GrColor coverage,
+                         bool forceCoverage = false,
                          GrBlendCoeff* srcCoeff = NULL,
                          GrBlendCoeff* dstCoeff = NULL) const;
 
-    const GrProcOptInfo& colorProcInfo() const { 
-        this->calcColorInvariantOutput();
+    const GrProcOptInfo& colorProcInfo(GrColor color) const {
+        this->calcColorInvariantOutput(color);
         return fColorProcInfo;
     }
 
-    const GrProcOptInfo& coverageProcInfo() const {
-        this->calcCoverageInvariantOutput();
+    const GrProcOptInfo& coverageProcInfo(GrColor coverage) const {
+        this->calcCoverageInvariantOutput(coverage);
         return fCoverageProcInfo;
     }
 
     /**
      * Determines whether src alpha is guaranteed to be one for all src pixels
      */
-    bool srcAlphaWillBeOne() const;
+    bool srcAlphaWillBeOne(GrColor color, GrColor coverage) const;
 
     /**
      * If fColorProcInfoValid is false, function calculates the invariant output for the color
      * stages and results are stored in fColorProcInfo.
      */
-    void calcColorInvariantOutput() const;
+    void calcColorInvariantOutput(GrColor) const;
 
     /**
      * If fCoverageProcInfoValid is false, function calculates the invariant output for the coverage
      * stages and results are stored in fCoverageProcInfo.
      */
-    void calcCoverageInvariantOutput() const;
+    void calcCoverageInvariantOutput(GrColor) const;
 
     void onReset(const SkMatrix* initialViewMatrix);
 
     // 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;
+    mutable GrColor fColorCache;
+    mutable GrColor fCoverageCache;
 
     friend class GrOptDrawState;
 };
 
 #endif