Make drawRect preserve vertex attrib state and push/pop the geom sources.

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
@@ skipping 313 matching lines @@
                         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).
      */
     void stencilPath(const GrPath*, const SkStrokeRec& stroke, SkPath::FillType fill);
 
     /**
-     * Helper function for drawing rects. This does not use the current index
-     * and vertex sources. After returning, the vertex and index sources may
-     * have changed. They should be reestablished before the next draw call.
-     * This cannot be called between reserving and releasing
-     * geometry.
-     *
-     * A subclass may override this to perform more optimal rect rendering. Its
-     * draws should be funneled through one of the public GrDrawTarget draw methods
-     * (e.g. drawNonIndexed, drawIndexedInstances, ...). The base class draws a two
-     * triangle fan using drawNonIndexed from reserved vertex space.
+     * 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 matrix      optional matrix applied to rect (before viewMatrix)
      * @param localRect   optional rect that specifies local coords to map onto
      *                    rect. If NULL then rect serves as the local coords.
      * @param localMatrix optional matrix applied to localRect. If
      *                    srcRect is non-NULL and srcMatrix is non-NULL
      *                    then srcRect will be transformed by srcMatrix.
      *                    srcMatrix can be NULL when no srcMatrix is desired.
      */
-    virtual void drawRect(const GrRect& rect,
-                          const SkMatrix* matrix,
-                          const GrRect* localRect,
-                          const SkMatrix* localMatrix);
+    void drawRect(const GrRect& rect,
+                  const SkMatrix* matrix,
+                  const GrRect* localRect,
+                  const SkMatrix* localMatrix) {
+        AutoGeometryPush agp(this);
+        this->onDrawRect(rect, matrix, localRect, localMatrix);
+    }
 
     /**
      * Helper for drawRect when the caller doesn't need separate local rects or matrices.
      */
     void drawSimpleRect(const GrRect& rect, const SkMatrix* matrix = NULL) {
         drawRect(rect, matrix, NULL, NULL);
     }
     void drawSimpleRect(const GrIRect& irect, const SkMatrix* matrix = NULL) {
         SkRect rect = SkRect::MakeFromIRect(irect);
         this->drawRect(rect, matrix, NULL, NULL);
@@ skipping 158 matching lines @@
         }
     private:
         GrDrawTarget*           fTarget;
         const GrClipData*       fClip;
         SkTLazy<SkClipStack>    fStack;
         GrClipData              fReplacementClip;
     };
 
     ////////////////////////////////////////////////////////////////////////////
 
-    class AutoGeometryAndStatePush : ::GrNoncopyable {
+    /**
+     * Saves the geometry src state at construction and restores in the destructor. It also saves
+     * and then restores the vertex attrib state.
+     */
+    class AutoGeometryPush : ::GrNoncopyable {
     public:
-        AutoGeometryAndStatePush(GrDrawTarget* target, ASRInit init)
-            : fState(target, init) {
+        AutoGeometryPush(GrDrawTarget* target)
+            : fAttribRestore(target->drawState()) {
             GrAssert(NULL != target);
             fTarget = target;
             target->pushGeometrySource();
         }
-        ~AutoGeometryAndStatePush() {
-            fTarget->popGeometrySource();
+
+        ~AutoGeometryPush() { fTarget->popGeometrySource(); }
+
+    private:
+        GrDrawTarget*                           fTarget;
+        GrDrawState::AutoVertexAttribRestore    fAttribRestore;
+    };
+
+    /**
+     * Combination of AutoGeometryPush and AutoStateRestore. The vertex attribs will be in default
+     * state regardless of ASRInit value.

[jvanverth1, 2013/04/02 18:45:35]

Maybe I'm misunderstanding. What happens if the pushed geometry doesn't match
the default vertex attribs? Why not use  AutoVertexAttribRestore?

[bsalomon, 2013/04/02 18:47:39]

It's already using an AutoStateRestore. So it will restore the entire
GrDrawState that was previously set including its vertex attribs.

+     */
+    class AutoGeometryAndStatePush : ::GrNoncopyable {
+    public:
+        AutoGeometryAndStatePush(GrDrawTarget* target, ASRInit init)
+            : fState(target, init){
+            GrAssert(NULL != target);
+            fTarget = target;
+            target->pushGeometrySource();
+            if (kPreserve_ASRInit == init) {
+                target->drawState()->setDefaultVertexAttribs();
+            }
         }
+
+        ~AutoGeometryAndStatePush() { fTarget->popGeometrySource(); }
+
     private:
+        AutoStateRestore fState;
         GrDrawTarget*    fTarget;
-        AutoStateRestore fState;
     };
 
 protected:
 
     enum GeometrySrcType {
         kNone_GeometrySrcType,     //<! src has not been specified
         kReserved_GeometrySrcType, //<! src was set using reserve*Space
         kArray_GeometrySrcType,    //<! src was set using set*SourceToArray
         kBuffer_GeometrySrcType    //<! src was set using set*SourceToBuffer
     };
@@ skipping 150 matching lines @@
     virtual void onSetVertexSourceToArray(const void* vertexArray, int vertexCount) = 0;
     virtual void onSetIndexSourceToArray(const void* indexArray, int indexCount) = 0;
     // subclass is notified that geom source will be set away from an array
     virtual void releaseVertexArray() = 0;
     virtual void releaseIndexArray() = 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 DrawInfo&) = 0;
+    // Implementation of drawRect. The geometry src and vertex attribs will already
+    // be saved before this is called and restored afterwards. A subclass may override
+    // this to perform more optimal rect rendering. Its draws should be funneled through
+    // one of the public GrDrawTarget draw methods (e.g. drawNonIndexed,
+    // drawIndexedInstances, ...). The base class draws a two triangle fan using
+    // drawNonIndexed from reserved vertex space.
+    virtual void onDrawRect(const GrRect& rect,
+                            const SkMatrix* matrix,
+                            const GrRect* localRect,
+                            const SkMatrix* localMatrix);
     virtual void onStencilPath(const GrPath*, const SkStrokeRec& stroke, SkPath::FillType fill) = 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.
@@ skipping 15 matching lines @@
     const GrClipData*                                               fClip;
     GrDrawState*                                                    fDrawState;
     GrDrawState                                                     fDefaultDrawState;
     // The context owns us, not vice-versa, so this ptr is not ref'ed by DrawTarget.
     GrContext*                                                      fContext;
 
     typedef GrRefCnt INHERITED;
 };
 
 #endif