mirror of https://github.com/axmolengine/axmol.git
142 lines
4.8 KiB
C++
142 lines
4.8 KiB
C++
/*
|
|
Copyright 2010 Google Inc.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
|
|
#ifndef GrVertexBufferAllocPool_DEFINED
|
|
#define GrVertexBufferAllocPool_DEFINED
|
|
|
|
#include "GrNoncopyable.h"
|
|
#include "GrTDArray.h"
|
|
#include "GrTArray.h"
|
|
|
|
class GrVertexBuffer;
|
|
class GrGpu;
|
|
|
|
/**
|
|
* A pool of vertices in vertex buffers tied to a GrGpu.
|
|
*
|
|
* The pool has an alloc() function that returns a pointer into a locked
|
|
* vertex buffer. A client can release() if it has over-allocated.
|
|
*
|
|
* At creation time a minimum VB size can be specified. Additionally,
|
|
* a number of vertex buffers to preallocate can be specified. These will
|
|
* be allocated at the min size and kept until the pool is destroyed.
|
|
*/
|
|
class GrVertexBufferAllocPool : GrNoncopyable {
|
|
public:
|
|
/**
|
|
* Constructor
|
|
*
|
|
* @param gpu The GrGpu used to create the vertex buffers.
|
|
* @param bufferSize The size of created VBs (unless an alloc request
|
|
* exceeds this size in which case a larger VB is
|
|
* created). This value is clamped to some
|
|
* reasonable minimum.
|
|
* @param preallocBufferCnt The pool will allocate this number of VBs at
|
|
* bufferSize and keep them until it is destroyed.
|
|
*/
|
|
GrVertexBufferAllocPool(GrGpu* gpu,
|
|
size_t bufferSize = 0,
|
|
int preallocBufferCnt = 0);
|
|
~GrVertexBufferAllocPool();
|
|
|
|
/**
|
|
* Ensures all VBs are unlocked. Call before using to draw.
|
|
*/
|
|
void unlock();
|
|
|
|
/**
|
|
* Frees all vertex data that has been allocated with alloc().
|
|
*/
|
|
void reset();
|
|
|
|
/**
|
|
* Returns a block of memory bytes size big. The vertex buffer
|
|
* containing the memory is returned in buffer.
|
|
*
|
|
* @param layout specifies type of vertices to allocate space for
|
|
* @param vertexCount number of vertices to allocate space for
|
|
* @param buffer returns the vertex buffer that will hold the
|
|
* vertices.
|
|
* @param startVertex returns the offset into buffer of the first vertex.
|
|
* In units of the size of a vertex using layout param.
|
|
* @return pointer to first vertex.
|
|
*/
|
|
void* alloc(GrVertexLayout layout,
|
|
uint32_t vertexCount,
|
|
GrVertexBuffer** buffer,
|
|
uint32_t* startVertex);
|
|
|
|
/**
|
|
* Gets the number of vertices that can be allocated without changing VBs.
|
|
* This means either the last VB returned by alloc() if the last alloc did
|
|
* not exhaust it. If that VB was exhausted by the last alloc or alloc hasn't
|
|
* been called since reset() then it will be the number of vertices that
|
|
* would fit in an available preallocated VB. If no preallocated VB
|
|
* is available then it returns 0 since the next alloc would force a new
|
|
* VB to be created.
|
|
*/
|
|
int currentBufferVertices(GrVertexLayout layout) const;
|
|
|
|
/**
|
|
* Gets the number of preallocated buffers that are yet to be used.
|
|
*/
|
|
int preallocatedBuffersRemaining() const;
|
|
|
|
/**
|
|
* Gets the number of vertices that can fit in a preallocated vertex buffer.
|
|
* Zero if no preallocated buffers.
|
|
*/
|
|
int preallocatedBufferVertices(GrVertexLayout layout) const;
|
|
|
|
/**
|
|
* gets the number of preallocated vertex buffers
|
|
*/
|
|
int preallocatedBufferCount() const;
|
|
|
|
|
|
/**
|
|
* Releases the most recently allocated bytes back to the pool.
|
|
*/
|
|
void release(size_t bytes);
|
|
|
|
/**
|
|
* Gets the GrGpu that this pool is associated with.
|
|
*/
|
|
GrGpu* getGpu() { return fGpu; }
|
|
|
|
|
|
private:
|
|
struct BufferBlock {
|
|
size_t fBytesFree;
|
|
GrVertexBuffer* fVertexBuffer;
|
|
};
|
|
|
|
bool createBlock(size_t size);
|
|
void destroyBlock();
|
|
|
|
GrTArray<BufferBlock> fBlocks;
|
|
GrTDArray<GrVertexBuffer*> fPreallocBuffers;
|
|
int fPreallocBuffersInUse;
|
|
int fFirstPreallocBuffer;
|
|
|
|
size_t fMinBlockSize;
|
|
GrGpu* fGpu;
|
|
void* fBufferPtr;
|
|
};
|
|
|
|
#endif
|