blob: 1f82453c2e5ea3ba527328202660c7cfc825adeb [file] [log] [blame]
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrBatchBuffer_DEFINED
#define GrBatchBuffer_DEFINED
#include "GrBufferAllocPool.h"
#include "batches/GrVertexBatch.h"
class GrResourceProvider;
/** Simple class that performs the upload on behalf of a GrBatchUploader. */
class GrBatchUploader::TextureUploader {
public:
TextureUploader(GrGpu* gpu) : fGpu(gpu) { SkASSERT(gpu); }
/**
* Updates the pixels in a rectangle of a texture.
*
* @param left left edge of the rectangle to write (inclusive)
* @param top top edge of the rectangle to write (inclusive)
* @param width width of rectangle to write in pixels.
* @param height height of rectangle to write in pixels.
* @param config the pixel config of the source buffer
* @param buffer memory to read pixels from
* @param rowBytes number of bytes between consecutive rows. Zero
* means rows are tightly packed.
*/
bool writeTexturePixels(GrTexture* texture,
int left, int top, int width, int height,
GrPixelConfig config, const void* buffer,
size_t rowBytes) {
return fGpu->writePixels(texture, left, top, width, height, config, buffer, rowBytes);
}
private:
GrGpu* fGpu;
};
/** Tracks the state across all the GrBatches in a GrDrawTarget flush. */
class GrBatchFlushState {
public:
GrBatchFlushState(GrGpu*, GrResourceProvider*);
~GrBatchFlushState() { this->reset(); }
void advanceToken() { ++fCurrentToken; }
void advanceLastFlushedToken() { ++fLastFlushedToken; }
/** Inserts an upload to be executred after all batches in the flush prepared their draws
but before the draws are executed to the backend 3D API. */
void addASAPUpload(GrBatchUploader* upload) {
fAsapUploads.push_back().reset(SkRef(upload));
}
const GrCaps& caps() const { return *fGpu->caps(); }
GrResourceProvider* resourceProvider() const { return fResourceProvider; }
/** Has the token been flushed to the backend 3D API. */
bool hasTokenBeenFlushed(GrBatchToken token) const { return fLastFlushedToken >= token; }
/** The current token advances once for every contiguous set of uninterrupted draws prepared
by a batch. */
GrBatchToken currentToken() const { return fCurrentToken; }
/** The last token flushed to all the way to the backend API. */
GrBatchToken lastFlushedToken() const { return fLastFlushedToken; }
/** This is a magic token that can be used to indicate that an upload should occur before
any draws for any batch in the current flush execute. */
GrBatchToken asapToken() const { return fLastFlushedToken + 1; }
void* makeVertexSpace(size_t vertexSize, int vertexCount,
const GrVertexBuffer** buffer, int* startVertex);
uint16_t* makeIndexSpace(int indexCount, const GrIndexBuffer** buffer, int* startIndex);
/** This is called after each batch has a chance to prepare its draws and before the draws
are issued. */
void preIssueDraws() {
fVertexPool.unmap();
fIndexPool.unmap();
int uploadCount = fAsapUploads.count();
for (int i = 0; i < uploadCount; i++) {
fAsapUploads[i]->upload(&fUploader);
}
fAsapUploads.reset();
}
void putBackIndices(size_t indices) { fIndexPool.putBack(indices * sizeof(uint16_t)); }
void putBackVertexSpace(size_t sizeInBytes) { fVertexPool.putBack(sizeInBytes); }
GrBatchUploader::TextureUploader* uploader() { return &fUploader; }
GrGpu* gpu() { return fGpu; }
void reset() {
fVertexPool.reset();
fIndexPool.reset();
}
private:
GrGpu* fGpu;
GrBatchUploader::TextureUploader fUploader;
GrResourceProvider* fResourceProvider;
GrVertexBufferAllocPool fVertexPool;
GrIndexBufferAllocPool fIndexPool;
SkTArray<SkAutoTUnref<GrBatchUploader>, true> fAsapUploads;
GrBatchToken fCurrentToken;
GrBatchToken fLastFlushedToken;
};
/**
* GrDrawBatch instances use this object to allocate space for their geometry and to issue the draws
* that render their batch.
*/
class GrDrawBatch::Target {
public:
Target(GrBatchFlushState* state, GrDrawBatch* batch) : fState(state), fBatch(batch) {}
void upload(GrBatchUploader* upload) {
if (this->asapToken() == upload->lastUploadToken()) {
fState->addASAPUpload(upload);
} else {
fBatch->fInlineUploads.push_back().reset(SkRef(upload));
}
}
bool hasTokenBeenFlushed(GrBatchToken token) const {
return fState->hasTokenBeenFlushed(token);
}
GrBatchToken currentToken() const { return fState->currentToken(); }
GrBatchToken asapToken() const { return fState->asapToken(); }
const GrCaps& caps() const { return fState->caps(); }
GrResourceProvider* resourceProvider() const { return fState->resourceProvider(); }
protected:
GrDrawBatch* batch() { return fBatch; }
GrBatchFlushState* state() { return fState; }
private:
GrBatchFlushState* fState;
GrDrawBatch* fBatch;
};
/** Extension of GrDrawBatch::Target for use by GrVertexBatch. Adds the ability to create vertex
draws. */
class GrVertexBatch::Target : public GrDrawBatch::Target {
public:
Target(GrBatchFlushState* state, GrVertexBatch* batch) : INHERITED(state, batch) {}
void initDraw(const GrPrimitiveProcessor* primProc) {
GrVertexBatch::DrawArray* draws = this->vertexBatch()->fDrawArrays.addToTail();
draws->fPrimitiveProcessor.reset(primProc);
this->state()->advanceToken();
}
void draw(const GrMesh& mesh) {
this->vertexBatch()->fDrawArrays.tail()->fDraws.push_back(mesh);
}
void* makeVertexSpace(size_t vertexSize, int vertexCount,
const GrVertexBuffer** buffer, int* startVertex) {
return this->state()->makeVertexSpace(vertexSize, vertexCount, buffer, startVertex);
}
uint16_t* makeIndexSpace(int indexCount, const GrIndexBuffer** buffer, int* startIndex) {
return this->state()->makeIndexSpace(indexCount, buffer, startIndex);
}
/** Helpers for batches which over-allocate and then return data to the pool. */
void putBackIndices(int indices) { this->state()->putBackIndices(indices); }
void putBackVertices(int vertices, size_t vertexStride) {
this->state()->putBackVertexSpace(vertices * vertexStride);
}
private:
GrVertexBatch* vertexBatch() { return static_cast<GrVertexBatch*>(this->batch()); }
typedef GrDrawBatch::Target INHERITED;
};
#endif