Add an opaqueness hint to GrDrawState.

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 "GrBackendEffectFactory.h"
 #include "GrBlend.h"
 #include "GrColor.h"
 #include "GrEffectStage.h"
-#include "GrPaint.h"
-#include "GrRenderTarget.h"
 #include "GrStencil.h"
-#include "GrTemplates.h"
-#include "GrTexture.h"
-#include "GrTypesPriv.h"
 #include "effects/GrSimpleTextureEffect.h"
 
 #include "SkMatrix.h"
-#include "SkTypes.h"
-#include "SkXfermode.h"
+
+class GrDrawTargetCaps;
+class GrPaint;
+class GrRenderTarget;
+class GrTexture;
 
 class GrDrawState : public SkRefCnt {
 public:
     SK_DECLARE_INST_COUNT(GrDrawState)
 
     GrDrawState() {
         SkDEBUGCODE(fBlockEffectRemovalCnt = 0;)
         this->reset();
     }
 
@@ skipping 118 matching lines @@
     /**
      * Determines whether src alpha is guaranteed to be one for all src pixels
      */
     bool srcAlphaWillBeOne() const;
 
     /**
      * Determines whether the output coverage is guaranteed to be one for all pixels hit by a draw.
      */
     bool hasSolidCoverage() const;
 
+    /**
+     * 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;
+
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name Color
     ////
 
     /**
      *  Sets color for next draw to a premultiplied-alpha color.
      *
      *  @param color    the color to set.
      */
     void setColor(GrColor color) {
         fColor = color;
         this->invalidateBlendOptFlags();
     }
 
     GrColor getColor() const { return fColor; }
 
     /**
      *  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);
-    }
+    void setAlpha(uint8_t a) { this->setColor((a << 24) | (a << 16) | (a << 8) | a); }
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name Coverage
     ////
 
     /**
      * 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) {
         fCoverage = GrColorPackRGBA(coverage, coverage, coverage, coverage);
         this->invalidateBlendOptFlags();
     }
 
-    uint8_t getCoverage() const {
-        return GrColorUnpackR(fCoverage);
-    }
+    uint8_t getCoverage() const { return GrColorUnpackR(fCoverage); }
 
-    GrColor getCoverageColor() const {
-        return fCoverage;
-    }
+    GrColor getCoverageColor() const { return fCoverage; }
 
     /// @}
 
     /**
      * This struct is here so that the GrDrawState can have multiple instances of state information.
      * The use of this will come in a future revision when we want to keep track of the original
      * draw state as well as an optimized version of it.
      */
     struct State {
         State() {
@@ skipping 329 matching lines @@
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name Render Target
     ////
 
     /**
      * Sets the render-target used at the next drawing call
      *
      * @param target  The render target to set.
      */
-    void setRenderTarget(GrRenderTarget* target) {
-        fRenderTarget.reset(SkSafeRef(target));
-    }
+    void setRenderTarget(GrRenderTarget* target) { fRenderTarget.reset(SkSafeRef(target)); }
 
     /**
      * Retrieves the currently set render-target.
      *
      * @return    The currently set render target.
      */
     const GrRenderTarget* getRenderTarget() const { return fRenderTarget.get(); }
     GrRenderTarget* getRenderTarget() { return fRenderTarget.get(); }
 
     class AutoRenderTargetRestore : public ::SkNoncopyable {
@@ skipping 138 matching lines @@
      * @param enable    if true enable stateBits, otherwise disable
      */
     void setState(uint32_t stateBits, bool enable) {
         if (enable) {
             this->enableState(stateBits);
         } else {
             this->disableState(stateBits);
         }
     }
 
-    bool isDitherState() const {
-        return 0 != (fFlagBits & kDither_StateBit);
-    }
+    bool isStateFlagEnabled(uint32_t stateBit) const { return 0 != (stateBit & fFlagBits); }
 
-    bool isHWAntialiasState() const {
-        return 0 != (fFlagBits & kHWAntialias_StateBit);
-    }
-
-    bool isClipState() const {
-        return 0 != (fFlagBits & kClip_StateBit);
-    }
-
-    bool isColorWriteDisabled() const {
-        return 0 != (fFlagBits & kNoColorWrites_StateBit);
-    }
-
-    bool isCoverageDrawing() const {
-        return 0 != (fFlagBits & kCoverageDrawing_StateBit);
-    }
-
-    bool isStateFlagEnabled(uint32_t stateBit) const {
-        return 0 != (stateBit & fFlagBits);
-    }
+    bool isDitherState() const { return 0 != (fFlagBits & kDither_StateBit); }
+    bool isHWAntialiasState() const { return 0 != (fFlagBits & kHWAntialias_StateBit); }
+    bool isClipState() const { return 0 != (fFlagBits & kClip_StateBit); }
+    bool isColorWriteDisabled() const { return 0 != (fFlagBits & kNoColorWrites_StateBit); }
+    bool isCoverageDrawing() const { return 0 != (fFlagBits & kCoverageDrawing_StateBit); }
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name Face Culling
     ////
 
     enum DrawFace {
         kInvalid_DrawFace = -1,
 
@@ skipping 14 matching lines @@
     /**
      * Gets whether the target is drawing clockwise, counterclockwise,
      * or both faces.
      * @return the current draw face(s).
      */
     DrawFace getDrawFace() const { return fDrawFace; }
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
+    /// @name Hints
+    /// Hints that when provided can enable optimizations.
+    ////
+
+    enum Hints { kVertexColorsAreOpaque_Hint = 0x1, };
+
+    void setHint(Hints hint, bool value) { fHints = value ? (fHints | hint) : (fHints & ~hint); }
+
+    /// @}
+
+    ///////////////////////////////////////////////////////////////////////////
 
     /** Return type for CombineIfPossible. */
     enum CombinedState {
         /** The GrDrawStates cannot be combined. */
         kIncompatible_CombinedState,
         /** Either draw state can be used in place of the other. */
         kAOrB_CombinedState,
         /** Use the first draw state. */
         kA_CombinedState,
         /** Use the second draw state. */
         kB_CombinedState,
     };
 
     /** This function determines whether the GrDrawStates used for two draws can be combined into
         a single GrDrawState. This is used to avoid storing redundant GrDrawStates and to determine
         if draws can be batched. The return value indicates whether combining is possible and, if
         so, which of the two inputs should be used. */
-    static CombinedState CombineIfPossible(const GrDrawState& a, const GrDrawState& b);
+    static CombinedState CombineIfPossible(const GrDrawState& a, const GrDrawState& b,
+                                           const GrDrawTargetCaps& caps);
 
     GrDrawState& operator= (const GrDrawState& that);
 
 private:
     void onReset(const SkMatrix* initialViewMatrix);
 
     BlendOptFlags calcBlendOpts(bool forceCoverage = false,
-                               GrBlendCoeff* srcCoeff = NULL,
-                               GrBlendCoeff* dstCoeff = NULL) const;
+                                GrBlendCoeff* srcCoeff = NULL,
+                                GrBlendCoeff* dstCoeff = NULL) const;
 
     // These fields are roughly sorted by decreasing likelihood of being different in op==
     SkAutoTUnref<GrRenderTarget>        fRenderTarget;
     GrColor                             fColor;
     SkMatrix                            fViewMatrix;
     GrColor                             fBlendConstant;
     uint32_t                            fFlagBits;
     const GrVertexAttrib*               fVAPtr;
     int                                 fVACount;
     GrStencilSettings                   fStencilSettings;
     GrColor                             fCoverage;
     DrawFace                            fDrawFace;
 
     State                               fState;
+
+    uint32_t                            fHints;
     
-    mutable GrBlendCoeff                        fOptSrcBlend;
-    mutable GrBlendCoeff                        fOptDstBlend;
-    mutable BlendOptFlags                       fBlendOptFlags;
+    mutable GrBlendCoeff                fOptSrcBlend;
+    mutable GrBlendCoeff                fOptDstBlend;
+    mutable BlendOptFlags               fBlendOptFlags;
 
     // This is simply a different representation of info in fVertexAttribs and thus does
     // not need to be compared in op==.
     int fFixedFunctionVertexAttribIndices[kGrFixedFunctionVertexAttribBindingCnt];
 
     // 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;)
 
     /**
      *  Sets vertex attributes for next draw.
      *
      *  @param attribs    the array of vertex attributes to set.
      *  @param count      the number of attributes being set, limited to kMaxVertexAttribCnt.
      */
     void setVertexAttribs(const GrVertexAttrib attribs[], int count);
 
     typedef SkRefCnt INHERITED;
 };
 
 GR_MAKE_BITFIELD_OPS(GrDrawState::BlendOptFlags);
 
 #endif