Combine similar DrawPaths calls in GrInOrderDrawBuffer

src/gpu/GrInOrderDrawBuffer.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 GrInOrderDrawBuffer_DEFINED
 #define GrInOrderDrawBuffer_DEFINED
 
@@ skipping 37 matching lines @@
      *                   the vertex source is either reserved or array.
      * @param indexPool  pool where indices for queued draws will be saved when
      *                   the index source is either reserved or array.
      */
     GrInOrderDrawBuffer(GrGpu* gpu,
                         GrVertexBufferAllocPool* vertexPool,
                         GrIndexBufferAllocPool* indexPool);
 
     virtual ~GrInOrderDrawBuffer();
 
+    GrGpu* dstGpu() const { return fDstGpu; }

[bsalomon, 2014/11/13 17:36:05]

Does this need to be public? Otherwise looks good.

[Chris Dalton, 2014/11/13 19:05:43]

Done.

+    const uint32_t* pathIndexBuffer() const { return fPathIndexBuffer.begin(); }
+    const float* pathTransformBuffer() const { return fPathTransformBuffer.begin(); }
+
     /**
      * Empties the draw buffer of any queued up draws. This must not be called while inside an
      * unbalanced pushGeometrySource(). The current draw state and clip are preserved.
      */
     void reset();
 
     /**
      * This plays the queued up draws to its GrGpu target. It also resets this object (i.e. flushing
      * is destructive). This buffer must not have an active reserved vertex or index source. Any
      * reserved geometry on the target will be finalized because it's geometry source will be pushed
@@ skipping 35 matching lines @@
         kClear_Cmd          = 4,
         kCopySurface_Cmd    = 5,
         kDrawPath_Cmd       = 6,
         kDrawPaths_Cmd      = 7,
     };
 
     struct Cmd : ::SkNoncopyable {
         Cmd(uint8_t type) : fType(type) {}
         virtual ~Cmd() {}
 
-        virtual void execute(GrGpu*, const GrOptDrawState*) = 0;
+        virtual void execute(GrInOrderDrawBuffer*, const GrOptDrawState*) = 0;
 
         uint8_t fType;
     };
 
     struct Draw : public Cmd {
         Draw(const DrawInfo& info,
              const ScissorState& scissorState,
              const GrVertexBuffer* vb,
              const GrIndexBuffer* ib)
             : Cmd(kDraw_Cmd)
             , fInfo(info)
             , fScissorState(scissorState)
             , fVertexBuffer(vb)
             , fIndexBuffer(ib) {}
 
         const GrVertexBuffer* vertexBuffer() const { return fVertexBuffer.get(); }
         const GrIndexBuffer* indexBuffer() const { return fIndexBuffer.get(); }
 
-        virtual void execute(GrGpu*, const GrOptDrawState*);
+        virtual void execute(GrInOrderDrawBuffer*, const GrOptDrawState*);
 
         DrawInfo     fInfo;
         ScissorState fScissorState;
 
     private:
         GrPendingIOResource<const GrVertexBuffer, kRead_GrIOType>    fVertexBuffer;
         GrPendingIOResource<const GrIndexBuffer, kRead_GrIOType>     fIndexBuffer;
     };
 
     struct StencilPath : public Cmd {
         StencilPath(const GrPath* path) : Cmd(kStencilPath_Cmd), fPath(path) {}
 
         const GrPath* path() const { return fPath.get(); }
 
-        virtual void execute(GrGpu*, const GrOptDrawState*);
+        virtual void execute(GrInOrderDrawBuffer*, const GrOptDrawState*);
 
         ScissorState      fScissorState;
         GrStencilSettings fStencilSettings;
 
     private:
         GrPendingIOResource<const GrPath, kRead_GrIOType>   fPath;
     };
 
     struct DrawPath : public Cmd {
         DrawPath(const GrPath* path) : Cmd(kDrawPath_Cmd), fPath(path) {}
 
         const GrPath* path() const { return fPath.get(); }
 
-        virtual void execute(GrGpu*, const GrOptDrawState*);
+        virtual void execute(GrInOrderDrawBuffer*, const GrOptDrawState*);
 
         GrDeviceCoordTexture    fDstCopy;
         ScissorState            fScissorState;
         GrStencilSettings       fStencilSettings;
 
     private:
         GrPendingIOResource<const GrPath, kRead_GrIOType> fPath;
     };
 
     struct DrawPaths : public Cmd {
         DrawPaths(const GrPathRange* pathRange) : Cmd(kDrawPaths_Cmd), fPathRange(pathRange) {}
 
         const GrPathRange* pathRange() const { return fPathRange.get();  }
-        uint32_t* indices() { return reinterpret_cast<uint32_t*>(CmdBuffer::GetDataForItem(this)); }
-        float* transforms() { return reinterpret_cast<float*>(&this->indices()[fCount]); }
 
-        virtual void execute(GrGpu*, const GrOptDrawState*);
+        virtual void execute(GrInOrderDrawBuffer*, const GrOptDrawState*);
 
+        int                     fIndicesLocation;
         size_t                  fCount;
+        int                     fTransformsLocation;
         PathTransformType       fTransformsType;
         GrDeviceCoordTexture    fDstCopy;
         ScissorState            fScissorState;
         GrStencilSettings       fStencilSettings;
 
     private:
         GrPendingIOResource<const GrPathRange, kRead_GrIOType> fPathRange;
     };
 
     // This is also used to record a discard by setting the color to GrColor_ILLEGAL
     struct Clear : public Cmd {
         Clear(GrRenderTarget* rt) : Cmd(kClear_Cmd), fRenderTarget(rt) {}
 
         GrRenderTarget* renderTarget() const { return fRenderTarget.get(); }
 
-        virtual void execute(GrGpu*, const GrOptDrawState*);
+        virtual void execute(GrInOrderDrawBuffer*, const GrOptDrawState*);
 
         SkIRect fRect;
         GrColor fColor;
         bool    fCanIgnoreRect;
 
     private:
         GrPendingIOResource<GrRenderTarget, kWrite_GrIOType> fRenderTarget;
     };
 
     // This command is ONLY used by the clip mask manager to clear the stencil clip bits
     struct ClearStencilClip : public Cmd {
         ClearStencilClip(GrRenderTarget* rt) : Cmd(kClear_Cmd), fRenderTarget(rt) {}
 
         GrRenderTarget* renderTarget() const { return fRenderTarget.get(); }
 
-        virtual void execute(GrGpu*, const GrOptDrawState*);
+        virtual void execute(GrInOrderDrawBuffer*, const GrOptDrawState*);
 
         SkIRect fRect;
         bool    fInsideClip;
 
     private:
         GrPendingIOResource<GrRenderTarget, kWrite_GrIOType> fRenderTarget;
     };
 
     struct CopySurface : public Cmd {
         CopySurface(GrSurface* dst, GrSurface* src) : Cmd(kCopySurface_Cmd), fDst(dst), fSrc(src) {}
 
         GrSurface* dst() const { return fDst.get(); }
         GrSurface* src() const { return fSrc.get(); }
 
-        virtual void execute(GrGpu*, const GrOptDrawState*);
+        virtual void execute(GrInOrderDrawBuffer*, const GrOptDrawState*);
 
         SkIPoint    fDstPoint;
         SkIRect     fSrcRect;
 
     private:
         GrPendingIOResource<GrSurface, kWrite_GrIOType> fDst;
         GrPendingIOResource<GrSurface, kRead_GrIOType> fSrc;
     };
 
     struct SetState : public Cmd {
         SetState(const GrDrawState& state) : Cmd(kSetState_Cmd), fState(state) {}
 
-        virtual void execute(GrGpu*, const GrOptDrawState*);
+        virtual void execute(GrInOrderDrawBuffer*, const GrOptDrawState*);
 
         GrDrawState fState;
         GrGpu::DrawType fDrawType;
         GrDeviceCoordTexture fDstCopy;
     };
 
     typedef void* TCmdAlign; // This wouldn't be enough align if a command used long double.
     typedef GrTRecorder<Cmd, TCmdAlign> CmdBuffer;
 
     // overrides from GrDrawTarget
@@ skipping 43 matching lines @@
     // We lazily record clip changes in order to skip clips that have no effect.
     void recordClipIfNecessary();
     // Records any trace markers for a command after adding it to the buffer.
     void recordTraceMarkersIfNecessary();
 
     virtual bool isIssued(uint32_t drawID) { return drawID != fDrawID; }
 
     // TODO: Use a single allocator for commands and records
     enum {
         kCmdBufferInitialSizeInBytes = 8 * 1024,
+        kPathIdxBufferMinReserve     = 64,
+        kPathXformBufferMinReserve   = 2 * kPathIdxBufferMinReserve,
         kGeoPoolStatePreAllocCnt     = 4,
     };
 
     CmdBuffer                         fCmdBuffer;
     GrDrawState*                      fLastState;
     SkTArray<GrTraceMarkerSet, false> fGpuCmdMarkers;
     GrGpu*                            fDstGpu;
     GrVertexBufferAllocPool&          fVertexPool;
     GrIndexBufferAllocPool&           fIndexPool;
+    SkTDArray<uint32_t>               fPathIndexBuffer;
+    SkTDArray<float>                  fPathTransformBuffer;
 
     struct GeometryPoolState {
         const GrVertexBuffer*   fPoolVertexBuffer;
         int                     fPoolStartVertex;
         const GrIndexBuffer*    fPoolIndexBuffer;
         int                     fPoolStartIndex;
         // caller may conservatively over reserve vertices / indices.
         // we release unused space back to allocator if possible
         // can only do this if there isn't an intervening pushGeometrySource()
         size_t                  fUsedPoolVertexBytes;
         size_t                  fUsedPoolIndexBytes;
     };
 
     typedef SkSTArray<kGeoPoolStatePreAllocCnt, GeometryPoolState> GeoPoolStateStack;
 
     GeoPoolStateStack                                   fGeoPoolStateStack;
     bool                                                fFlushing;
     uint32_t                                            fDrawID;
 
     typedef GrClipTarget INHERITED;
 };
 
 #endif