Move program descriptor and primitive processor off of optstate

src/gpu/GrGpu.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 GrGpu_DEFINED
 #define GrGpu_DEFINED
 
 #include "GrDrawTarget.h"
 #include "GrPathRendering.h"
 #include "GrProgramDesc.h"
 #include "SkPath.h"
 
 class GrContext;
 class GrIndexBufferAllocPool;
 class GrOptDrawState;
 class GrPath;
 class GrPathRange;
 class GrPathRenderer;
 class GrPathRendererChain;
+class GrPrimitiveProcessor;
 class GrStencilBuffer;
 class GrVertexBufferAllocPool;
 
 class GrGpu : public SkRefCnt {
 public:
 
     /**
      * Additional blend coefficients for dual source blending, not exposed
      * through GrPaint/GrContext.
      */
@@ skipping 275 matching lines @@
         kDrawPath_DrawType,
         kDrawPaths_DrawType,
     };
 
     static bool IsPathRenderingDrawType(DrawType type) {
         return kDrawPath_DrawType == type || kDrawPaths_DrawType == type;
     }
 
     GrContext::GPUStats* gpuStats() { return &fGPUStats; }
 
-    virtual void buildProgramDesc(const GrOptDrawState&,
+    virtual void buildProgramDesc(GrProgramDesc*,
+                                  const GrPrimitiveProcessor&,
+                                  const GrOptDrawState&,
                                   const GrProgramDesc::DescInfo&,
                                   GrGpu::DrawType,
-                                  GrProgramDesc*) = 0;
+                                  const GrBatchTracker&) const = 0;
 
     /**
      * Called at start and end of gpu trace marking
      * GR_CREATE_GPU_TRACE_MARKER(marker_str, target) will automatically call these at the start
      * and end of a code block respectively
      */
     void addGpuTraceMarker(const GrGpuTraceMarker* marker);
     void removeGpuTraceMarker(const GrGpuTraceMarker* marker);
 
     /**
@@ skipping 19 matching lines @@
 
     // Called to perform a surface to surface copy. Fallbacks to issuing a draw from the src to dst
     // take place at the GrDrawTarget level and this function implement faster copy paths. The rect
     // and point are pre-clipped. The src rect and implied dst rect are guaranteed to be within the
     // src/dst bounds and non-empty.
     virtual bool copySurface(GrSurface* dst,
                              GrSurface* src,
                              const SkIRect& srcRect,
                              const SkIPoint& dstPoint) = 0;
 
-    void draw(const GrOptDrawState&, const GrDrawTarget::DrawInfo&);
+    struct DrawArgs {
+        typedef GrDrawTarget::DrawInfo DrawInfo;
+        DrawArgs(const GrPrimitiveProcessor* primProc,
+                 const GrOptDrawState* optState,
+                 const GrProgramDesc* desc,
+                 const GrBatchTracker* batchTracker)
+            : fPrimitiveProcessor(primProc)
+            , fOptState(optState)
+            , fDesc(desc)
+            , fBatchTracker(batchTracker) {
+            SkASSERT(primProc && optState && desc && batchTracker);
+        }
+        const GrPrimitiveProcessor* fPrimitiveProcessor;
+        const GrOptDrawState* fOptState;
+        const GrProgramDesc* fDesc;
+        const GrBatchTracker* fBatchTracker;
+    };
+
+    void draw(const DrawArgs&, const GrDrawTarget::DrawInfo&);
 
     /** None of these params are optional, pointers used just to avoid making copies. */
     struct StencilPathState {
         bool fUseHWAA;
         GrRenderTarget* fRenderTarget;
         const SkMatrix* fViewMatrix;
         const GrStencilSettings* fStencil;
         const GrScissorState* fScissor;
     };
 
     void stencilPath(const GrPath*, const StencilPathState&);
 
-    void drawPath(const GrOptDrawState&, const GrPath*, const GrStencilSettings&);
-    void drawPaths(const GrOptDrawState&,
+    void drawPath(const DrawArgs&, const GrPath*, const GrStencilSettings&);
+    void drawPaths(const DrawArgs&,
                    const GrPathRange*,
                    const void* indices,
                    GrDrawTarget::PathIndexType,
                    const float transformValues[],
                    GrDrawTarget::PathTransformType,
                    int count,
                    const GrStencilSettings&);
 
     static DrawType PrimTypeToDrawType(GrPrimitiveType type) {
         switch (type) {
@@ skipping 53 matching lines @@
                          bool canIgnoreRect) = 0;
 
 
     // Overridden by backend specific classes to perform a clear of the stencil clip bits.  This is
     // ONLY used by the the clip target
     virtual void onClearStencilClip(GrRenderTarget*,
                                     const SkIRect& rect,
                                     bool insideClip) = 0;
 
     // overridden by backend-specific derived class to perform the draw call.
-    virtual void onDraw(const GrOptDrawState&, const GrDrawTarget::DrawInfo&) = 0;
+    virtual void onDraw(const DrawArgs&, const GrDrawTarget::DrawInfo&) = 0;
     virtual void onStencilPath(const GrPath*, const StencilPathState&) = 0;
 
-    virtual void onDrawPath(const GrOptDrawState&, const GrPath*, const GrStencilSettings&) = 0;
-    virtual void onDrawPaths(const GrOptDrawState&,
+    virtual void onDrawPath(const DrawArgs&, const GrPath*, const GrStencilSettings&) = 0;
+    virtual void onDrawPaths(const DrawArgs&,
                              const GrPathRange*,
                              const void* indices,
                              GrDrawTarget::PathIndexType,
                              const float transformValues[],
                              GrDrawTarget::PathTransformType,
                              int count,
                              const GrStencilSettings&) = 0;
 
     // overridden by backend-specific derived class to perform the read pixels.
     virtual bool onReadPixels(GrRenderTarget* target,
@@ skipping 48 matching lines @@
     int                                                                 fGpuTraceMarkerCount;
     GrTraceMarkerSet                                                    fActiveTraceMarkers;
     GrTraceMarkerSet                                                    fStoredTraceMarkers;
     // The context owns us, not vice-versa, so this ptr is not ref'ed by Gpu.
     GrContext*                                                          fContext;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif