OptState owns program descriptor

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
 
 #include "GrColor.h"
 #include "GrGpu.h"
 #include "GrProcessorStage.h"
+#include "GrProgramDesc.h"
 #include "GrStencil.h"
 #include "GrTypesPriv.h"
 #include "SkMatrix.h"
 #include "SkRefCnt.h"
 
+class GrDeviceCoordTexture;
 class GrDrawState;
 
 /**
  * Class that holds an optimized version of a GrDrawState. It is meant to be an immutable class,
  * and contains all data needed to set the state for a gpu draw.
  */
 class GrOptDrawState : public SkRefCnt {
 public:
     /**
      * Returns a snapshot of the current optimized state. If the current drawState has a valid
      * cached optimiezed state it will simply return a pointer to it otherwise it will create a new
      * GrOptDrawState. In all cases the GrOptDrawState is reffed and ownership is given to the
      * caller.
      */
-    static GrOptDrawState* Create(const GrDrawState& drawState, const GrDrawTargetCaps& caps,
-                                  GrGpu::DrawType drawType);
+    static GrOptDrawState* Create(const GrDrawState& drawState, GrGpu*,
+                                  const GrDeviceCoordTexture* dstCopy, GrGpu::DrawType drawType);
 
     bool operator== (const GrOptDrawState& that) const;
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name Vertex Attributes
     ////
 
     enum {
         kMaxVertexAttribCnt = kLast_GrVertexAttribBinding + 4,
     };
@@ skipping 254 matching lines @@
         kB_CombinedState,
     };
 
     bool inputColorIsUsed() const { return fInputColorIsUsed; }
     bool inputCoverageIsUsed() const { return fInputCoverageIsUsed; }
 
     bool readsDst() const { return fReadsDst; }
     bool readsFragPosition() const { return fReadsFragPosition; }
     bool requiresLocalCoordAttrib() const { return fRequiresLocalCoordAttrib; }
 
-    ///////////////////////////////////////////////////////////////////////////
-    /// @name Stage Output Types
-    ////
+    GrProgramDesc::PrimaryOutputType getPrimaryOutputType() const { return fPrimaryOutputType; }
+    GrProgramDesc::SecondaryOutputType getSecondaryOutputType() const { return fSecondaryOutputType; }
 
-    enum PrimaryOutputType {
-        // Modulate color and coverage, write result as the color output.
-        kModulate_PrimaryOutputType,
-        // Combines the coverage, dst, and color as coverage * color + (1 - coverage) * dst. This
-        // can only be set if fDstReadKey is non-zero.
-        kCombineWithDst_PrimaryOutputType,
-
-        kPrimaryOutputTypeCnt,
-    };
-
-    enum SecondaryOutputType {
-        // There is no secondary output
-        kNone_SecondaryOutputType,
-        // Writes coverage as the secondary output. Only set if dual source blending is supported
-        // and primary output is kModulate.
-        kCoverage_SecondaryOutputType,
-        // Writes coverage * (1 - colorA) as the secondary output. Only set if dual source blending
-        // is supported and primary output is kModulate.
-        kCoverageISA_SecondaryOutputType,
-        // Writes coverage * (1 - colorRGBA) as the secondary output. Only set if dual source
-        // blending is supported and primary output is kModulate.
-        kCoverageISC_SecondaryOutputType,
-
-        kSecondaryOutputTypeCnt,
-    };
-
-    PrimaryOutputType getPrimaryOutputType() const { return fPrimaryOutputType; }
-    SecondaryOutputType getSecondaryOutputType() const { return fSecondaryOutputType; }
+    const GrProgramDesc& desc() const { return fDesc; }
 
     /// @}
 
 private:
     /**
      * Optimizations for blending / coverage to that can be applied based on the current state.
      */
     enum BlendOptFlags {
         /**
          * No optimization
@@ skipping 18 matching lines @@
          */
         kEmitTransBlack_BlendOptFlag    = 0x8,
     };
     GR_DECL_BITFIELD_OPS_FRIENDS(BlendOptFlags);
 
     /**
      * Constructs and optimized drawState out of a GrRODrawState.
      */
     GrOptDrawState(const GrDrawState& drawState, BlendOptFlags blendOptFlags,
                    GrBlendCoeff optSrcCoeff, GrBlendCoeff optDstCoeff,
-                   const GrDrawTargetCaps& caps);
+                   GrGpu*, 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, int* firstColorStageIdx,
                                      uint8_t* fixFunctionVAToRemove);
 
@@ skipping 70 matching lines @@
     // These flags give aggregated info on the effect stages that are used when building programs.
     bool            fReadsDst;
     bool            fReadsFragPosition;
     bool            fRequiresLocalCoordAttrib;
 
     SkAutoSTArray<4, GrVertexAttrib> fOptVA;
 
     BlendOptFlags   fBlendOptFlags;
 
     // Fragment shader color outputs
-    PrimaryOutputType  fPrimaryOutputType : 8;
-    SecondaryOutputType  fSecondaryOutputType : 8;
+    GrProgramDesc::PrimaryOutputType  fPrimaryOutputType : 8;
+    GrProgramDesc::SecondaryOutputType  fSecondaryOutputType : 8;
+
+    GrProgramDesc fDesc;
 
     typedef SkRefCnt INHERITED;
 };
 
 GR_MAKE_BITFIELD_OPS(GrOptDrawState::BlendOptFlags);
 
 #endif