Create an optimized draw state but not hooked in yet to gpu pipeline

src/gpu/GrRODrawState.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrRODrawState_DEFINED
 #define GrRODrawState_DEFINED
 
 #include "GrStencil.h"
 #include "GrEffectStage.h"
 #include "SkMatrix.h"
 
+class GrDrawState;
 class GrDrawTargetCaps;
 class GrPaint;
 class GrRenderTarget;
 class GrTexture;
 
 /**
  * Read-only base class for GrDrawState. This class contains all the necessary data to represent a
  * canonical DrawState. All methods in the class are const, thus once created the data in the class
  * cannot be changed.
  */
 class GrRODrawState : public SkRefCnt {
 public:
     SK_DECLARE_INST_COUNT(GrRODrawState)
 
+    GrRODrawState() {}
+
+    GrRODrawState& operator= (const GrRODrawState& that);
+
     ///////////////////////////////////////////////////////////////////////////
     /// @name Vertex Attributes
     ////
 
     enum {
         kMaxVertexAttribCnt = kLast_GrVertexAttribBinding + 4,
     };
 
     const GrVertexAttrib* getVertexAttribs() const { return fVAPtr; }
     int getVertexAttribCount() const { return fVACount; }
 
     size_t getVertexSize() const { return fVertexSize; }

[bsalomon, 2014/08/28 13:49:27]

Have you rebased? I thought this was now stride...

[egdaniel, 2014/08/28 14:39:38]

Woops thought I had rebased

 
     /**
      * Getters for index into getVertexAttribs() for particular bindings. -1 is returned if the
      * binding does not appear in the current attribs. These bindings should appear only once in
      * the attrib array.
      */
 
     int positionAttributeIndex() const {
         return fFixedFunctionVertexAttribIndices[kPosition_GrVertexAttribBinding];
     }
@@ skipping 10 matching lines @@
     bool hasLocalCoordAttribute() const {
         return -1 != fFixedFunctionVertexAttribIndices[kLocalCoord_GrVertexAttribBinding];
     }
     bool hasColorVertexAttribute() const {
         return -1 != fFixedFunctionVertexAttribIndices[kColor_GrVertexAttribBinding];
     }
     bool hasCoverageVertexAttribute() const {
         return -1 != fFixedFunctionVertexAttribIndices[kCoverage_GrVertexAttribBinding];
     }
 
+    const int* getFixedFunctionVertexAttribIndices() const {

[bsalomon, 2014/08/28 13:49:27]

Does this need to be public? Comment about what it returns (length of the array,
how it's indexed).

[egdaniel, 2014/08/28 14:39:38]

moved to protected

+        return fFixedFunctionVertexAttribIndices;
+    }
+
     bool validateVertexAttribs() const;
 
     /// @}
 
     /**
      * Determines whether the output coverage is guaranteed to be one for all pixels hit by a draw.
      */
     bool hasSolidCoverage() const;
 
     /// @}
@@ skipping 65 matching lines @@
         *dstBlendCoeff = fDstBlend;
     }
 
     /**
      * Retrieves the last value set by setBlendConstant()
      * @return the blending constant value
      */
     GrColor getBlendConstant() const { return fBlendConstant; }
 
     /**
+     * We don't use supplied vertex color attributes if our blend mode is EmitCoverage or
+     * EmitTransBlack
+     */
+    bool canIgnoreColorAttribute() const;
+
+    /**
      * 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;
 
     /**
      * Optimizations for blending / coverage to that can be applied based on the current state.
      */
     enum BlendOptFlags {
@@ skipping 20 matching lines @@
          */
         kEmitTransBlack_BlendOptFlag    = 0x8,
         /**
          * Flag used to invalidate the cached BlendOptFlags, OptSrcCoeff, and OptDstCoeff cached by
          * the get BlendOpts function.
          */
         kInvalid_BlendOptFlag           = 1 << 31,
     };
     GR_DECL_BITFIELD_OPS_FRIENDS(BlendOptFlags);
 
+    /**
+     * 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.
+     *
+     * Subclasses of GrDrawTarget that actually draw (as opposed to those that just buffer for
+     * playback) must call this function and respect the flags that replace the output color.
+     *
+     * If the cached BlendOptFlags does not have the invalidate bit set, then getBlendOpts will
+     * simply returned the cached flags and coefficients. Otherwise it will calculate the values. 
+     */
+    BlendOptFlags getBlendOpts(bool forceCoverage = false,

[bsalomon, 2014/08/28 13:49:27]

What was it that is keeping this public now? I know you told me, just can't
remember.

[egdaniel, 2014/08/28 14:39:38]

Needed to stay public in this CL since the opt state stuff still isn't connected
in. Goes protected in follow cl once we are using the opt state

+                               GrBlendCoeff* srcCoeff = NULL,
+                               GrBlendCoeff* dstCoeff = NULL) const;
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name View Matrix
     ////
 
     /**
      * Retrieves the current view matrix
      * @return the current view matrix.
      */
@@ skipping 82 matching lines @@
          * control over the blend coeffs. When set, there will be a single blend step controlled by
          * setBlendFunc() which will use coverage*color as the src color.
          */
          kCoverageDrawing_StateBit = 0x10,
 
         // Users of the class may add additional bits to the vector
         kDummyStateBit,
         kLastPublicStateBit = kDummyStateBit-1,
     };
 
+    uint32_t getFlagBits() const { return fFlagBits; }
+
     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); }
 
     /// @}
 
@@ skipping 12 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, };
+
+    bool vertexColorsAreOpaque() const { return kVertexColorsAreOpaque_Hint & fHints; }
+
+    /// @}
+
+    ///////////////////////////////////////////////////////////////////////////
 
     /** 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,
     };
 
-    GrRODrawState& operator= (const GrRODrawState& that);
+protected:
+    explicit GrRODrawState(const GrRODrawState& drawState) : INHERITED() {
+        fRenderTarget.reset(SkSafeRef(drawState.fRenderTarget.get()));
+    }
 
-protected:
     bool isEqual(const GrRODrawState& that) 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;
     size_t                              fVertexSize;
     GrStencilSettings                   fStencilSettings;
     uint8_t                             fCoverage;
     DrawFace                            fDrawFace;
     GrBlendCoeff                        fSrcBlend;
     GrBlendCoeff                        fDstBlend;
 
     typedef SkSTArray<4, GrEffectStage> EffectStageArray;
     EffectStageArray                    fColorStages;
     EffectStageArray                    fCoverageStages;
 
+    uint32_t                            fHints;
+
     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];
 
 private:
+    /**
+     * Determines whether src alpha is guaranteed to be one for all src pixels
+     */
+    bool srcAlphaWillBeOne() const;
+
+    /**
+     * Helper function for getBlendOpts.
+     */
+    BlendOptFlags calcBlendOpts(bool forceCoverage = false,
+                                GrBlendCoeff* srcCoeff = NULL,
+                                GrBlendCoeff* dstCoeff = NULL) const;
+
     typedef SkRefCnt INHERITED;
 };
 
 GR_MAKE_BITFIELD_OPS(GrRODrawState::BlendOptFlags);
 
 #endif