Small cleanups after GrDrawState/GrOptDrawState base class elimination.

src/gpu/GrOptDrawState.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 GrOptDrawState_DEFINED
 #define GrOptDrawState_DEFINED
 
@@ skipping 158 matching lines @@
     ///////////////////////////////////////////////////////////////////////////
     /// @name ScissorState
     ////
 
     const ScissorState& getScissorState() const { return fScissorState; }
 
     /// @}
 
 
     ///////////////////////////////////////////////////////////////////////////
-    /// @name State Flags
+    /// @name Boolean Queries
     ////
 
-    bool isDitherState() const { return 0 != (fFlagBits & kDither_StateBit); }
-    bool isHWAntialiasState() const { return 0 != (fFlagBits & kHWAntialias_StateBit); }
-    bool isColorWriteDisabled() const { return 0 != (fFlagBits & kNoColorWrites_StateBit); }
-    bool isCoverageDrawing() const { return 0 != (fFlagBits & kCoverageDrawing_StateBit); }
+    bool isDitherState() const { return SkToBool(fFlags & kDither_Flag); }
+    bool isHWAntialiasState() const { return SkToBool(fFlags & kHWAA_Flag); }
+    bool isColorWriteDisabled() const { return SkToBool(fFlags & kDisableColorWrite_Flag); }
 
     /// @}
 
-    ///////////////////////////////////////////////////////////////////////////
-    /// @name Face Culling
-    ////
-
-    enum DrawFace {
-        kInvalid_DrawFace = -1,
-
-        kBoth_DrawFace,
-        kCCW_DrawFace,
-        kCW_DrawFace,
-    };
-
     /**
      * Gets whether the target is drawing clockwise, counterclockwise,
      * or both faces.
      * @return the current draw face(s).
      */
-    DrawFace getDrawFace() const { return fDrawFace; }
+    GrDrawState::DrawFace getDrawFace() const { return fDrawFace; }
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
 
 
     const GrProgramDesc& programDesc() const { return fDesc; }
 
 private:
-    // This is lifted from GrDrawState. This should be revised and made specific to this class/
-    enum StateBits {
-        /**
-         * Perform dithering. TODO: Re-evaluate whether we need this bit
-         */
-        kDither_StateBit        = 0x01,
-        /**
-         * Perform HW anti-aliasing. This means either HW FSAA, if supported by the render target,
-         * or smooth-line rendering if a line primitive is drawn and line smoothing is supported by
-         * the 3D API.
-         */
-        kHWAntialias_StateBit   = 0x02,
-        /**
-         * Draws will respect the clip, otherwise the clip is ignored.
-         */
-        kClip_StateBit          = 0x04,
-        /**
-         * Disables writing to the color buffer. Useful when performing stencil
-         * operations.
-         */
-        kNoColorWrites_StateBit = 0x08,
-
-        /**
-         * Usually coverage is applied after color blending. The color is blended using the coeffs
-         * specified by setBlendFunc(). The blended color is then combined with dst using coeffs
-         * of src_coverage, 1-src_coverage. Sometimes we are explicitly drawing a coverage mask. In
-         * this case there is no distinction between coverage and color and the caller needs direct
-         * 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
-    };
-      
-    /**
-     * Optimizations for blending / coverage to that can be applied based on the current state.
-     */
-    enum BlendOptFlags {
-        /**
-         * No optimization
-         */
-        kNone_BlendOpt                  = 0,
-        /**
-         * Don't draw at all
-         */
-        kSkipDraw_BlendOptFlag          = 0x1,
-        /**
-         * The coverage value does not have to be computed separately from alpha, the the output
-         * color can be the modulation of the two.
-         */
-        kCoverageAsAlpha_BlendOptFlag   = 0x2,
-        /**
-         * Instead of emitting a src color, emit coverage in the alpha channel and r,g,b are
-         * "don't cares".
-         */
-        kEmitCoverage_BlendOptFlag      = 0x4,
-        /**
-         * Emit transparent black instead of the src color, no need to compute coverage.
-         */
-        kEmitTransBlack_BlendOptFlag    = 0x8,
-    };
-    GR_DECL_BITFIELD_OPS_FRIENDS(BlendOptFlags);
-
     /**
      * Constructs and optimized drawState out of a GrRODrawState.
      */
-    GrOptDrawState(const GrDrawState& drawState, BlendOptFlags blendOptFlags,
+    GrOptDrawState(const GrDrawState& drawState, GrDrawState::BlendOpt,
                    GrBlendCoeff optSrcCoeff, GrBlendCoeff optDstCoeff,
                    GrGpu*, const ScissorState&, const GrDeviceCoordTexture* dstCopy,
                    GrGpu::DrawType);
 
     /**
      * Loops through all the color stage effects to check if the stage will ignore color input or
      * always output a constant color. In the ignore color input case we can ignore all previous
      * stages. In the constant color case, we can ignore all previous stages and
      * the current one and set the state color to the constant color.
      */
     void computeEffectiveColorStages(const GrDrawState& ds, GrProgramDesc::DescInfo*,
                                      int* firstColorStageIdx, uint8_t* fixFunctionVAToRemove);
 
     /**
      * Loops through all the coverage stage effects to check if the stage will ignore color input.
      * If a coverage stage will ignore input, then we can ignore all coverage stages before it. We
      * loop to determine the first effective coverage stage.
      */
     void computeEffectiveCoverageStages(const GrDrawState& ds, GrProgramDesc::DescInfo* descInfo,
                                         int* firstCoverageStageIdx);
 
     /**
      * This function takes in a flag and removes the corresponding fixed function vertex attributes.
      * The flags are in the same order as GrVertexAttribBinding array. If bit i of removeVAFlags is
      * set, then vertex attributes with binding (GrVertexAttribute)i will be removed.
      */
     void removeFixedFunctionVertexAttribs(uint8_t removeVAFlags, GrProgramDesc::DescInfo*);
 
     /**
-     * Alter the OptDrawState (adjusting stages, vertex attribs, flags, etc.) based on the
-     * BlendOptFlags.
+     * Alter the program desc and inputs (attribs and processors) based on the blend optimization.
      */
-    void adjustFromBlendOpts(const GrDrawState& ds, GrProgramDesc::DescInfo*,
-                             int* firstColorStageIdx, int* firstCoverageStageIdx,
-                             uint8_t* fixedFunctionVAToRemove);
+    void adjustProgramForBlendOpt(const GrDrawState& ds, GrDrawState::BlendOpt,
+                                  GrProgramDesc::DescInfo*,
+                                  int* firstColorStageIdx, int* firstCoverageStageIdx,
+                                  uint8_t* fixedFunctionVAToRemove);
 
     /**
      * Loop over the effect stages to determine various info like what data they will read and what
      * shaders they require.
      */
     void getStageStats(const GrDrawState& ds, int firstColorStageIdx, int firstCoverageStageIdx,
                        GrProgramDesc::DescInfo*);
 
     /**
      * Calculates the primary and secondary output types of the shader. For certain output types
      * the function may adjust the blend coefficients. After this function is called the src and dst
      * blend coeffs will represent those used by backend API.
      */
-    void setOutputStateInfo(const GrDrawState& ds, const GrDrawTargetCaps&,
+    void setOutputStateInfo(const GrDrawState& ds, GrDrawState::BlendOpt, const GrDrawTargetCaps&,
                             GrProgramDesc::DescInfo*);
 
+    enum Flags {
+        kDither_Flag            = 0x1,
+        kHWAA_Flag              = 0x2,
+        kDisableColorWrite_Flag = 0x4,
+    };
+
     typedef GrPendingIOResource<GrRenderTarget, kWrite_GrIOType> RenderTarget;
     typedef SkSTArray<8, GrPendingFragmentStage> FragmentStageArray;
     typedef GrPendingProgramElement<const GrGeometryProcessor> ProgramGeometryProcessor;
     RenderTarget                        fRenderTarget;
     ScissorState                        fScissorState;
     GrColor                             fColor;
     SkMatrix                            fViewMatrix;
     GrColor                             fBlendConstant;
-    uint32_t                            fFlagBits;
     const GrVertexAttrib*               fVAPtr;
     int                                 fVACount;
     size_t                              fVAStride;
     GrStencilSettings                   fStencilSettings;
     uint8_t                             fCoverage;
-    DrawFace                            fDrawFace;
+    GrDrawState::DrawFace               fDrawFace;
     GrBlendCoeff                        fSrcBlend;
     GrBlendCoeff                        fDstBlend;
-
+    uint32_t                            fFlags;
     ProgramGeometryProcessor            fGeometryProcessor;
     FragmentStageArray                  fFragmentStages;
 
     // This function is equivalent to the offset into fFragmentStages where coverage stages begin.
     int                                 fNumColorStages;
 
     SkAutoSTArray<4, GrVertexAttrib> fOptVA;
 
-    BlendOptFlags   fBlendOptFlags;
-
     GrProgramDesc fDesc;
 
     typedef SkRefCnt INHERITED;
 };
 
-GR_MAKE_BITFIELD_OPS(GrOptDrawState::BlendOptFlags);
-
 #endif
-