GrBatchPrototype

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 "GrPendingFragmentStage.h"
 #include "GrProgramDesc.h"
 #include "GrStencil.h"
 #include "GrTypesPriv.h"
 #include "SkMatrix.h"
 #include "SkRefCnt.h"
 
+class GrBatch;
 class GrDeviceCoordTexture;
 class GrDrawState;
-class GrPathProcessor;
 
 /**
  * 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:
     SK_DECLARE_INST_COUNT(GrOptDrawState)
 
+    // TODO get rid of this version of the constructor when we use batch everywhere
     GrOptDrawState(const GrDrawState& drawState, const GrPrimitiveProcessor*,
                    const GrDrawTargetCaps&, const GrScissorState&,
                    const GrDeviceCoordTexture* dstCopy, GrGpu::DrawType);
 
+    GrOptDrawState(GrBatch*,
+                   const GrDrawState& drawState,
+                   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 combineIfPossible(GrOptDrawState& that);
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @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).
     ///
@@ skipping 78 matching lines @@
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
 
     GrGpu::DrawType drawType() const { return fDrawType; }
 
     const GrDeviceCoordTexture* getDstCopy() const { return fDstCopy.texture() ? &fDstCopy : NULL; }
 
     // Finalize *MUST* be called before programDesc()
+    // TODO we need to move the descriptor out of GrOptDrawState.  The program Descriptor should be
+    // a combination of OptState descriptor(which can be created when optstate is constructed)
+    // and GrGeometryProcessor key.
     void finalize(GrGpu*);
 
     const GrProgramDesc& programDesc() const { SkASSERT(fFinalized); return fDesc; }
 
+    void flush(GrGpu*, GrVertexBufferAllocPool*, GrIndexBufferAllocPool*);
+
+    // TODO this is unfortunate, but GrBatch needs to initialize the batch tracker on the GP
+    // NOBODY ELSE should be using this.  Once we use GrBatch everywhere we can remove this
+    GrBatchTracker* batchTracker() { return &fBatchTracker; }
+
+    // TODO this goes away when I pull primitive processor off optstate
+    void setPrimitiveProcessor(const GrPrimitiveProcessor* primProc) {
+        fFinalized = false;
+        fPrimitiveProcessor.reset(primProc);
+    }
+
 private:
+    // TODO we can have one constructor once GrBatch is complete
+    void internalConstructor(GrGeometryProcessor::InitBT*,
+                             const GrDrawState&,
+                             const GrProcOptInfo& colorPOI,
+                             const GrProcOptInfo& coveragePOI,
+                             const GrDrawTargetCaps&,
+                             const GrScissorState&,
+                             const GrDeviceCoordTexture* dstCopy);
+
     /**
      * 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);
 
@@ skipping 31 matching lines @@
 
     // This function is equivalent to the offset into fFragmentStages where coverage stages begin.
     int                                 fNumColorStages;
 
     GrProgramDesc fDesc;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif