1 /* 2 Copyright 2011 Google Inc. 3 4 Licensed under the Apache License, Version 2.0 (the "License"); 5 you may not use this file except in compliance with the License. 6 You may obtain a copy of the License at 7 8 http://www.apache.org/licenses/LICENSE-2.0 9 10 Unless required by applicable law or agreed to in writing, software 11 distributed under the License is distributed on an "AS IS" BASIS, 12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 See the License for the specific language governing permissions and 14 limitations under the License. 15 */ 16 17 18 #ifndef GrInOrderDrawBuffer_DEFINED 19 #define GrInOrderDrawBuffer_DEFINED 20 21 #include "GrDrawTarget.h" 22 #include "GrAllocPool.h" 23 #include "GrAllocator.h" 24 #include "GrClip.h" 25 26 class GrVertexBufferAllocPool; 27 class GrIndexBufferAllocPool; 28 29 /** 30 * GrInOrderDrawBuffer is an implementation of GrDrawTarget that queues up 31 * draws for eventual playback into a GrGpu. In theory one draw buffer could 32 * playback into another. When index or vertex buffers are used as geometry 33 * sources it is the callers the draw buffer only holds references to the 34 * buffers. It is the callers responsibility to ensure that the data is still 35 * valid when the draw buffer is played back into a GrGpu. Similarly, it is the 36 * caller's responsibility to ensure that all referenced textures, buffers, 37 * and rendertargets are associated in the GrGpu object that the buffer is 38 * played back into. The buffer requires VB and IB pools to store geometry. 39 */ 40 41 class GrInOrderDrawBuffer : public GrDrawTarget { 42 public: 43 44 /** 45 * Creates a GrInOrderDrawBuffer 46 * 47 * @param vertexPool pool where vertices for queued draws will be saved when 48 * the vertex source is either reserved or array. 49 * @param indexPool pool where indices for queued draws will be saved when 50 * the index source is either reserved or array. 51 */ 52 GrInOrderDrawBuffer(GrVertexBufferAllocPool* vertexPool, 53 GrIndexBufferAllocPool* indexPool); 54 55 virtual ~GrInOrderDrawBuffer(); 56 57 /** 58 * Copies the draw state and clip from target to this draw buffer. 59 * 60 * @param target the target whose clip and state should be copied. 61 */ 62 void initializeDrawStateAndClip(const GrDrawTarget& target); 63 64 /** 65 * Provides the buffer with an index buffer that can be used for quad rendering. 66 * The buffer may be able to batch consecutive drawRects if this is provided. 67 * @param indexBuffer index buffer with quad indices. 68 */ 69 void setQuadIndexBuffer(const GrIndexBuffer* indexBuffer); 70 71 /** 72 * Empties the draw buffer of any queued up draws. 73 */ 74 void reset(); 75 76 /** 77 * plays the queued up draws to another target. Does not empty this buffer so 78 * that it can be played back multiple times. 79 * @param target the target to receive the playback 80 */ 81 void playback(GrDrawTarget* target); 82 83 // overrides from GrDrawTarget 84 virtual void drawIndexed(GrPrimitiveType primitiveType, 85 int startVertex, 86 int startIndex, 87 int vertexCount, 88 int indexCount); 89 virtual void drawNonIndexed(GrPrimitiveType primitiveType, 90 int startVertex, 91 int vertexCount); 92 93 virtual void drawRect(const GrRect& rect, 94 const GrMatrix* matrix = NULL, 95 int stageEnableMask = 0, 96 const GrRect* srcRects[] = NULL, 97 const GrMatrix* srcMatrices[] = NULL); 98 99 virtual bool geometryHints(GrVertexLayout vertexLayout, 100 int* vertexCount, 101 int* indexCount) const; 102 103 virtual void clear(const GrIRect* rect, GrColor color); 104 105 private: 106 107 struct Draw { 108 GrPrimitiveType fPrimitiveType; 109 int fStartVertex; 110 int fStartIndex; 111 int fVertexCount; 112 int fIndexCount; 113 bool fStateChanged; 114 bool fClipChanged; 115 GrVertexLayout fVertexLayout; 116 const GrVertexBuffer* fVertexBuffer; 117 const GrIndexBuffer* fIndexBuffer; 118 }; 119 120 struct Clear { 121 int fBeforeDrawIdx; 122 GrIRect fRect; 123 GrColor fColor; 124 }; 125 126 virtual bool onAcquireGeometry(GrVertexLayout vertexLayout, 127 void** vertices, 128 void** indices); 129 virtual void onReleaseGeometry(); 130 virtual void clipWillBeSet(const GrClip& newClip); 131 132 virtual void onSetVertexSourceToArray(const void* vertexArray, 133 int vertexCount); 134 135 virtual void onSetIndexSourceToArray(const void* indexArray, 136 int indexCount); 137 138 bool needsNewState() const; 139 bool needsNewClip() const; 140 141 void pushState(); 142 void pushClip(); 143 144 GrTAllocator<Draw> fDraws; 145 GrTAllocator<SavedDrawState> fStates; 146 GrTAllocator<Clear> fClears; 147 148 GrTAllocator<GrClip> fClips; 149 bool fClipSet; 150 151 GrVertexLayout fLastRectVertexLayout; 152 const GrIndexBuffer* fQuadIndexBuffer; 153 int fMaxQuads; 154 int fCurrQuad; 155 156 GrVertexBufferAllocPool& fVertexPool; 157 const GrVertexBuffer* fCurrPoolVertexBuffer; 158 int fCurrPoolStartVertex; 159 160 GrIndexBufferAllocPool& fIndexPool; 161 const GrIndexBuffer* fCurrPoolIndexBuffer; 162 int fCurrPoolStartIndex; 163 164 // caller may conservatively over reserve vertices / indices. 165 // we release unused space back to allocator if possible 166 size_t fReservedVertexBytes; 167 size_t fReservedIndexBytes; 168 size_t fUsedReservedVertexBytes; 169 size_t fUsedReservedIndexBytes; 170 171 enum { 172 kDrawPreallocCnt = 8, 173 kStatePreallocCnt = 8, 174 kClipPreallocCnt = 8, 175 kClearPreallocCnt = 4, 176 }; 177 178 GrAlignedSTStorage<kDrawPreallocCnt, Draw> fDrawStorage; 179 GrAlignedSTStorage<kStatePreallocCnt, SavedDrawState> fStateStorage; 180 GrAlignedSTStorage<kClipPreallocCnt, GrClip> fClipStorage; 181 GrAlignedSTStorage<kClearPreallocCnt, Clear> fClearStorage; 182 183 typedef GrDrawTarget INHERITED; 184 }; 185 186 #endif 187
