Move program descriptor and primitive processor off of optstate

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 19 matching lines @@
     SK_DECLARE_INST_COUNT(GrOptDrawState)
 
     GrOptDrawState(const GrDrawState& drawState, const GrPrimitiveProcessor*,
                    const GrDrawTargetCaps&, const GrScissorState&,
                    const GrDeviceCoordTexture* dstCopy, GrGpu::DrawType);
 
     /*
      * Returns true if it is possible to combine the two GrOptDrawStates and it will update 'this'
      * to subsume 'that''s draw.
      */
-    bool combineIfPossible(const GrOptDrawState& that);
+    bool isEqual(const GrOptDrawState& that) const;
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name Effect Stages
     /// Each stage hosts a GrProcessor. 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
     /// color stage produces the final pixel color. The coverage-computing stages function exactly
     /// as the color-computing but the output of the final coverage stage is treated as a fractional
     /// pixel coverage rather than as input to the src/dst color blend step.
     ///
     /// The input color to the first color-stage is either the constant color or interpolated
     /// per-vertex colors. The input to the first coverage stage is either a constant coverage
     /// (usually full-coverage) or interpolated per-vertex coverage.
     ////
 
     int numColorStages() const { return fNumColorStages; }
     int numCoverageStages() const { return fFragmentStages.count() - fNumColorStages; }
     int numFragmentStages() const { return fFragmentStages.count(); }
 
-    const GrPrimitiveProcessor* getPrimitiveProcessor() const { return fPrimitiveProcessor.get(); }
-    const GrBatchTracker& getBatchTracker() const { return fBatchTracker; }
-
     const GrXferProcessor* getXferProcessor() const { return fXferProcessor.get(); }
 
     const GrPendingFragmentStage& getColorStage(int idx) const {
         SkASSERT(idx < this->numColorStages());
         return fFragmentStages[idx];
     }
     const GrPendingFragmentStage& getCoverageStage(int idx) const {
         SkASSERT(idx < this->numCoverageStages());
         return fFragmentStages[fNumColorStages + idx];
     }
@@ skipping 50 matching lines @@
     GrDrawState::DrawFace getDrawFace() const { return fDrawFace; }
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
 
     GrGpu::DrawType drawType() const { return fDrawType; }
 
     const GrDeviceCoordTexture* getDstCopy() const { return fDstCopy.texture() ? &fDstCopy : NULL; }
 
-    // Finalize *MUST* be called before programDesc()
-    void finalize(GrGpu*);
+    const GrProgramDesc::DescInfo& descInfo() const { return fDescInfo; }
 
-    const GrProgramDesc& programDesc() const { SkASSERT(fFinalized); return fDesc; }
+    const GrGeometryProcessor::InitBT& getInitBatchTracker() const { return fInitBT; }
 
 private:
     /**
      * Alter the program desc and inputs (attribs and processors) based on the blend optimization.
      */
     void adjustProgramFromOptimizations(const GrDrawState& ds,
                                         GrXferProcessor::OptFlags,
                                         const GrProcOptInfo& colorPOI,
                                         const GrProcOptInfo& coveragePOI,
                                         int* firstColorStageIdx,
                                         int* firstCoverageStageIdx);
 
     /**
      * 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, GrXferProcessor::OptFlags,
                             const GrDrawTargetCaps&);
 
     enum Flags {
         kDither_Flag            = 0x1,
         kHWAA_Flag              = 0x2,
     };
 
     typedef GrPendingIOResource<GrRenderTarget, kWrite_GrIOType> RenderTarget;
     typedef SkSTArray<8, GrPendingFragmentStage> FragmentStageArray;
-    typedef GrPendingProgramElement<const GrGeometryProcessor> ProgramGeometryProcessor;
-    typedef GrPendingProgramElement<const GrPrimitiveProcessor> ProgramPrimitiveProcessor;
     typedef GrPendingProgramElement<const GrXferProcessor> ProgramXferProcessor;
     RenderTarget                        fRenderTarget;
     GrScissorState                      fScissorState;
     GrStencilSettings                   fStencilSettings;
     GrDrawState::DrawFace               fDrawFace;
     GrDeviceCoordTexture                fDstCopy;
     uint32_t                            fFlags;
-    ProgramPrimitiveProcessor           fPrimitiveProcessor;
-    GrBatchTracker                      fBatchTracker;
     ProgramXferProcessor                fXferProcessor;
     FragmentStageArray                  fFragmentStages;
     GrGpu::DrawType                     fDrawType;
     GrProgramDesc::DescInfo             fDescInfo;
-    bool                                fFinalized;
+    GrGeometryProcessor::InitBT         fInitBT;
 
     // This function is equivalent to the offset into fFragmentStages where coverage stages begin.
     int                                 fNumColorStages;
 
     GrProgramDesc fDesc;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif