Line data Source code
1 : /*
2 : * Copyright 2010 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 GrBufferAllocPool_DEFINED
9 : #define GrBufferAllocPool_DEFINED
10 :
11 : #include "SkTArray.h"
12 : #include "SkTDArray.h"
13 : #include "SkTypes.h"
14 : #include "GrTypesPriv.h"
15 :
16 : class GrBuffer;
17 : class GrGpu;
18 :
19 : /**
20 : * A pool of geometry buffers tied to a GrGpu.
21 : *
22 : * The pool allows a client to make space for geometry and then put back excess
23 : * space if it over allocated. When a client is ready to draw from the pool
24 : * it calls unmap on the pool ensure buffers are ready for drawing. The pool
25 : * can be reset after drawing is completed to recycle space.
26 : *
27 : * At creation time a minimum per-buffer size can be specified. Additionally,
28 : * a number of buffers to preallocate can be specified. These will
29 : * be allocated at the min size and kept around until the pool is destroyed.
30 : */
31 : class GrBufferAllocPool : SkNoncopyable {
32 : public:
33 : /**
34 : * Ensures all buffers are unmapped and have all data written to them.
35 : * Call before drawing using buffers from the pool.
36 : */
37 : void unmap();
38 :
39 : /**
40 : * Invalidates all the data in the pool, unrefs non-preallocated buffers.
41 : */
42 : void reset();
43 :
44 : /**
45 : * Frees data from makeSpaces in LIFO order.
46 : */
47 : void putBack(size_t bytes);
48 :
49 : protected:
50 : /**
51 : * Constructor
52 : *
53 : * @param gpu The GrGpu used to create the buffers.
54 : * @param bufferType The type of buffers to create.
55 : * @param bufferSize The minimum size of created buffers.
56 : * This value will be clamped to some
57 : * reasonable minimum.
58 : */
59 : GrBufferAllocPool(GrGpu* gpu,
60 : GrBufferType bufferType,
61 : size_t bufferSize = 0);
62 :
63 : virtual ~GrBufferAllocPool();
64 :
65 : /**
66 : * Returns a block of memory to hold data. A buffer designated to hold the
67 : * data is given to the caller. The buffer may or may not be locked. The
68 : * returned ptr remains valid until any of the following:
69 : * *makeSpace is called again.
70 : * *unmap is called.
71 : * *reset is called.
72 : * *this object is destroyed.
73 : *
74 : * Once unmap on the pool is called the data is guaranteed to be in the
75 : * buffer at the offset indicated by offset. Until that time it may be
76 : * in temporary storage and/or the buffer may be locked.
77 : *
78 : * @param size the amount of data to make space for
79 : * @param alignment alignment constraint from start of buffer
80 : * @param buffer returns the buffer that will hold the data.
81 : * @param offset returns the offset into buffer of the data.
82 : * @return pointer to where the client should write the data.
83 : */
84 : void* makeSpace(size_t size,
85 : size_t alignment,
86 : const GrBuffer** buffer,
87 : size_t* offset);
88 :
89 : GrBuffer* getBuffer(size_t size);
90 :
91 : private:
92 : struct BufferBlock {
93 : size_t fBytesFree;
94 : GrBuffer* fBuffer;
95 : };
96 :
97 : bool createBlock(size_t requestSize);
98 : void destroyBlock();
99 : void deleteBlocks();
100 : void flushCpuData(const BufferBlock& block, size_t flushSize);
101 : void* resetCpuData(size_t newSize);
102 : #ifdef SK_DEBUG
103 : void validate(bool unusedBlockAllowed = false) const;
104 : #endif
105 : size_t fBytesInUse;
106 :
107 : GrGpu* fGpu;
108 : size_t fMinBlockSize;
109 : GrBufferType fBufferType;
110 :
111 : SkTArray<BufferBlock> fBlocks;
112 : void* fCpuData;
113 : void* fBufferPtr;
114 : size_t fBufferMapThreshold;
115 : };
116 :
117 : /**
118 : * A GrBufferAllocPool of vertex buffers
119 : */
120 0 : class GrVertexBufferAllocPool : public GrBufferAllocPool {
121 : public:
122 : /**
123 : * Constructor
124 : *
125 : * @param gpu The GrGpu used to create the vertex buffers.
126 : */
127 : GrVertexBufferAllocPool(GrGpu* gpu);
128 :
129 : /**
130 : * Returns a block of memory to hold vertices. A buffer designated to hold
131 : * the vertices given to the caller. The buffer may or may not be locked.
132 : * The returned ptr remains valid until any of the following:
133 : * *makeSpace is called again.
134 : * *unmap is called.
135 : * *reset is called.
136 : * *this object is destroyed.
137 : *
138 : * Once unmap on the pool is called the vertices are guaranteed to be in
139 : * the buffer at the offset indicated by startVertex. Until that time they
140 : * may be in temporary storage and/or the buffer may be locked.
141 : *
142 : * @param vertexSize specifies size of a vertex to allocate space for
143 : * @param vertexCount number of vertices to allocate space for
144 : * @param buffer returns the vertex buffer that will hold the
145 : * vertices.
146 : * @param startVertex returns the offset into buffer of the first vertex.
147 : * In units of the size of a vertex from layout param.
148 : * @return pointer to first vertex.
149 : */
150 : void* makeSpace(size_t vertexSize,
151 : int vertexCount,
152 : const GrBuffer** buffer,
153 : int* startVertex);
154 :
155 : private:
156 : typedef GrBufferAllocPool INHERITED;
157 : };
158 :
159 : /**
160 : * A GrBufferAllocPool of index buffers
161 : */
162 0 : class GrIndexBufferAllocPool : public GrBufferAllocPool {
163 : public:
164 : /**
165 : * Constructor
166 : *
167 : * @param gpu The GrGpu used to create the index buffers.
168 : */
169 : GrIndexBufferAllocPool(GrGpu* gpu);
170 :
171 : /**
172 : * Returns a block of memory to hold indices. A buffer designated to hold
173 : * the indices is given to the caller. The buffer may or may not be locked.
174 : * The returned ptr remains valid until any of the following:
175 : * *makeSpace is called again.
176 : * *unmap is called.
177 : * *reset is called.
178 : * *this object is destroyed.
179 : *
180 : * Once unmap on the pool is called the indices are guaranteed to be in the
181 : * buffer at the offset indicated by startIndex. Until that time they may be
182 : * in temporary storage and/or the buffer may be locked.
183 : *
184 : * @param indexCount number of indices to allocate space for
185 : * @param buffer returns the index buffer that will hold the indices.
186 : * @param startIndex returns the offset into buffer of the first index.
187 : * @return pointer to first index.
188 : */
189 : void* makeSpace(int indexCount,
190 : const GrBuffer** buffer,
191 : int* startIndex);
192 :
193 : private:
194 : typedef GrBufferAllocPool INHERITED;
195 : };
196 :
197 : #endif
|
