Home | History | Annotate | Download | only in batches 
      1 /*
      2  * Copyright 2015 Google Inc.
      3  *
      4  * Use of this source code is governed by a BSD-style license that can be
      5  * found in the LICENSE file.
      6  */
      7 
      8 #ifndef GrVertexBatch_DEFINED
      9 #define GrVertexBatch_DEFINED
     10 
     11 #include "GrDrawBatch.h"
     12 #include "GrPrimitiveProcessor.h"
     13 #include "GrPendingProgramElement.h"
     14 #include "GrVertices.h"
     15 
     16 #include "SkTLList.h"
     17 
     18 class GrBatchFlushState;
     19 
     20 /**
     21  * Base class for vertex-based GrBatches.
     22  */
     23 class GrVertexBatch : public GrDrawBatch {
     24 public:
     25     class Target;
     26 
     27     GrVertexBatch(uint32_t classID);
     28 
     29 protected:
     30     /** Helper for rendering instances using an instanced index index buffer. This class creates the
     31         space for the vertices and flushes the draws to the batch target. */
     32    class InstancedHelper {
     33    public:
     34         InstancedHelper() {}
     35         /** Returns the allocated storage for the vertices. The caller should populate the before
     36             vertices before calling issueDraws(). */
     37         void* init(Target*, GrPrimitiveType, size_t vertexStride,
     38                    const GrIndexBuffer*, int verticesPerInstance, int indicesPerInstance,
     39                    int instancesToDraw);
     40 
     41         /** Call after init() to issue draws to the batch target.*/
     42         void recordDraw(Target* target);
     43     private:
     44         GrVertices  fVertices;
     45     };
     46 
     47     static const int kVerticesPerQuad = 4;
     48     static const int kIndicesPerQuad = 6;
     49 
     50     /** A specialization of InstanceHelper for quad rendering. */
     51     class QuadHelper : private InstancedHelper {
     52     public:
     53         QuadHelper() : INHERITED() {}
     54         /** Finds the cached quad index buffer and reserves vertex space. Returns nullptr on failure
     55             and on sucess a pointer to the vertex data that the caller should populate before
     56             calling issueDraws(). */
     57         void* init(Target* batchTarget, size_t vertexStride, int quadsToDraw);
     58 
     59         using InstancedHelper::recordDraw;
     60     private:
     61         typedef InstancedHelper INHERITED;
     62     };
     63 
     64 private:
     65     void onPrepare(GrBatchFlushState* state) final;
     66     void onDraw(GrBatchFlushState* state) final;
     67 
     68     virtual void onPrepareDraws(Target*) const = 0;
     69 
     70     // A set of contiguous draws with no inline uploads between them that all use the same
     71     // primitive processor. All the draws in a DrawArray share a primitive processor and use the
     72     // the batch's GrPipeline.
     73     struct DrawArray {
     74         SkSTArray<1, GrVertices, true>                      fDraws;
     75         GrPendingProgramElement<const GrPrimitiveProcessor> fPrimitiveProcessor;
     76     };
     77 
     78     // Array of DrawArray. There may be inline uploads between each DrawArray and each DrawArray
     79     // may use a different primitive processor.
     80     typedef SkTLList<DrawArray, 4> DrawArrayList;
     81     DrawArrayList fDrawArrays;
     82 
     83     typedef GrDrawBatch INHERITED;
     84 };
     85 
     86 #endif
     87