Create Read-only Base class for GrDrawState that holds data members and getters

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 "GrRODrawState.h"
+
 #include "GrBlend.h"
-#include "GrColor.h"
-#include "GrEffectStage.h"
-#include "GrStencil.h"
 #include "effects/GrSimpleTextureEffect.h"
 
-#include "SkMatrix.h"
-
-class GrDrawTargetCaps;
-class GrPaint;
-class GrRenderTarget;
-class GrTexture;
-
-class GrDrawState : public SkRefCnt {
+/**
+ * Sub class that is derived from GrRODrawState. The majority of the data the represents a draw

[bsalomon, 2014/08/26 18:25:55]

Subclass?

"data the"->"data that"?

Maybe say "Editable subclass of GrRODrawState ..." or "Modifiable"?

Maybe mention something like "This is used to configure the state used when
issuing draws via GrDrawTarget." rather than the vague language around "majority
of cases."?

[egdaniel, 2014/08/26 18:45:23]

Done.

+ * state is stored in the parent class. GrDrawState contains methods for setting, adding to, etc.
+ * various data members of the draw state. This class will be used in the majority of the cases
+ * where a draw state is needed.
+ */
+class GrDrawState : public GrRODrawState {
 public:
     SK_DECLARE_INST_COUNT(GrDrawState)
 
     GrDrawState() {
         SkDEBUGCODE(fBlockEffectRemovalCnt = 0;)
         this->reset();
     }
 
     GrDrawState(const SkMatrix& initialViewMatrix) {
         SkDEBUGCODE(fBlockEffectRemovalCnt = 0;)
@@ skipping 27 matching lines @@
      * GrDrawState encompasses more than GrPaint. Aspects of GrDrawState that have no GrPaint
      * equivalents are set to default values with the exception of vertex attribute state which
      * is unmodified by this function and clipping which will be enabled.
      */
     void setFromPaint(const GrPaint& , const SkMatrix& viewMatrix, GrRenderTarget*);
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name Vertex Attributes
     ////
 
-    enum {
-        kMaxVertexAttribCnt = kLast_GrVertexAttribBinding + 4,
-    };
-
    /**
      * The format of vertices is represented as an array of GrVertexAttribs, with each representing
      * the type of the attribute, its offset, and semantic binding (see GrVertexAttrib in
      * GrTypesPriv.h).
      *
      * The mapping of attributes with kEffect bindings to GrEffect inputs is specified when
      * setEffect is called.
      */
 
     /**
      *  Sets vertex attributes for next draw. The object driving the templatization
      *  should be a global GrVertexAttrib array that is never changed.
      */
     template <const GrVertexAttrib A[]> void setVertexAttribs(int count) {
         this->setVertexAttribs(A, count);
     }
 
-    const GrVertexAttrib* getVertexAttribs() const { return fVAPtr; }
-    int getVertexAttribCount() const { return fVACount; }
-
-    size_t getVertexSize() const;
-
     /**
      *  Sets default vertex attributes for next draw. The default is a single attribute:
      *  {kVec2f_GrVertexAttribType, 0, kPosition_GrVertexAttribType}
      */
     void setDefaultVertexAttribs();
 
     /**
-     * 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];
-    }
-    int localCoordAttributeIndex() const {
-        return fFixedFunctionVertexAttribIndices[kLocalCoord_GrVertexAttribBinding];
-    }
-    int colorVertexAttributeIndex() const {
-        return fFixedFunctionVertexAttribIndices[kColor_GrVertexAttribBinding];
-    }
-    int coverageVertexAttributeIndex() const {
-        return fFixedFunctionVertexAttribIndices[kCoverage_GrVertexAttribBinding];
-    }
-
-    bool hasLocalCoordAttribute() const {
-        return -1 != fFixedFunctionVertexAttribIndices[kLocalCoord_GrVertexAttribBinding];
-    }
-    bool hasColorVertexAttribute() const {
-        return -1 != fFixedFunctionVertexAttribIndices[kColor_GrVertexAttribBinding];
-    }
-    bool hasCoverageVertexAttribute() const {
-        return -1 != fFixedFunctionVertexAttribIndices[kCoverage_GrVertexAttribBinding];
-    }
-
-    bool validateVertexAttribs() const;
-
-    /**
      * Helper to save/restore vertex attribs
      */
      class AutoVertexAttribRestore {
      public:
          AutoVertexAttribRestore(GrDrawState* drawState);
 
          ~AutoVertexAttribRestore() { fDrawState->setVertexAttribs(fVAPtr, fVACount); }
 
      private:
          GrDrawState*          fDrawState;
          const GrVertexAttrib* fVAPtr;
          int                   fVACount;
      };
 
     /// @}
 
     /**
      * Determines whether src alpha is guaranteed to be one for all src pixels
      */
     bool srcAlphaWillBeOne() const;

[bsalomon, 2014/08/26 18:15:01]

Shouldn't this be in RO?

[egdaniel, 2014/08/26 18:23:46]

This is only called in one place, calcBlendOpt. It actually could be a private
function in GrDrawState

[bsalomon, 2014/08/26 18:26:41]

That sgtm

 
     /**
-     * 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); }
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @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 = coverage;
         this->invalidateBlendOptFlags();
     }
 
-    uint8_t getCoverage() const { return fCoverage; }
-
-    GrColor getCoverageColor() const {
-        return GrColorPackRGBA(fCoverage, fCoverage, fCoverage, fCoverage);
-    }
-
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name Effect Stages
     /// Each stage hosts a GrEffect. The effect produces an output color or coverage in the fragment
     /// shader. Its inputs are the output from the previous stage as well as some variables
     /// available to it in the fragment and vertex shader (e.g. the vertex position, the dst color,
     /// the fragment position, local coordinates).
     ///
     /// The stages are divided into two sets, color-computing and coverage-computing. The final
@@ skipping 63 matching lines @@
         void set(GrDrawState* ds);
 
         bool isSet() const { return NULL != fDrawState; }
 
     private:
         GrDrawState* fDrawState;
         int fColorEffectCnt;
         int fCoverageEffectCnt;
     };
 
-    int numColorStages() const { return fColorStages.count(); }
-    int numCoverageStages() const { return fCoverageStages.count(); }
-    int numTotalStages() const { return this->numColorStages() + this->numCoverageStages(); }
-
-    const GrEffectStage& getColorStage(int stageIdx) const { return fColorStages[stageIdx]; }
-    const GrEffectStage& getCoverageStage(int stageIdx) const { return fCoverageStages[stageIdx]; }
-
-    /**
-     * Checks whether any of the effects will read the dst pixel color.
-     */
-    bool willEffectReadDstColor() const;
-
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name Blending
     ////
 
     /**
      * Sets the blending function coefficients.
      *
      * The blend function will be:
@@ skipping 13 matching lines @@
     #ifdef SK_DEBUG
         if (GrBlendCoeffRefsDst(dstCoeff)) {
             GrPrintf("Unexpected dst blend coeff. Won't work correctly with coverage stages.\n");
         }
         if (GrBlendCoeffRefsSrc(srcCoeff)) {
             GrPrintf("Unexpected src blend coeff. Won't work correctly with coverage stages.\n");
         }
     #endif
     }
 
-    GrBlendCoeff getSrcBlendCoeff() const { return fSrcBlend; }
-    GrBlendCoeff getDstBlendCoeff() const { return fDstBlend; }
-
-    void getDstBlendCoeff(GrBlendCoeff* srcBlendCoeff,
-                          GrBlendCoeff* dstBlendCoeff) const {
-        *srcBlendCoeff = fSrcBlend;
-        *dstBlendCoeff = fDstBlend;
-    }
-
     /**
      * 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;
         this->invalidateBlendOptFlags();
     }
 
     /**
-     * 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;
-
-    /**
-     * 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,
-        /**
-         * 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);
-
-    void invalidateBlendOptFlags() {
-        fBlendOptFlags = kInvalid_BlendOptFlag;
-    }
-
-    /**
-     * We don't use suplied vertex color attributes if our blend mode is EmitCoverage or
-     * EmitTransBlack
-     */
-    bool canIgnoreColorAttribute() const;
-
-    /**
      * 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,
                                GrBlendCoeff* srcCoeff = NULL,
                                GrBlendCoeff* dstCoeff = NULL) const;
 
+    void invalidateBlendOptFlags() {

[bsalomon, 2014/08/26 18:15:01]

Is this public? Need it be?

[egdaniel, 2014/08/26 18:23:46]

Should be private.

+        fBlendOptFlags = kInvalid_BlendOptFlag;
+    }
+
+    /**
+     * We don't use suplied vertex color attributes if our blend mode is EmitCoverage or
+     * EmitTransBlack
+     */
+    bool canIgnoreColorAttribute() const;

[bsalomon, 2014/08/26 18:15:01]

Should this be in RO? I guess it is going to go away soon?

[egdaniel, 2014/08/26 18:23:46]

The entire idea of ignoring color attribs is removed once I connect in the opt
code. But yes should probably makes more sense in RO for now.

[egdaniel, 2014/08/26 18:45:23]

So I realized the reason I had this here is because the function itself calls
getBlendOpts. I figured it was easier to leave it here in GrDrawState instead of
either moving getBlendOpts to RO or having it override an unused version in RO,
especially knowing it will disappear soon.

[bsalomon, 2014/08/26 18:51:52]

Ok if it disappears (or goes private) at the end of the three CL sequence then
fine by me.

+
+
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name View Matrix
     ////
 
     /**
      * Sets the view matrix to identity and updates any installed effects to compensate for the
      * coord system change.
      */
     bool setIdentityViewMatrix();
 
-    /**
-     * Retrieves the current view matrix
-     * @return the current view matrix.
-     */
-    const SkMatrix& getViewMatrix() const { return fViewMatrix; }
-
-    /**
-     *  Retrieves the inverse of the current view matrix.
-     *
-     *  If the current view matrix is invertible, return true, and if matrix
-     *  is non-null, copy the inverse into it. If the current view matrix is
-     *  non-invertible, return false and ignore the matrix parameter.
-     *
-     * @param matrix if not null, will receive a copy of the current inverse.
-     */
-    bool getViewInverse(SkMatrix* matrix) const {
-        // TODO: determine whether we really need to leave matrix unmodified
-        // at call sites when inversion fails.
-        SkMatrix inverse;
-        if (fViewMatrix.invert(&inverse)) {
-            if (matrix) {
-                *matrix = inverse;
-            }
-            return true;
-        }
-        return false;
-    }
-
     ////////////////////////////////////////////////////////////////////////////
 
     /**
      * Preconcats the current view matrix and restores the previous view matrix in the destructor.
      * Effect matrices are automatically adjusted to compensate and adjusted back in the destructor.
      */
     class AutoViewMatrixRestore : public ::SkNoncopyable {
     public:
         AutoViewMatrixRestore() : fDrawState(NULL) {}
 
@@ skipping 30 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)); }
 
-    /**
-     * 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 {
     public:
         AutoRenderTargetRestore() : fDrawState(NULL), fSavedTarget(NULL) {}
         AutoRenderTargetRestore(GrDrawState* ds, GrRenderTarget* newTarget) {
             fDrawState = NULL;
             fSavedTarget = NULL;
             this->set(ds, newTarget);
         }
         ~AutoRenderTargetRestore() { this->restore(); }
 
@@ skipping 40 matching lines @@
     }
 
     /**
      * Shortcut to disable stencil testing and ops.
      */
     void disableStencil() {
         fStencilSettings.setDisabled();
         this->invalidateBlendOptFlags();
     }
 
-    const GrStencilSettings& getStencil() const { return fStencilSettings; }
-
     GrStencilSettings* stencil() { return &fStencilSettings; }
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name State Flags
     ////
 
-    /**
-     *  Flags that affect rendering. Controlled using enable/disableState(). All
-     *  default to disabled.
-     */
-    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,
-
-        // Users of the class may add additional bits to the vector
-        kDummyStateBit,
-        kLastPublicStateBit = kDummyStateBit-1,
-    };
-
     void resetStateFlags() {
         fFlagBits = 0;
         this->invalidateBlendOptFlags();
     }
 
     /**
      * Enable render state settings.
      *
      * @param stateBits bitfield of StateBits specifying the states to enable
      */
@@ skipping 19 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 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,
-
-        kBoth_DrawFace,
-        kCCW_DrawFace,
-        kCW_DrawFace,
-    };
-
     /**
      * Controls whether clockwise, counterclockwise, or both faces are drawn.
      * @param face  the face(s) to draw.
      */
     void setDrawFace(DrawFace face) {
         SkASSERT(kInvalid_DrawFace != face);
         fDrawFace = face;
     }
 
-    /**
-     * 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); }
@@ skipping 23 matching lines @@
 
     GrDrawState& operator= (const GrDrawState& that);
 
 private:
     void onReset(const SkMatrix* initialViewMatrix);
 
     BlendOptFlags calcBlendOpts(bool forceCoverage = false,
                                 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;
-    GrBlendCoeff                        fSrcBlend;
-    GrBlendCoeff                        fDstBlend;
-    GrColor                             fBlendConstant;
-    uint32_t                            fFlagBits;
-    const GrVertexAttrib*               fVAPtr;
-    int                                 fVACount;
-    size_t                              fVertexSize;
-    GrStencilSettings                   fStencilSettings;
-    uint8_t                             fCoverage;
-    DrawFace                            fDrawFace;
-
-    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];
 
     // 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;
+    typedef GrRODrawState INHERITED;
 };
 
-GR_MAKE_BITFIELD_OPS(GrDrawState::BlendOptFlags);
-
 #endif