Rename GrOptDrawState to GrPipeline and GrDrawState to GrPipelineBuilder

src/gpu/GrDrawTarget.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrDrawTarget_DEFINED
 #define GrDrawTarget_DEFINED
 
 #include "GrClipData.h"
 #include "GrClipMaskManager.h"
 #include "GrContext.h"
-#include "GrDrawState.h"
 #include "GrIndexBuffer.h"
 #include "GrPathRendering.h"
+#include "GrPipelineBuilder.h"
 #include "GrTraceMarker.h"
 #include "GrVertexBuffer.h"
 
 #include "SkClipStack.h"
 #include "SkMatrix.h"
 #include "SkPath.h"
 #include "SkStrokeRec.h"
 #include "SkTArray.h"
 #include "SkTLazy.h"
 #include "SkTypes.h"
@@ skipping 91 matching lines @@
      * If the target cannot make space for the request then this function will
      * return false. If vertexCount was non-zero then upon failure the vertex
      * source is reset and likewise for indexCount.
      *
      * The pointers to the space allocated for vertices and indices remain valid
      * until a drawIndexed, drawNonIndexed, drawIndexedInstances, drawRect,
      * copySurface, or push/popGeomtrySource is called. At that point logically a
      * snapshot of the data is made and the pointers are invalid.
      *
      * @param vertexCount  the number of vertices to reserve space for. Can be
-     *                     0. Vertex size is queried from the current GrDrawState.
+     *                     0. Vertex size is queried from the current GrPipelineBuilder.
      * @param indexCount   the number of indices to reserve space for. Can be 0.
      * @param vertices     will point to reserved vertex space if vertexCount is
      *                     non-zero. Illegal to pass NULL if vertexCount > 0.
      * @param indices      will point to reserved index space if indexCount is
      *                     non-zero. Illegal to pass NULL if indexCount > 0.
      */
      bool reserveVertexAndIndexSpace(int vertexCount,
                                      size_t vertexStride,
                                      int indexCount,
                                      void** vertices,
                                      void** indices);
 
     /**
      * Provides hints to caller about the number of vertices and indices
      * that can be allocated cheaply. This can be useful if caller is reserving
      * space but doesn't know exactly how much geometry is needed.
      *
      * Also may hint whether the draw target should be flushed first. This is
      * useful for deferred targets.
      *
      * @param vertexCount  in: hint about how many vertices the caller would
      *                     like to allocate. Vertex size is queried from the
-     *                     current GrDrawState.
+     *                     current GrPipelineBuilder.
      *                     out: a hint about the number of vertices that can be
      *                     allocated cheaply. Negative means no hint.
      *                     Ignored if NULL.
      * @param indexCount   in: hint about how many indices the caller would
      *                     like to allocate.
      *                     out: a hint about the number of indices that can be
      *                     allocated cheaply. Negative means no hint.
      *                     Ignored if NULL.
      *
      * @return  true if target should be flushed based on the input values.
      */
     virtual bool geometryHints(size_t vertexStride, int* vertexCount, int* indexCount) const;
 
     /**
      * Sets source of vertex data for the next draw. Data does not have to be
      * in the buffer until drawIndexed, drawNonIndexed, or drawIndexedInstances.
      *
      * @param buffer        vertex buffer containing vertex data. Must be
      *                      unlocked before draw call. Vertex size is queried
-     *                      from current GrDrawState.
+     *                      from current GrPipelineBuilder.
      */
     void setVertexSourceToBuffer(const GrVertexBuffer* buffer, size_t vertexStride);
 
     /**
      * Sets source of index data for the next indexed draw. Data does not have
      * to be in the buffer until drawIndexed.
      *
      * @param buffer index buffer containing indices. Must be unlocked
      *               before indexed draw call.
      */
@@ skipping 43 matching lines @@
      * @param startVertex  the vertex in the vertex array/buffer corresponding
      *                     to index 0
      * @param startIndex   first index to read from index src.
      * @param vertexCount  one greater than the max index.
      * @param indexCount   the number of index elements to read. The index count
      *                     is effectively trimmed to the last completely
      *                     specified primitive.
      * @param devBounds    optional bounds hint. This is a promise from the caller,
      *                     not a request for clipping.
      */
-    void drawIndexed(GrDrawState*,
+    void drawIndexed(GrPipelineBuilder*,
                      const GrGeometryProcessor*,
                      GrPrimitiveType type,
                      int startVertex,
                      int startIndex,
                      int vertexCount,
                      int indexCount,
                      const SkRect* devBounds = NULL);
 
     /**
      * Draws non-indexed geometry using the current state and current vertex
      * sources.
      *
      * @param type         The type of primitives to draw.
      * @param startVertex  the vertex in the vertex array/buffer corresponding
      *                     to index 0
      * @param vertexCount  one greater than the max index.
      * @param devBounds    optional bounds hint. This is a promise from the caller,
      *                     not a request for clipping.
      */
-    void drawNonIndexed(GrDrawState*,
+    void drawNonIndexed(GrPipelineBuilder*,
                         const GrGeometryProcessor*,
                         GrPrimitiveType type,
                         int startVertex,
                         int vertexCount,
                         const SkRect* devBounds = NULL);
 
     /**
      * Draws path into the stencil buffer. The fill must be either even/odd or
      * winding (not inverse or hairline). It will respect the HW antialias flag
-     * on the draw state (if possible in the 3D API).  Note, we will never have an inverse fill
-     * with stencil path
+     * on the GrPipelineBuilder (if possible in the 3D API).  Note, we will never have an inverse
+     * fill with stencil path
      */
-    void stencilPath(GrDrawState*, const GrPathProcessor*, const GrPath*,GrPathRendering::FillType);
+    void stencilPath(GrPipelineBuilder*, const GrPathProcessor*, const GrPath*,
+                     GrPathRendering::FillType);
 
     /**
      * Draws a path. Fill must not be a hairline. It will respect the HW
-     * antialias flag on the draw state (if possible in the 3D API).
+     * antialias flag on the GrPipelineBuilder (if possible in the 3D API).
      */
-    void drawPath(GrDrawState*, const GrPathProcessor*, const GrPath*, GrPathRendering::FillType);
+    void drawPath(GrPipelineBuilder*, const GrPathProcessor*, const GrPath*,
+                  GrPathRendering::FillType);
 
     /**
      * Draws the aggregate path from combining multiple. Note that this will not
      * always be equivalent to back-to-back calls to drawPath(). It will respect
-     * the HW antialias flag on the draw state (if possible in the 3D API).
+     * the HW antialias flag on the GrPipelineBuilder (if possible in the 3D API).
      *
      * @param pathRange       Source paths to draw from
      * @param indices         Array of path indices to draw
      * @param indexType       Data type of the array elements in indexBuffer
      * @param transformValues Array of transforms for the individual paths
      * @param transformType   Type of transforms in transformBuffer
      * @param count           Number of paths to draw
      * @param fill            Fill type for drawing all the paths
      */
-    void drawPaths(GrDrawState*,
+    void drawPaths(GrPipelineBuilder*,
                    const GrPathProcessor*,
                    const GrPathRange* pathRange,
                    const void* indices,
                    PathIndexType indexType,
                    const float transformValues[],
                    PathTransformType transformType,
                    int count,
                    GrPathRendering::FillType fill);
 
     /**
      * Helper function for drawing rects. It performs a geometry src push and pop
      * and thus will finalize any reserved geometry.
      *
      * @param rect        the rect to draw
      * @param localRect   optional rect that specifies local coords to map onto
      *                    rect. If NULL then rect serves as the local coords.
      * @param localMatrix Optional local matrix. The local coordinates are specified by localRect,
      *                    or if it is NULL by rect. This matrix applies to the coordinate implied by
      *                    that rectangle before it is input to GrCoordTransforms that read local
      *                    coordinates
      */
-    void drawRect(GrDrawState* ds,
+    void drawRect(GrPipelineBuilder* ds,
                   GrColor color,
                   const SkMatrix& viewMatrix,
                   const SkRect& rect,
                   const SkRect* localRect,
                   const SkMatrix* localMatrix) {
         AutoGeometryPush agp(this);
         this->onDrawRect(ds, color, viewMatrix, rect, localRect, localMatrix);
     }
 
     /**
      * Helper for drawRect when the caller doesn't need separate local rects or matrices.
      */
-    void drawSimpleRect(GrDrawState* ds, GrColor color, const SkMatrix& viewM, const SkRect& rect) {
+    void drawSimpleRect(GrPipelineBuilder* ds, GrColor color, const SkMatrix& viewM,
+                        const SkRect& rect) {
         this->drawRect(ds, color, viewM, rect, NULL, NULL);
     }
-    void drawSimpleRect(GrDrawState* ds, GrColor color, const SkMatrix& viewM,
+    void drawSimpleRect(GrPipelineBuilder* ds, GrColor color, const SkMatrix& viewM,
                         const SkIRect& irect) {
         SkRect rect = SkRect::Make(irect);
         this->drawRect(ds, color, viewM, rect, NULL, NULL);
     }
 
     /**
      * This call is used to draw multiple instances of some geometry with a
      * given number of vertices (V) and indices (I) per-instance. The indices in
      * the index source must have the form i[k+I] == i[k] + V. Also, all indices
      * i[kI] ... i[(k+1)I-1] must be elements of the range kV ... (k+1)V-1. As a
@@ skipping 15 matching lines @@
      *                      consists of verticesPerInstance vertices indexed by
      *                      indicesPerInstance indices drawn as the primitive
      *                      type specified by type.
      * @param verticesPerInstance   The number of vertices in each instance (V
      *                              in the above description).
      * @param indicesPerInstance    The number of indices in each instance (I
      *                              in the above description).
      * @param devBounds    optional bounds hint. This is a promise from the caller,
      *                     not a request for clipping.
      */
-    void drawIndexedInstances(GrDrawState*,
+    void drawIndexedInstances(GrPipelineBuilder*,
                               const GrGeometryProcessor*,
                               GrPrimitiveType type,
                               int instanceCount,
                               int verticesPerInstance,
                               int indicesPerInstance,
                               const SkRect* devBounds = NULL);
 
     /**
-     * Clear the passed in render target. Ignores the draw state and clip. Clears the whole thing if
-     * rect is NULL, otherwise just the rect. If canIgnoreRect is set then the entire render target
-     * can be optionally cleared.
+     * Clear the passed in render target. Ignores the GrPipelineBuilder and clip. Clears the whole
+     * thing if rect is NULL, otherwise just the rect. If canIgnoreRect is set then the entire
+     * render target can be optionally cleared.
      */
     void clear(const SkIRect* rect,
                GrColor color,
                bool canIgnoreRect,
                GrRenderTarget* renderTarget);
 
     /**
      * Discards the contents render target.
      **/
     virtual void discard(GrRenderTarget*) = 0;
@@ skipping 268 matching lines @@
     }
 
     // Subclass must initialize this in its constructor.
     SkAutoTUnref<const GrDrawTargetCaps> fCaps;
 
     const GrTraceMarkerSet& getActiveTraceMarkers() { return fActiveTraceMarkers; }
 
     // Makes a copy of the dst if it is necessary for the draw. Returns false if a copy is required
     // but couldn't be made. Otherwise, returns true.  This method needs to be protected because it
     // needs to be accessed by GLPrograms to setup a correct drawstate
-    bool setupDstReadIfNecessary(GrDrawState*,
+    bool setupDstReadIfNecessary(GrPipelineBuilder*,
                                  GrDeviceCoordTexture* dstCopy,
                                  const SkRect* drawBounds);
 
 private:
     /**
      * This will be called before allocating a texture as a dst for copySurface. This function
      * populates the dstDesc's config, flags, and origin so as to maximize efficiency and guarantee
      * success of the copySurface call.
      */
     void initCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* dstDesc) {
@@ skipping 19 matching lines @@
     // implemented by subclass to allocate space for reserved geom
     virtual bool onReserveVertexSpace(size_t vertexSize, int vertexCount, void** vertices) = 0;
     virtual bool onReserveIndexSpace(int indexCount, void** indices) = 0;
     // implemented by subclass to handle release of reserved geom space
     virtual void releaseReservedVertexSpace() = 0;
     virtual void releaseReservedIndexSpace() = 0;
     // subclass overrides to be notified just before geo src state is pushed/popped.
     virtual void geometrySourceWillPush() = 0;
     virtual void geometrySourceWillPop(const GeometrySrcState& restoredState) = 0;
     // subclass called to perform drawing
-    virtual void onDraw(const GrDrawState&,
+    virtual void onDraw(const GrPipelineBuilder&,
                         const GrGeometryProcessor*,
                         const DrawInfo&,
                         const GrScissorState&,
                         const GrDeviceCoordTexture* dstCopy) = 0;
     // TODO copy in order drawbuffer onDrawRect to here
-    virtual void onDrawRect(GrDrawState*,
+    virtual void onDrawRect(GrPipelineBuilder*,
                             GrColor color,
                             const SkMatrix& viewMatrix,
                             const SkRect& rect,
                             const SkRect* localRect,
                             const SkMatrix* localMatrix) = 0;
 
-    virtual void onStencilPath(const GrDrawState&,
+    virtual void onStencilPath(const GrPipelineBuilder&,
                                const GrPathProcessor*,
                                const GrPath*,
                                const GrScissorState&,
                                const GrStencilSettings&) = 0;
-    virtual void onDrawPath(const GrDrawState&,
+    virtual void onDrawPath(const GrPipelineBuilder&,
                             const GrPathProcessor*,
                             const GrPath*,
                             const GrScissorState&,
                             const GrStencilSettings&,
                             const GrDeviceCoordTexture* dstCopy) = 0;
-    virtual void onDrawPaths(const GrDrawState&,
+    virtual void onDrawPaths(const GrPipelineBuilder&,
                              const GrPathProcessor*,
                              const GrPathRange*,
                              const void* indices,
                              PathIndexType,
                              const float transformValues[],
                              PathTransformType,
                              int count,
                              const GrScissorState&,
                              const GrStencilSettings&,
                              const GrDeviceCoordTexture*) = 0;
@@ skipping 26 matching lines @@
     virtual bool onInitCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* dstDesc) = 0;
 
     // helpers for reserving vertex and index space.
     bool reserveVertexSpace(size_t vertexSize,
                             int vertexCount,
                             void** vertices);
     bool reserveIndexSpace(int indexCount, void** indices);
 
     // called by drawIndexed and drawNonIndexed. Use a negative indexCount to
     // indicate non-indexed drawing.
-    bool checkDraw(const GrDrawState&,
+    bool checkDraw(const GrPipelineBuilder&,
                    const GrGeometryProcessor*,
                    GrPrimitiveType type,
                    int startVertex,
                    int startIndex,
                    int vertexCount,
                    int indexCount) const;
     // called when setting a new vert/idx source to unref prev vb/ib
     void releasePreviousVertexSource();
     void releasePreviousIndexSource();
 
     // Check to see if this set of draw commands has been sent out
     virtual bool       isIssued(uint32_t drawID) { return true; }
     void getPathStencilSettingsForFilltype(GrPathRendering::FillType,
                                            const GrStencilBuffer*,
                                            GrStencilSettings*);
     virtual GrClipMaskManager* clipMaskManager() = 0;
-    virtual bool setupClip(GrDrawState*,
-                           GrDrawState::AutoRestoreEffects* are,
-                           GrDrawState::AutoRestoreStencil* ars,
+    virtual bool setupClip(GrPipelineBuilder*,
+                           GrPipelineBuilder::AutoRestoreEffects* are,
+                           GrPipelineBuilder::AutoRestoreStencil* ars,
                            GrScissorState* scissorState,
                            const SkRect* devBounds) = 0;
 
     enum {
         kPreallocGeoSrcStateStackCnt = 4,
     };
     SkSTArray<kPreallocGeoSrcStateStackCnt, GeometrySrcState, true> fGeoSrcStateStack;
     const GrClipData*                                               fClip;
     // The context owns us, not vice-versa, so this ptr is not ref'ed by DrawTarget.
     GrContext*                                                      fContext;
@@ skipping 37 matching lines @@
         // get rid of them all.
         fClipMaskManager.purgeResources();
     };
 
 protected:
     GrClipMaskManager           fClipMaskManager;
 
 private:
     GrClipMaskManager* clipMaskManager() SK_OVERRIDE { return &fClipMaskManager; }
 
-    virtual bool setupClip(GrDrawState*,
-                           GrDrawState::AutoRestoreEffects* are,
-                           GrDrawState::AutoRestoreStencil* ars,
+    virtual bool setupClip(GrPipelineBuilder*,
+                           GrPipelineBuilder::AutoRestoreEffects* are,
+                           GrPipelineBuilder::AutoRestoreStencil* ars,
                            GrScissorState* scissorState,
                            const SkRect* devBounds) SK_OVERRIDE;
 
     typedef GrDrawTarget INHERITED;
 };
 
 #endif