#include "GrBufferAllocPool.h"
#include "GrContext.h"
#include "GrPathUtils.h"
+#include "GrResourceProvider.h"
#include "GrTest.h"
#include "GrTestBatch.h"
#include "SkColorPriv.h"
}
void onGenerateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
- QuadHelper helper;
+ SkAutoTUnref<const GrIndexBuffer> indexBuffer(
+ batchTarget->resourceProvider()->refQuadIndexBuffer());
+
size_t vertexStride = this->geometryProcessor()->getVertexStride();
- SkASSERT(vertexStride == sizeof(Vertex));
- Vertex* verts = reinterpret_cast<Vertex*>(helper.init(batchTarget, vertexStride, 1));
- if (!verts) {
+ const GrVertexBuffer* vertexBuffer;
+ int firstVertex;
+ void* vertices = batchTarget->vertexPool()->makeSpace(vertexStride,
+ kVertsPerCubic,
+ &vertexBuffer,
+ &firstVertex);
+
+ if (!vertices || !indexBuffer) {
+ SkDebugf("Could not allocate buffers\n");
return;
}
+ SkASSERT(vertexStride == sizeof(Vertex));
+ Vertex* verts = reinterpret_cast<Vertex*>(vertices);
+
verts[0].fPosition.setRectFan(fGeometry.fBounds.fLeft, fGeometry.fBounds.fTop,
fGeometry.fBounds.fRight, fGeometry.fBounds.fBottom,
sizeof(Vertex));
verts[v].fKLM[1] = eval_line(verts[v].fPosition, fKlmEqs + 3, fSign);
verts[v].fKLM[2] = eval_line(verts[v].fPosition, fKlmEqs + 6, 1.f);
}
- helper.issueDraws(batchTarget);
+
+ GrDrawTarget::DrawInfo drawInfo;
+ drawInfo.setPrimitiveType(kTriangleFan_GrPrimitiveType);
+ drawInfo.setVertexBuffer(vertexBuffer);
+ drawInfo.setStartVertex(firstVertex);
+ drawInfo.setVertexCount(kVertsPerCubic);
+ drawInfo.setStartIndex(0);
+ drawInfo.setIndexCount(kIndicesPerCubic);
+ drawInfo.setIndexBuffer(indexBuffer);
+ batchTarget->draw(drawInfo);
}
Geometry fGeometry;
}
void onGenerateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
- QuadHelper helper;
+ SkAutoTUnref<const GrIndexBuffer> indexBuffer(
+ batchTarget->resourceProvider()->refQuadIndexBuffer());
+
size_t vertexStride = this->geometryProcessor()->getVertexStride();
- SkASSERT(vertexStride == sizeof(Vertex));
- GrDrawTarget::DrawInfo drawInfo;
- Vertex* verts = reinterpret_cast<Vertex*>(helper.init(batchTarget, vertexStride, 1));
- if (!verts) {
+ const GrVertexBuffer* vertexBuffer;
+ int firstVertex;
+
+ void* vertices = batchTarget->vertexPool()->makeSpace(vertexStride,
+ kVertsPerCubic,
+ &vertexBuffer,
+ &firstVertex);
+
+ if (!vertices || !indexBuffer) {
+ SkDebugf("Could not allocate buffers\n");
return;
}
+
+ SkASSERT(vertexStride == sizeof(Vertex));
+ Vertex* verts = reinterpret_cast<Vertex*>(vertices);
+
verts[0].fPosition.setRectFan(fGeometry.fBounds.fLeft, fGeometry.fBounds.fTop,
fGeometry.fBounds.fRight, fGeometry.fBounds.fBottom,
sizeof(Vertex));
+
fDevToUV.apply<4, sizeof(Vertex), sizeof(SkPoint)>(verts);
- helper.issueDraws(batchTarget);
+
+
+ GrDrawTarget::DrawInfo drawInfo;
+ drawInfo.setPrimitiveType(kTriangles_GrPrimitiveType);
+ drawInfo.setVertexBuffer(vertexBuffer);
+ drawInfo.setStartVertex(firstVertex);
+ drawInfo.setVertexCount(kVertsPerCubic);
+ drawInfo.setStartIndex(0);
+ drawInfo.setIndexCount(kIndicesPerCubic);
+ drawInfo.setIndexBuffer(indexBuffer);
+ batchTarget->draw(drawInfo);
}
Geometry fGeometry;
#include "GrContext.h"
#include "GrDefaultGeoProcFactory.h"
#include "GrPathUtils.h"
+#include "GrResourceProvider.h"
#include "GrTest.h"
#include "GrTestBatch.h"
#include "SkColorPriv.h"
}
void onGenerateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
+ SkAutoTUnref<const GrIndexBuffer> indexBuffer(
+ batchTarget->resourceProvider()->refQuadIndexBuffer());
+
size_t vertexStride = this->geometryProcessor()->getVertexStride();
- SkASSERT(vertexStride == sizeof(SkPoint));
- QuadHelper helper;
- SkPoint* verts = reinterpret_cast<SkPoint*>(helper.init(batchTarget, vertexStride, 1));
- if (!verts) {
+ const GrVertexBuffer* vertexBuffer;
+ int firstVertex;
+
+ void* vertices = batchTarget->vertexPool()->makeSpace(vertexStride,
+ kVertsPerCubic,
+ &vertexBuffer,
+ &firstVertex);
+
+ if (!vertices || !indexBuffer) {
+ SkDebugf("Could not allocate buffers\n");
return;
}
+ SkASSERT(vertexStride == sizeof(SkPoint));
+ SkPoint* verts = reinterpret_cast<SkPoint*>(vertices);
+
// Make sure any artifacts around the exterior of path are visible by using overly
// conservative bounding geometry.
fGeometry.fBounds.outset(5.f, 5.f);
fGeometry.fBounds.toQuad(verts);
- helper.issueDraws(batchTarget);
+ GrDrawTarget::DrawInfo drawInfo;
+ drawInfo.setPrimitiveType(kTriangleFan_GrPrimitiveType);
+ drawInfo.setVertexBuffer(vertexBuffer);
+ drawInfo.setStartVertex(firstVertex);
+ drawInfo.setVertexCount(kVertsPerCubic);
+ drawInfo.setStartIndex(0);
+ drawInfo.setIndexCount(kIndicesPerCubic);
+ drawInfo.setIndexBuffer(indexBuffer);
+ batchTarget->draw(drawInfo);
}
Geometry fGeometry;
+ static const int kVertsPerCubic = 4;
+ static const int kIndicesPerCubic = 6;
+
typedef GrTestBatch INHERITED;
};
create_vertices(segments, fanPt, &draws, verts, idxs);
GrDrawTarget::DrawInfo info;
+ info.setVertexBuffer(vertexBuffer);
+ info.setIndexBuffer(indexBuffer);
+ info.setPrimitiveType(kTriangles_GrPrimitiveType);
+ info.setStartIndex(firstIndex);
+ int vOffset = 0;
for (int i = 0; i < draws.count(); ++i) {
const Draw& draw = draws[i];
- info.initIndexed(kTriangles_GrPrimitiveType, vertexBuffer, indexBuffer, firstVertex,
- firstIndex, draw.fVertexCnt, draw.fIndexCnt);
+ info.setStartVertex(vOffset + firstVertex);
+ info.setVertexCount(draw.fVertexCnt);
+ info.setIndexCount(draw.fIndexCnt);
batchTarget->draw(info);
- firstVertex += draw.fVertexCnt;
- firstIndex += draw.fIndexCnt;
+ vOffset += draw.fVertexCnt;
}
}
}
#include "GrBufferAllocPool.h"
#include "GrContext.h"
#include "GrPipelineBuilder.h"
-#include "GrResourceProvider.h"
#include "GrSurfacePriv.h"
#include "GrSWMaskHelper.h"
+#include "GrResourceProvider.h"
#include "GrTexturePriv.h"
#include "GrVertexBuffer.h"
#include "effects/GrDistanceFieldGeoProc.h"
fBatch.fCoverageIgnored = init.fCoverageIgnored;
}
- struct FlushInfo {
- SkAutoTUnref<const GrVertexBuffer> fVertexBuffer;
- SkAutoTUnref<const GrIndexBuffer> fIndexBuffer;
- int fVertexOffset;
- int fInstancesToFlush;
- };
-
void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
int instanceCount = fGeoData.count();
this->initDraw(batchTarget, dfProcessor, pipeline);
- FlushInfo flushInfo;
+ static const int kVertsPerQuad = 4;
+ static const int kIndicesPerQuad = 6;
+
+ SkAutoTUnref<const GrIndexBuffer> indexBuffer(
+ batchTarget->resourceProvider()->refQuadIndexBuffer());
// allocate vertices
size_t vertexStride = dfProcessor->getVertexStride();
SkASSERT(vertexStride == 2 * sizeof(SkPoint));
-
const GrVertexBuffer* vertexBuffer;
+ int vertexCount = kVertsPerQuad * instanceCount;
+ int firstVertex;
+
void* vertices = batchTarget->vertexPool()->makeSpace(vertexStride,
- kVerticesPerQuad * instanceCount,
+ vertexCount,
&vertexBuffer,
- &flushInfo.fVertexOffset);
- flushInfo.fVertexBuffer.reset(SkRef(vertexBuffer));
- flushInfo.fIndexBuffer.reset(batchTarget->resourceProvider()->refQuadIndexBuffer());
- if (!vertices || !flushInfo.fIndexBuffer) {
+ &firstVertex);
+
+ if (!vertices || !indexBuffer) {
SkDebugf("Could not allocate vertices\n");
return;
}
- flushInfo.fInstancesToFlush = 0;
+ // We may have to flush while uploading path data to the atlas, so we set up the draw here
+ int maxInstancesPerDraw = indexBuffer->maxQuads();
+
+ GrDrawTarget::DrawInfo drawInfo;
+ drawInfo.setPrimitiveType(kTriangles_GrPrimitiveType);
+ drawInfo.setStartVertex(0);
+ drawInfo.setStartIndex(0);
+ drawInfo.setVerticesPerInstance(kVertsPerQuad);
+ drawInfo.setIndicesPerInstance(kIndicesPerQuad);
+ drawInfo.adjustStartVertex(firstVertex);
+ drawInfo.setVertexBuffer(vertexBuffer);
+ drawInfo.setIndexBuffer(indexBuffer);
+
+ int instancesToFlush = 0;
for (int i = 0; i < instanceCount; i++) {
Geometry& args = fGeoData[i];
if (!this->addPathToAtlas(batchTarget,
dfProcessor,
pipeline,
- &flushInfo,
+ &drawInfo,
+ &instancesToFlush,
+ maxInstancesPerDraw,
atlas,
args.fPathData,
args.fPath,
// Now set vertices
intptr_t offset = reinterpret_cast<intptr_t>(vertices);
- offset += i * kVerticesPerQuad * vertexStride;
+ offset += i * kVertsPerQuad * vertexStride;
SkPoint* positions = reinterpret_cast<SkPoint*>(offset);
- this->writePathVertices(batchTarget,
- atlas,
- pipeline,
- dfProcessor,
- positions,
- vertexStride,
- this->viewMatrix(),
- args.fPath,
- args.fPathData);
- flushInfo.fInstancesToFlush++;
+ this->drawPath(batchTarget,
+ atlas,
+ pipeline,
+ dfProcessor,
+ positions,
+ vertexStride,
+ this->viewMatrix(),
+ args.fPath,
+ args.fPathData);
+ instancesToFlush++;
}
- this->flush(batchTarget, &flushInfo);
+ this->flush(batchTarget, &drawInfo, instancesToFlush, maxInstancesPerDraw);
}
SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
bool addPathToAtlas(GrBatchTarget* batchTarget,
const GrGeometryProcessor* dfProcessor,
const GrPipeline* pipeline,
- FlushInfo* flushInfo,
+ GrDrawTarget::DrawInfo* drawInfo,
+ int* instancesToFlush,
+ int maxInstancesPerDraw,
GrBatchAtlas* atlas,
PathData* pathData,
const SkPath& path,
bool success = atlas->addToAtlas(&id, batchTarget, width, height, dfStorage.get(),
&atlasLocation);
if (!success) {
- this->flush(batchTarget, flushInfo);
+ this->flush(batchTarget, drawInfo, *instancesToFlush, maxInstancesPerDraw);
this->initDraw(batchTarget, dfProcessor, pipeline);
+ *instancesToFlush = 0;
SkDEBUGCODE(success =) atlas->addToAtlas(&id, batchTarget, width, height,
dfStorage.get(), &atlasLocation);
return true;
}
- void writePathVertices(GrBatchTarget* target,
- GrBatchAtlas* atlas,
- const GrPipeline* pipeline,
- const GrGeometryProcessor* gp,
- SkPoint* positions,
- size_t vertexStride,
- const SkMatrix& viewMatrix,
- const SkPath& path,
- const PathData* pathData) {
+ void drawPath(GrBatchTarget* target,
+ GrBatchAtlas* atlas,
+ const GrPipeline* pipeline,
+ const GrGeometryProcessor* gp,
+ SkPoint* positions,
+ size_t vertexStride,
+ const SkMatrix& viewMatrix,
+ const SkPath& path,
+ const PathData* pathData) {
GrTexture* texture = atlas->getTexture();
SkScalar dx = pathData->fBounds.fLeft;
dfProcessor->initBatchTracker(batchTarget->currentBatchTracker(), init);
}
- void flush(GrBatchTarget* batchTarget, FlushInfo* flushInfo) {
- GrDrawTarget::DrawInfo drawInfo;
- int instancesToFlush = flushInfo->fInstancesToFlush;
- int maxInstancesPerDraw = flushInfo->fIndexBuffer->maxQuads();
- drawInfo.initInstanced(kTriangles_GrPrimitiveType, flushInfo->fVertexBuffer,
- flushInfo->fIndexBuffer, flushInfo->fVertexOffset, kVerticesPerQuad,
- kIndicesPerQuad, &instancesToFlush, maxInstancesPerDraw);
- do {
- batchTarget->draw(drawInfo);
- } while (drawInfo.nextInstances(&instancesToFlush, maxInstancesPerDraw));
- flushInfo->fVertexOffset += kVerticesPerQuad * flushInfo->fInstancesToFlush;
- flushInfo->fInstancesToFlush = 0;
+ void flush(GrBatchTarget* batchTarget,
+ GrDrawTarget::DrawInfo* drawInfo,
+ int instanceCount,
+ int maxInstancesPerDraw) {
+ while (instanceCount) {
+ drawInfo->setInstanceCount(SkTMin(instanceCount, maxInstancesPerDraw));
+ drawInfo->setVertexCount(drawInfo->instanceCount() * drawInfo->verticesPerInstance());
+ drawInfo->setIndexCount(drawInfo->instanceCount() * drawInfo->indicesPerInstance());
+
+ batchTarget->draw(*drawInfo);
+
+ drawInfo->setStartVertex(drawInfo->startVertex() + drawInfo->vertexCount());
+ instanceCount -= drawInfo->instanceCount();
+ }
}
GrColor color() const { return fBatch.fColor; }
}
{
- int linesLeft = lineCount;
GrDrawTarget::DrawInfo info;
- info.initInstanced(kTriangles_GrPrimitiveType, vertexBuffer, linesIndexBuffer,
- firstVertex, kLineSegNumVertices, kIdxsPerLineSeg, &linesLeft,
- kLineSegsNumInIdxBuffer);
- do {
+ info.setVertexBuffer(vertexBuffer);
+ info.setIndexBuffer(linesIndexBuffer);
+ info.setPrimitiveType(kTriangles_GrPrimitiveType);
+ info.setStartIndex(0);
+
+ int lines = 0;
+ while (lines < lineCount) {
+ int n = SkTMin(lineCount - lines, kLineSegsNumInIdxBuffer);
+
+ info.setStartVertex(kLineSegNumVertices*lines + firstVertex);
+ info.setVertexCount(kLineSegNumVertices*n);
+ info.setIndexCount(kIdxsPerLineSeg*n);
batchTarget->draw(info);
- } while (info.nextInstances(&linesLeft, kLineSegsNumInIdxBuffer));
+
+ lines += n;
+ }
}
}
quadGP->initBatchTracker(batchTarget->currentBatchTracker(), init);
{
- int quadsLeft = quadCount;
- GrDrawTarget::DrawInfo info;
- info.initInstanced(kTriangles_GrPrimitiveType, vertexBuffer, quadsIndexBuffer,
- firstVertex, kQuadNumVertices, kIdxsPerQuad, &quadsLeft,
- kQuadsNumInIdxBuffer);
- do {
+ GrDrawTarget::DrawInfo info;
+ info.setVertexBuffer(vertexBuffer);
+ info.setIndexBuffer(quadsIndexBuffer);
+ info.setPrimitiveType(kTriangles_GrPrimitiveType);
+ info.setStartIndex(0);
+
+ int quads = 0;
+ while (quads < quadCount) {
+ int n = SkTMin(quadCount - quads, kQuadsNumInIdxBuffer);
+
+ info.setStartVertex(kQuadNumVertices*quads + firstVertex);
+ info.setVertexCount(kQuadNumVertices*n);
+ info.setIndexCount(kIdxsPerQuad*n);
batchTarget->draw(info);
- } while (info.nextInstances(&quadsLeft, kQuadsNumInIdxBuffer));
- firstVertex += quadCount * kQuadNumVertices;
+
+ quads += n;
+ }
}
}
conicGP->initBatchTracker(batchTarget->currentBatchTracker(), init);
{
- int conicsLeft = conicCount;
GrDrawTarget::DrawInfo info;
- info.initInstanced(kTriangles_GrPrimitiveType, vertexBuffer, quadsIndexBuffer,
- firstVertex, kQuadNumVertices, kIdxsPerQuad, &conicsLeft,
- kQuadsNumInIdxBuffer);
- do {
+ info.setVertexBuffer(vertexBuffer);
+ info.setIndexBuffer(quadsIndexBuffer);
+ info.setPrimitiveType(kTriangles_GrPrimitiveType);
+ info.setStartIndex(0);
+
+ int conics = 0;
+ while (conics < conicCount) {
+ int n = SkTMin(conicCount - conics, kQuadsNumInIdxBuffer);
+
+ info.setStartVertex(kQuadNumVertices*(quadCount + conics) + firstVertex);
+ info.setVertexCount(kQuadNumVertices*n);
+ info.setIndexCount(kIdxsPerQuad*n);
batchTarget->draw(info);
- } while (info.nextInstances(&conicsLeft, kQuadsNumInIdxBuffer));
+
+ conics += n;
+ }
}
}
}
init.fUsesLocalCoords = this->usesLocalCoords();
gp->initBatchTracker(batchTarget->currentBatchTracker(), init);
+ SkAutoTUnref<const GrIndexBuffer> indexBuffer(this->getIndexBuffer(
+ batchTarget->resourceProvider()));
+
size_t vertexStride = gp->getVertexStride();
SkASSERT(canTweakAlphaForCoverage ?
vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorAttr) :
vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr));
int instanceCount = fGeoData.count();
+ int vertexCount = kVertsPerAAFillRect * instanceCount;
+ const GrVertexBuffer* vertexBuffer;
+ int firstVertex;
+ void* vertices = batchTarget->vertexPool()->makeSpace(vertexStride,
+ vertexCount,
+ &vertexBuffer,
+ &firstVertex);
- SkAutoTUnref<const GrIndexBuffer> indexBuffer(this->getIndexBuffer(
- batchTarget->resourceProvider()));
- InstancedHelper helper;
- void* vertices = helper.init(batchTarget, vertexStride, indexBuffer, kVertsPerAAFillRect,
- kIndicesPerAAFillRect, instanceCount);
if (!vertices || !indexBuffer) {
SkDebugf("Could not allocate vertices\n");
return;
canTweakAlphaForCoverage);
}
- helper.issueDraws(batchTarget);
+ GrDrawTarget::DrawInfo drawInfo;
+ drawInfo.setPrimitiveType(kTriangles_GrPrimitiveType);
+ drawInfo.setStartVertex(0);
+ drawInfo.setStartIndex(0);
+ drawInfo.setVerticesPerInstance(kVertsPerAAFillRect);
+ drawInfo.setIndicesPerInstance(kIndicesPerAAFillRect);
+ drawInfo.adjustStartVertex(firstVertex);
+ drawInfo.setVertexBuffer(vertexBuffer);
+ drawInfo.setIndexBuffer(indexBuffer);
+
+ int maxInstancesPerDraw = kNumAAFillRectsInIndexBuffer;
+
+ while (instanceCount) {
+ drawInfo.setInstanceCount(SkTMin(instanceCount, maxInstancesPerDraw));
+ drawInfo.setVertexCount(drawInfo.instanceCount() * drawInfo.verticesPerInstance());
+ drawInfo.setIndexCount(drawInfo.instanceCount() * drawInfo.indicesPerInstance());
+
+ batchTarget->draw(drawInfo);
+
+ drawInfo.setStartVertex(drawInfo.startVertex() + drawInfo.vertexCount());
+ instanceCount -= drawInfo.instanceCount();
+ }
}
SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
batchTarget->initDraw(gp, pipeline);
+ const SkAutoTUnref<const GrIndexBuffer> indexBuffer(
+ GetIndexBuffer(batchTarget->resourceProvider(), this->miterStroke()));
+
// TODO this is hacky, but the only way we have to initialize the GP is to use the
// GrPipelineInfo struct so we can generate the correct shader. Once we have GrBatch
// everywhere we can remove this nastiness
vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr));
int innerVertexNum = 4;
int outerVertexNum = this->miterStroke() ? 4 : 8;
- int verticesPerInstance = (outerVertexNum + innerVertexNum) * 2;
- int indicesPerInstance = this->miterStroke() ? kMiterIndexCnt : kBevelIndexCnt;
+ int totalVertexNum = (outerVertexNum + innerVertexNum) * 2;
+
int instanceCount = fGeoData.count();
+ int vertexCount = totalVertexNum * instanceCount;
+
+ const GrVertexBuffer* vertexBuffer;
+ int firstVertex;
+
+ void* vertices = batchTarget->vertexPool()->makeSpace(vertexStride,
+ vertexCount,
+ &vertexBuffer,
+ &firstVertex);
- const SkAutoTUnref<const GrIndexBuffer> indexBuffer(
- GetIndexBuffer(batchTarget->resourceProvider(), this->miterStroke()));
- InstancedHelper helper;
- void* vertices = helper.init(batchTarget, vertexStride, indexBuffer, verticesPerInstance,
- indicesPerInstance, instanceCount);
if (!vertices || !indexBuffer) {
- SkDebugf("Could not allocate vertices\n");
- return;
- }
+ SkDebugf("Could not allocate vertices\n");
+ return;
+ }
for (int i = 0; i < instanceCount; i++) {
const Geometry& args = fGeoData[i];
this->generateAAStrokeRectGeometry(vertices,
- i * verticesPerInstance * vertexStride,
+ i * totalVertexNum * vertexStride,
vertexStride,
outerVertexNum,
innerVertexNum,
args.fMiterStroke,
canTweakAlphaForCoverage);
}
- helper.issueDraws(batchTarget);
+ int indicesPerInstance = this->miterStroke() ? kMiterIndexCnt : kBevelIndexCnt;
+ GrDrawTarget::DrawInfo drawInfo;
+ drawInfo.setPrimitiveType(kTriangles_GrPrimitiveType);
+ drawInfo.setStartVertex(0);
+ drawInfo.setStartIndex(0);
+ drawInfo.setVerticesPerInstance(totalVertexNum);
+ drawInfo.setIndicesPerInstance(indicesPerInstance);
+ drawInfo.adjustStartVertex(firstVertex);
+ drawInfo.setVertexBuffer(vertexBuffer);
+ drawInfo.setIndexBuffer(indexBuffer);
+
+ int maxInstancesPerDraw = this->miterStroke() ? kNumMiterRectsInIndexBuffer :
+ kNumBevelRectsInIndexBuffer;
+
+ while (instanceCount) {
+ drawInfo.setInstanceCount(SkTMin(instanceCount, maxInstancesPerDraw));
+ drawInfo.setVertexCount(drawInfo.instanceCount() * drawInfo.verticesPerInstance());
+ drawInfo.setIndexCount(drawInfo.instanceCount() * drawInfo.indicesPerInstance());
+
+ batchTarget->draw(drawInfo);
+
+ drawInfo.setStartVertex(drawInfo.startVertex() + drawInfo.vertexCount());
+ instanceCount -= drawInfo.instanceCount();
+ }
}
SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
fBatch.fCoverageIgnored = init.fCoverageIgnored;
}
- struct FlushInfo {
- SkAutoTUnref<const GrVertexBuffer> fVertexBuffer;
- SkAutoTUnref<const GrIndexBuffer> fIndexBuffer;
- int fGlyphsToFlush;
- int fVertexOffset;
- };
-
void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
// if we have RGB, then we won't have any SkShaders so no need to use a localmatrix.
// TODO actually only invert if we don't have RGBA
localMatrix));
}
- FlushInfo flushInfo;
- flushInfo.fGlyphsToFlush = 0;
size_t vertexStride = gp->getVertexStride();
SkASSERT(vertexStride == (fUseDistanceFields ?
get_vertex_stride_df(fMaskFormat, fUseLCDText) :
int glyphCount = this->numGlyphs();
int instanceCount = fInstanceCount;
- const GrVertexBuffer* vertexBuffer;
+ SkAutoTUnref<const GrIndexBuffer> indexBuffer(
+ batchTarget->resourceProvider()->refQuadIndexBuffer());
+ const GrVertexBuffer* vertexBuffer;
+ int firstVertex;
void* vertices = batchTarget->vertexPool()->makeSpace(vertexStride,
glyphCount * kVerticesPerGlyph,
&vertexBuffer,
- &flushInfo.fVertexOffset);
- flushInfo.fVertexBuffer.reset(SkRef(vertexBuffer));
- flushInfo.fIndexBuffer.reset(batchTarget->resourceProvider()->refQuadIndexBuffer());
- if (!vertices || !flushInfo.fVertexBuffer) {
+ &firstVertex);
+ if (!vertices || !indexBuffer) {
SkDebugf("Could not allocate vertices\n");
return;
}
unsigned char* currVertex = reinterpret_cast<unsigned char*>(vertices);
+ // setup drawinfo
+ int maxInstancesPerDraw = indexBuffer->maxQuads();
+
+ GrDrawTarget::DrawInfo drawInfo;
+ drawInfo.setPrimitiveType(kTriangles_GrPrimitiveType);
+ drawInfo.setStartVertex(0);
+ drawInfo.setStartIndex(0);
+ drawInfo.setVerticesPerInstance(kVerticesPerGlyph);
+ drawInfo.setIndicesPerInstance(kIndicesPerGlyph);
+ drawInfo.adjustStartVertex(firstVertex);
+ drawInfo.setVertexBuffer(vertexBuffer);
+ drawInfo.setIndexBuffer(indexBuffer);
+
// We cache some values to avoid going to the glyphcache for the same fontScaler twice
// in a row
const SkDescriptor* desc = NULL;
GrFontScaler* scaler = NULL;
SkTypeface* typeface = NULL;
+ int instancesToFlush = 0;
for (int i = 0; i < instanceCount; i++) {
Geometry& args = fGeoData[i];
Blob* blob = args.fBlob;
if (!fFontCache->hasGlyph(glyph) &&
!strike->addGlyphToAtlas(batchTarget, glyph, scaler)) {
- this->flush(batchTarget, &flushInfo);
+ this->flush(batchTarget, &drawInfo, instancesToFlush,
+ maxInstancesPerDraw);
this->initDraw(batchTarget, gp, pipeline);
+ instancesToFlush = 0;
brokenRun = glyphIdx > 0;
SkDEBUGCODE(bool success =) strike->addGlyphToAtlas(batchTarget,
SkScalar transY = args.fTransY;
this->regeneratePositions(vertex, vertexStride, transX, transY);
}
- flushInfo.fGlyphsToFlush++;
+ instancesToFlush++;
}
// We my have changed the color so update it here
fFontCache->atlasGeneration(fMaskFormat);
}
} else {
- flushInfo.fGlyphsToFlush += glyphCount;
+ instancesToFlush += glyphCount;
// set use tokens for all of the glyphs in our subrun. This is only valid if we
// have a valid atlas generation
if (cache) {
SkGlyphCache::AttachCache(cache);
}
- this->flush(batchTarget, &flushInfo);
+ this->flush(batchTarget, &drawInfo, instancesToFlush, maxInstancesPerDraw);
}
// The minimum number of Geometry we will try to allocate.
gp->initBatchTracker(batchTarget->currentBatchTracker(), init);
}
- void flush(GrBatchTarget* batchTarget, FlushInfo* flushInfo) {
- GrDrawTarget::DrawInfo drawInfo;
- int glyphsToFlush = flushInfo->fGlyphsToFlush;
- int maxGlyphsPerDraw = flushInfo->fIndexBuffer->maxQuads();
- drawInfo.initInstanced(kTriangles_GrPrimitiveType, flushInfo->fVertexBuffer,
- flushInfo->fIndexBuffer, flushInfo->fVertexOffset,
- kVerticesPerGlyph, kIndicesPerGlyph, &glyphsToFlush,
- maxGlyphsPerDraw);
- do {
- batchTarget->draw(drawInfo);
- } while (drawInfo.nextInstances(&glyphsToFlush, maxGlyphsPerDraw));
- flushInfo->fVertexOffset += kVerticesPerGlyph * flushInfo->fGlyphsToFlush;
- flushInfo->fGlyphsToFlush = 0;
+ void flush(GrBatchTarget* batchTarget,
+ GrDrawTarget::DrawInfo* drawInfo,
+ int instanceCount,
+ int maxInstancesPerDraw) {
+ while (instanceCount) {
+ drawInfo->setInstanceCount(SkTMin(instanceCount, maxInstancesPerDraw));
+ drawInfo->setVertexCount(drawInfo->instanceCount() * drawInfo->verticesPerInstance());
+ drawInfo->setIndexCount(drawInfo->instanceCount() * drawInfo->indicesPerInstance());
+
+ batchTarget->draw(*drawInfo);
+
+ drawInfo->setStartVertex(drawInfo->startVertex() + drawInfo->vertexCount());
+ instanceCount -= drawInfo->instanceCount();
+ }
}
GrColor color() const { return fBatch.fColor; }
*/
#include "GrBatch.h"
-#include "GrBatchTarget.h"
-#include "GrResourceProvider.h"
#include "GrMemoryPool.h"
#include "SkSpinlock.h"
void GrBatch::operator delete(void* target) {
return MemoryPoolAccessor().pool()->release(target);
}
-
-void* GrBatch::InstancedHelper::init(GrBatchTarget* batchTarget, size_t vertexStride,
- const GrIndexBuffer* indexBuffer, int verticesPerInstance,
- int indicesPerInstance, int instancesToDraw) {
- SkASSERT(!fInstancesRemaining);
- SkASSERT(batchTarget);
- if (!indexBuffer) {
- return NULL;
- }
- const GrVertexBuffer* vertexBuffer;
- int firstVertex;
- int vertexCount = verticesPerInstance * instancesToDraw;
- void* vertices = batchTarget->vertexPool()->makeSpace(vertexStride, vertexCount, &vertexBuffer,
- &firstVertex);
- if (!vertices) {
- SkDebugf("Vertices could not be allocated for instanced rendering.");
- return NULL;
- }
- SkASSERT(vertexBuffer);
- fInstancesRemaining = instancesToDraw;
-
- fDrawInfo.initInstanced(kTriangles_GrPrimitiveType, vertexBuffer, indexBuffer,
- firstVertex, verticesPerInstance, indicesPerInstance, &fInstancesRemaining,
- indexBuffer->maxQuads());
- size_t ibSize = fDrawInfo.indexBuffer()->gpuMemorySize();
- fMaxInstancesPerDraw = static_cast<int>(ibSize / (sizeof(uint16_t) * indicesPerInstance));
- SkASSERT(fMaxInstancesPerDraw > 0);
- return vertices;
-}
-
-void* GrBatch::QuadHelper::init(GrBatchTarget* batchTarget, size_t vertexStride, int quadsToDraw) {
- SkAutoTUnref<const GrIndexBuffer> quadIndexBuffer(
- batchTarget->resourceProvider()->refQuadIndexBuffer());
- if (!quadIndexBuffer) {
- SkDebugf("Could not get quad index buffer.");
- return NULL;
- }
- return this->INHERITED::init(batchTarget, vertexStride, quadIndexBuffer, kVerticesPerQuad,
- kIndicesPerQuad, quadsToDraw);
-}
#include <new>
// TODO remove this header when we move entirely to batch
#include "GrDrawTarget.h"
-#include "GrBatchTarget.h"
#include "GrGeometryProcessor.h"
#include "SkRefCnt.h"
#include "SkThread.h"
#include "SkTypes.h"
+class GrBatchTarget;
class GrGpu;
class GrIndexBufferAllocPool;
class GrPipeline;
return fBounds.joinPossiblyEmptyRect(otherBounds);
}
- /** Helper for rendering instances using an instanced index index buffer. This class creates the
- space for the vertices and flushes the draws to the batch target.*/
- class InstancedHelper {
- public:
- InstancedHelper() : fInstancesRemaining(0) {}
- /** Returns the allocated storage for the vertices. The caller should populate the before
- vertices before calling issueDraws(). */
- void* init(GrBatchTarget* batchTarget, size_t vertexStride,
- const GrIndexBuffer* indexBuffer, int verticesPerInstance,
- int indicesPerInstance, int instancesToDraw);
-
- /** Call after init() to issue draws to the batch target.*/
- void issueDraws(GrBatchTarget* batchTarget) {
- SkASSERT(fDrawInfo.instanceCount());
- do {
- batchTarget->draw(fDrawInfo);
- } while (fDrawInfo.nextInstances(&fInstancesRemaining, fMaxInstancesPerDraw));
- }
- private:
- int fInstancesRemaining;
- int fMaxInstancesPerDraw;
- GrDrawTarget::DrawInfo fDrawInfo;
- };
-
- static const int kVerticesPerQuad = 4;
- static const int kIndicesPerQuad = 6;
-
- /** A specialization of InstanceHelper for quad rendering. */
- class QuadHelper : private InstancedHelper {
- public:
- QuadHelper() : INHERITED() {}
- /** Finds the cached quad index buffer and reserves vertex space. Returns NULL on failure
- and on sucess a pointer to the vertex data that the caller should populate before
- calling issueDraws(). */
- void* init(GrBatchTarget* batchTarget, size_t vertexStride, int quadsToDraw);
-
- using InstancedHelper::issueDraws;
-
- private:
- typedef InstancedHelper INHERITED;
- };
-
SkRect fBounds;
private:
}
GrDrawTarget::DrawInfo drawInfo;
- drawInfo.init(primType, vertexBuffer, firstVertex, vertexCount);
+ drawInfo.setPrimitiveType(primType);
+ drawInfo.setVertexBuffer(vertexBuffer);
+ drawInfo.setStartVertex(firstVertex);
+ drawInfo.setVertexCount(vertexCount);
+ drawInfo.setStartIndex(0);
+ drawInfo.setIndexCount(0);
+ drawInfo.setInstanceCount(0);
+ drawInfo.setVerticesPerInstance(0);
+ drawInfo.setIndicesPerInstance(0);
batchTarget->draw(drawInfo);
}
return;
}
- const GrIndexBuffer* indexBuffer = NULL;
- int firstIndex = 0;
+ const GrIndexBuffer* indexBuffer;
+ int firstIndex;
void* indices = NULL;
if (this->hasIndices()) {
}
GrDrawTarget::DrawInfo drawInfo;
+ drawInfo.setPrimitiveType(this->primitiveType());
+ drawInfo.setVertexBuffer(vertexBuffer);
+ drawInfo.setStartVertex(firstVertex);
+ drawInfo.setVertexCount(this->vertexCount());
if (this->hasIndices()) {
- drawInfo.initIndexed(this->primitiveType(), vertexBuffer, indexBuffer, firstVertex,
- firstIndex, this->vertexCount(), this->indexCount());
-
+ drawInfo.setIndexBuffer(indexBuffer);
+ drawInfo.setStartIndex(firstIndex);
+ drawInfo.setIndexCount(this->indexCount());
} else {
- drawInfo.init(this->primitiveType(), vertexBuffer, firstVertex, this->vertexCount());
+ drawInfo.setStartIndex(0);
+ drawInfo.setIndexCount(0);
}
batchTarget->draw(drawInfo);
}
return;
}
- const GrIndexBuffer* indexBuffer = NULL;
- int firstIndex = 0;
+ const GrIndexBuffer* indexBuffer;
+ int firstIndex;
void* indices = NULL;
if (isIndexed) {
}
GrDrawTarget::DrawInfo drawInfo;
+ drawInfo.setPrimitiveType(primitiveType);
+ drawInfo.setVertexBuffer(vertexBuffer);
+ drawInfo.setStartVertex(firstVertex);
+ drawInfo.setVertexCount(vertexOffset);
if (isIndexed) {
- drawInfo.initIndexed(primitiveType, vertexBuffer, indexBuffer, firstVertex, firstIndex,
- vertexOffset, indexOffset);
+ drawInfo.setIndexBuffer(indexBuffer);
+ drawInfo.setStartIndex(firstIndex);
+ drawInfo.setIndexCount(indexOffset);
} else {
- drawInfo.init(primitiveType, vertexBuffer, firstVertex, vertexOffset);
+ drawInfo.setStartIndex(0);
+ drawInfo.setIndexCount(0);
}
batchTarget->draw(drawInfo);
fVerticesPerInstance = di.fVerticesPerInstance;
fIndicesPerInstance = di.fIndicesPerInstance;
- fVertexBuffer.reset(di.vertexBuffer());
- fIndexBuffer.reset(di.indexBuffer());
+ if (di.fDevBounds) {
+ SkASSERT(di.fDevBounds == &di.fDevBoundsStorage);
+ fDevBoundsStorage = di.fDevBoundsStorage;
+ fDevBounds = &fDevBoundsStorage;
+ } else {
+ fDevBounds = NULL;
+ }
+
+ this->setVertexBuffer(di.vertexBuffer());
+ this->setIndexBuffer(di.indexBuffer());
return *this;
}
virtual DrawToken getCurrentDrawToken() { return DrawToken(this, 0); }
/**
- * Used to communicate draw index vertex offsets and counts toto GPUs / subclasses
+ * Used to communicate draws to GPUs / subclasses
*/
class DrawInfo {
public:
- DrawInfo() {}
+ DrawInfo() { fDevBounds = NULL; }
DrawInfo(const DrawInfo& di) { (*this) = di; }
DrawInfo& operator =(const DrawInfo& di);
- void init(GrPrimitiveType primType, const GrVertexBuffer* vertexBuffer, int startVertex,
- int vertexCount) {
- SkASSERT(vertexBuffer);
- SkASSERT(vertexCount);
- SkASSERT(startVertex >= 0);
- fPrimitiveType = primType;
- fVertexBuffer.reset(SkRef(vertexBuffer));
- fIndexBuffer.reset(NULL);
- fStartVertex = startVertex;
- fStartIndex = 0;
- fVertexCount = vertexCount;
- fIndexCount = 0;
- fInstanceCount = 0;
- fVerticesPerInstance = 0;
- fIndicesPerInstance = 0;
- }
-
- void initIndexed(GrPrimitiveType primType,
- const GrVertexBuffer* vertexBuffer,
- const GrIndexBuffer* indexBuffer,
- int startVertex,
- int startIndex,
- int vertexCount,
- int indexCount) {
- SkASSERT(indexBuffer);
- SkASSERT(vertexBuffer);
- SkASSERT(indexCount);
- SkASSERT(vertexCount);
- SkASSERT(startIndex >= 0);
- SkASSERT(startVertex >= 0);
- fPrimitiveType = primType;
- fVertexBuffer.reset(SkRef(vertexBuffer));
- fIndexBuffer.reset(SkRef(indexBuffer));
- fStartVertex = startVertex;
- fStartIndex = startIndex;
- fVertexCount = vertexCount;
- fIndexCount = indexCount;
- fInstanceCount = 0;
- fVerticesPerInstance = 0;
- fIndicesPerInstance = 0;
- }
-
- void initInstanced(GrPrimitiveType primType,
- const GrVertexBuffer* vertexBuffer,
- const GrIndexBuffer* indexBuffer,
- int startVertex,
- int verticesPerInstance,
- int indicesPerInstance,
- int instanceCount) {
- SkASSERT(vertexBuffer);
- SkASSERT(indexBuffer);
- SkASSERT(instanceCount);
- SkASSERT(verticesPerInstance);
- SkASSERT(indicesPerInstance);
- SkASSERT(startVertex >= 0);
- fPrimitiveType = primType;
- fVertexBuffer.reset(SkRef(vertexBuffer));
- fIndexBuffer.reset(SkRef(indexBuffer));
- fStartVertex = startVertex;
- fStartIndex = 0;
- fVerticesPerInstance = verticesPerInstance;
- fIndicesPerInstance = indicesPerInstance;
- fInstanceCount = instanceCount;
- fVertexCount = instanceCount * fVerticesPerInstance;
- fIndexCount = instanceCount * fIndicesPerInstance;
- }
-
- /** Variation of the above that may be used when the total number of instances may exceed
- the number of instances supported by the index buffer. To be used with
- nextInstances() to draw in max-sized batches.*/
- void initInstanced(GrPrimitiveType primType,
- const GrVertexBuffer* vertexBuffer,
- const GrIndexBuffer* indexBuffer,
- int startVertex,
- int verticesPerInstance,
- int indicesPerInstance,
- int* instancesRemaining,
- int maxInstancesPerDraw) {
- int instanceCount = SkTMin(*instancesRemaining, maxInstancesPerDraw);
- *instancesRemaining -= instanceCount;
- this->initInstanced(primType, vertexBuffer, indexBuffer, startVertex,
- verticesPerInstance, indicesPerInstance, instanceCount);
- }
-
GrPrimitiveType primitiveType() const { return fPrimitiveType; }
int startVertex() const { return fStartVertex; }
int startIndex() const { return fStartIndex; }
int vertexCount() const { return fVertexCount; }
int indexCount() const { return fIndexCount; }
-
- /** These return 0 if initInstanced was not used to initialize the DrawInfo. */
int verticesPerInstance() const { return fVerticesPerInstance; }
int indicesPerInstance() const { return fIndicesPerInstance; }
int instanceCount() const { return fInstanceCount; }
+ void setPrimitiveType(GrPrimitiveType type) { fPrimitiveType = type; }
+ void setStartVertex(int startVertex) { fStartVertex = startVertex; }
+ void setStartIndex(int startIndex) { fStartIndex = startIndex; }
+ void setVertexCount(int vertexCount) { fVertexCount = vertexCount; }
+ void setIndexCount(int indexCount) { fIndexCount = indexCount; }
+ void setVerticesPerInstance(int verticesPerI) { fVerticesPerInstance = verticesPerI; }
+ void setIndicesPerInstance(int indicesPerI) { fIndicesPerInstance = indicesPerI; }
+ void setInstanceCount(int instanceCount) { fInstanceCount = instanceCount; }
+
bool isIndexed() const { return fIndexCount > 0; }
+#ifdef SK_DEBUG
+ bool isInstanced() const; // this version is longer because of asserts
+#else
bool isInstanced() const { return fInstanceCount > 0; }
+#endif
- /** Called after using this draw info to draw the next set of instances.
- The vertex offset is advanced while the index buffer is reused at the same
- position. instancesRemaining is number of instances that remain, maxInstances is
- the most number of instances that can be used with the index buffer. If there
- are no instances remaining, the DrawInfo is unmodified and false is returned.*/
- bool nextInstances(int* instancesRemaining, int maxInstances) {
- SkASSERT(this->isInstanced());
- if (!*instancesRemaining) {
- return false;
- }
- fStartVertex += fVertexCount;
- fInstanceCount = SkTMin(*instancesRemaining, maxInstances);
- fVertexCount = fInstanceCount * fVerticesPerInstance;
- fIndexCount = fInstanceCount * fIndicesPerInstance;
- *instancesRemaining -= fInstanceCount;
- return true;
+ // adds or remove instances
+ void adjustInstanceCount(int instanceOffset);
+ // shifts the start vertex
+ void adjustStartVertex(int vertexOffset) {
+ fStartVertex += vertexOffset;
+ SkASSERT(fStartVertex >= 0);
+ }
+ // shifts the start index
+ void adjustStartIndex(int indexOffset) {
+ SkASSERT(this->isIndexed());
+ fStartIndex += indexOffset;
+ SkASSERT(fStartIndex >= 0);
+ }
+ void setDevBounds(const SkRect& bounds) {
+ fDevBoundsStorage = bounds;
+ fDevBounds = &fDevBoundsStorage;
}
-
const GrVertexBuffer* vertexBuffer() const { return fVertexBuffer.get(); }
const GrIndexBuffer* indexBuffer() const { return fIndexBuffer.get(); }
+ void setVertexBuffer(const GrVertexBuffer* vb) {
+ fVertexBuffer.reset(vb);
+ }
+ void setIndexBuffer(const GrIndexBuffer* ib) {
+ fIndexBuffer.reset(ib);
+ }
+ const SkRect* getDevBounds() const { return fDevBounds; }
private:
friend class GrDrawTarget;
int fVerticesPerInstance;
int fIndicesPerInstance;
+ SkRect fDevBoundsStorage;
+ SkRect* fDevBounds;
+
GrPendingIOResource<const GrVertexBuffer, kRead_GrIOType> fVertexBuffer;
GrPendingIOResource<const GrIndexBuffer, kRead_GrIOType> fIndexBuffer;
};
#include "GrInOrderDrawBuffer.h"
#include "GrDefaultGeoProcFactory.h"
+#include "GrResourceProvider.h"
#include "GrTemplates.h"
GrInOrderDrawBuffer::GrInOrderDrawBuffer(GrContext* context,
init.fUsesLocalCoords = this->usesLocalCoords();
gp->initBatchTracker(batchTarget->currentBatchTracker(), init);
- int instanceCount = fGeoData.count();
size_t vertexStride = gp->getVertexStride();
+
SkASSERT(hasExplicitLocalCoords ?
vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordAttr) :
vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorAttr));
- QuadHelper helper;
- void* vertices = helper.init(batchTarget, vertexStride, instanceCount);
- if (!vertices) {
+ int instanceCount = fGeoData.count();
+ SkAutoTUnref<const GrIndexBuffer> indexBuffer(
+ batchTarget->resourceProvider()->refQuadIndexBuffer());
+
+ int vertexCount = kVertsPerRect * instanceCount;
+ const GrVertexBuffer* vertexBuffer;
+ int firstVertex;
+ void* vertices = batchTarget->vertexPool()->makeSpace(vertexStride,
+ vertexCount,
+ &vertexBuffer,
+ &firstVertex);
+
+ if (!vertices || !indexBuffer) {
+ SkDebugf("Could not allocate buffers\n");
return;
}
-
for (int i = 0; i < instanceCount; i++) {
- const Geometry& geom = fGeoData[i];
+ const Geometry& args = fGeoData[i];
- intptr_t offset = GrTCast<intptr_t>(vertices) + kVerticesPerQuad * i * vertexStride;
+ intptr_t offset = GrTCast<intptr_t>(vertices) + kVertsPerRect * i * vertexStride;
SkPoint* positions = GrTCast<SkPoint*>(offset);
- positions->setRectFan(geom.fRect.fLeft, geom.fRect.fTop,
- geom.fRect.fRight, geom.fRect.fBottom, vertexStride);
- geom.fViewMatrix.mapPointsWithStride(positions, vertexStride, kVerticesPerQuad);
+ positions->setRectFan(args.fRect.fLeft, args.fRect.fTop,
+ args.fRect.fRight, args.fRect.fBottom, vertexStride);
+ args.fViewMatrix.mapPointsWithStride(positions, vertexStride, kVertsPerRect);
- if (geom.fHasLocalRect) {
+ if (args.fHasLocalRect) {
static const int kLocalOffset = sizeof(SkPoint) + sizeof(GrColor);
SkPoint* coords = GrTCast<SkPoint*>(offset + kLocalOffset);
- coords->setRectFan(geom.fLocalRect.fLeft, geom.fLocalRect.fTop,
- geom.fLocalRect.fRight, geom.fLocalRect.fBottom,
+ coords->setRectFan(args.fLocalRect.fLeft, args.fLocalRect.fTop,
+ args.fLocalRect.fRight, args.fLocalRect.fBottom,
vertexStride);
- if (geom.fHasLocalMatrix) {
- geom.fLocalMatrix.mapPointsWithStride(coords, vertexStride, kVerticesPerQuad);
+ if (args.fHasLocalMatrix) {
+ args.fLocalMatrix.mapPointsWithStride(coords, vertexStride, kVertsPerRect);
}
}
static const int kColorOffset = sizeof(SkPoint);
GrColor* vertColor = GrTCast<GrColor*>(offset + kColorOffset);
for (int j = 0; j < 4; ++j) {
- *vertColor = geom.fColor;
+ *vertColor = args.fColor;
vertColor = (GrColor*) ((intptr_t) vertColor + vertexStride);
}
}
- helper.issueDraws(batchTarget);
+ GrDrawTarget::DrawInfo drawInfo;
+ drawInfo.setPrimitiveType(kTriangles_GrPrimitiveType);
+ drawInfo.setStartVertex(0);
+ drawInfo.setStartIndex(0);
+ drawInfo.setVerticesPerInstance(kVertsPerRect);
+ drawInfo.setIndicesPerInstance(kIndicesPerRect);
+ drawInfo.adjustStartVertex(firstVertex);
+ drawInfo.setVertexBuffer(vertexBuffer);
+ drawInfo.setIndexBuffer(indexBuffer);
+
+ int maxInstancesPerDraw = indexBuffer->maxQuads();
+ while (instanceCount) {
+ drawInfo.setInstanceCount(SkTMin(instanceCount, maxInstancesPerDraw));
+ drawInfo.setVertexCount(drawInfo.instanceCount() * drawInfo.verticesPerInstance());
+ drawInfo.setIndexCount(drawInfo.instanceCount() * drawInfo.indicesPerInstance());
+
+ batchTarget->draw(drawInfo);
+
+ drawInfo.setStartVertex(drawInfo.startVertex() + drawInfo.vertexCount());
+ instanceCount -= drawInfo.instanceCount();
+ }
}
SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
bool fCoverageIgnored;
};
+ const static int kVertsPerRect = 4;
+ const static int kIndicesPerRect = 6;
+
BatchTracker fBatch;
SkSTArray<1, Geometry, true> fGeoData;
};
gp->initBatchTracker(batchTarget->currentBatchTracker(), init);
int instanceCount = fGeoData.count();
+ int vertexCount = kVertsPerCircle * instanceCount;
size_t vertexStride = gp->getVertexStride();
SkASSERT(vertexStride == sizeof(CircleVertex));
- QuadHelper helper;
- CircleVertex* verts = reinterpret_cast<CircleVertex*>(helper.init(batchTarget, vertexStride,
- instanceCount));
- if (!verts) {
+
+ SkAutoTUnref<const GrIndexBuffer> indexBuffer(
+ batchTarget->resourceProvider()->refQuadIndexBuffer());
+ const GrVertexBuffer* vertexBuffer;
+ int firstVertex;
+
+ void *vertices = batchTarget->vertexPool()->makeSpace(vertexStride,
+ vertexCount,
+ &vertexBuffer,
+ &firstVertex);
+
+ if (!vertices || !indexBuffer) {
+ SkDebugf("Could not allocate buffers\n");
return;
}
+ CircleVertex* verts = reinterpret_cast<CircleVertex*>(vertices);
+
for (int i = 0; i < instanceCount; i++) {
- Geometry& geom = fGeoData[i];
+ Geometry& args = fGeoData[i];
- SkScalar innerRadius = geom.fInnerRadius;
- SkScalar outerRadius = geom.fOuterRadius;
+ SkScalar innerRadius = args.fInnerRadius;
+ SkScalar outerRadius = args.fOuterRadius;
- const SkRect& bounds = geom.fDevBounds;
+ const SkRect& bounds = args.fDevBounds;
// The inner radius in the vertex data must be specified in normalized space.
innerRadius = innerRadius / outerRadius;
verts[3].fOuterRadius = outerRadius;
verts[3].fInnerRadius = innerRadius;
- verts += kVerticesPerQuad;
+ verts += kVertsPerCircle;
+ }
+
+ GrDrawTarget::DrawInfo drawInfo;
+ drawInfo.setPrimitiveType(kTriangles_GrPrimitiveType);
+ drawInfo.setStartVertex(0);
+ drawInfo.setStartIndex(0);
+ drawInfo.setVerticesPerInstance(kVertsPerCircle);
+ drawInfo.setIndicesPerInstance(kIndicesPerCircle);
+ drawInfo.adjustStartVertex(firstVertex);
+ drawInfo.setVertexBuffer(vertexBuffer);
+ drawInfo.setIndexBuffer(indexBuffer);
+
+ int maxInstancesPerDraw = indexBuffer->maxQuads();
+
+ while (instanceCount) {
+ drawInfo.setInstanceCount(SkTMin(instanceCount, maxInstancesPerDraw));
+ drawInfo.setVertexCount(drawInfo.instanceCount() * drawInfo.verticesPerInstance());
+ drawInfo.setIndexCount(drawInfo.instanceCount() * drawInfo.indicesPerInstance());
+
+ batchTarget->draw(drawInfo);
+
+ drawInfo.setStartVertex(drawInfo.startVertex() + drawInfo.vertexCount());
+ instanceCount -= drawInfo.instanceCount();
}
- helper.issueDraws(batchTarget);
}
SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
bool fCoverageIgnored;
};
+ static const int kVertsPerCircle = 4;
+ static const int kIndicesPerCircle = 6;
+
BatchTracker fBatch;
SkSTArray<1, Geometry, true> fGeoData;
};
gp->initBatchTracker(batchTarget->currentBatchTracker(), init);
int instanceCount = fGeoData.count();
- QuadHelper helper;
+ int vertexCount = kVertsPerEllipse * instanceCount;
size_t vertexStride = gp->getVertexStride();
SkASSERT(vertexStride == sizeof(EllipseVertex));
- EllipseVertex* verts = reinterpret_cast<EllipseVertex*>(
- helper.init(batchTarget, vertexStride, instanceCount));
- if (!verts) {
+
+ const GrVertexBuffer* vertexBuffer;
+ SkAutoTUnref<const GrIndexBuffer> indexBuffer(
+ batchTarget->resourceProvider()->refQuadIndexBuffer());
+ int firstVertex;
+
+ void *vertices = batchTarget->vertexPool()->makeSpace(vertexStride,
+ vertexCount,
+ &vertexBuffer,
+ &firstVertex);
+
+ if (!vertices || !indexBuffer) {
+ SkDebugf("Could not allocate buffers\n");
return;
}
+ EllipseVertex* verts = reinterpret_cast<EllipseVertex*>(vertices);
+
for (int i = 0; i < instanceCount; i++) {
- Geometry& geom = fGeoData[i];
+ Geometry& args = fGeoData[i];
- SkScalar xRadius = geom.fXRadius;
- SkScalar yRadius = geom.fYRadius;
+ SkScalar xRadius = args.fXRadius;
+ SkScalar yRadius = args.fYRadius;
// Compute the reciprocals of the radii here to save time in the shader
SkScalar xRadRecip = SkScalarInvert(xRadius);
SkScalar yRadRecip = SkScalarInvert(yRadius);
- SkScalar xInnerRadRecip = SkScalarInvert(geom.fInnerXRadius);
- SkScalar yInnerRadRecip = SkScalarInvert(geom.fInnerYRadius);
+ SkScalar xInnerRadRecip = SkScalarInvert(args.fInnerXRadius);
+ SkScalar yInnerRadRecip = SkScalarInvert(args.fInnerYRadius);
- const SkRect& bounds = geom.fDevBounds;
+ const SkRect& bounds = args.fDevBounds;
// The inner radius in the vertex data must be specified in normalized space.
verts[0].fPos = SkPoint::Make(bounds.fLeft, bounds.fTop);
verts[3].fOuterRadii = SkPoint::Make(xRadRecip, yRadRecip);
verts[3].fInnerRadii = SkPoint::Make(xInnerRadRecip, yInnerRadRecip);
- verts += kVerticesPerQuad;
+ verts += kVertsPerEllipse;
+ }
+
+ GrDrawTarget::DrawInfo drawInfo;
+ drawInfo.setPrimitiveType(kTriangles_GrPrimitiveType);
+ drawInfo.setStartVertex(0);
+ drawInfo.setStartIndex(0);
+ drawInfo.setVerticesPerInstance(kVertsPerEllipse);
+ drawInfo.setIndicesPerInstance(kIndicesPerEllipse);
+ drawInfo.adjustStartVertex(firstVertex);
+ drawInfo.setVertexBuffer(vertexBuffer);
+ drawInfo.setIndexBuffer(indexBuffer);
+
+ int maxInstancesPerDraw = indexBuffer->maxQuads();
+
+ while (instanceCount) {
+ drawInfo.setInstanceCount(SkTMin(instanceCount, maxInstancesPerDraw));
+ drawInfo.setVertexCount(drawInfo.instanceCount() * drawInfo.verticesPerInstance());
+ drawInfo.setIndexCount(drawInfo.instanceCount() * drawInfo.indicesPerInstance());
+
+ batchTarget->draw(drawInfo);
+
+ drawInfo.setStartVertex(drawInfo.startVertex() + drawInfo.vertexCount());
+ instanceCount -= drawInfo.instanceCount();
}
- helper.issueDraws(batchTarget);
}
SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
bool fCoverageIgnored;
};
+ static const int kVertsPerEllipse = 4;
+ static const int kIndicesPerEllipse = 6;
+
BatchTracker fBatch;
SkSTArray<1, Geometry, true> fGeoData;
};
init.fUsesLocalCoords = this->usesLocalCoords();
gp->initBatchTracker(batchTarget->currentBatchTracker(), init);
+ SkAutoTUnref<const GrIndexBuffer> indexBuffer(
+ batchTarget->resourceProvider()->refQuadIndexBuffer());
+
int instanceCount = fGeoData.count();
+ int vertexCount = kVertsPerEllipse * instanceCount;
size_t vertexStride = gp->getVertexStride();
SkASSERT(vertexStride == sizeof(DIEllipseVertex));
- QuadHelper helper;
- DIEllipseVertex* verts = reinterpret_cast<DIEllipseVertex*>(
- helper.init(batchTarget, vertexStride, instanceCount));
- if (!verts) {
+ const GrVertexBuffer* vertexBuffer;
+ int firstVertex;
+ void *vertices = batchTarget->vertexPool()->makeSpace(vertexStride,
+ vertexCount,
+ &vertexBuffer,
+ &firstVertex);
+
+ if (!vertices || !indexBuffer) {
+ SkDebugf("Could not allocate buffers\n");
return;
}
+ DIEllipseVertex* verts = reinterpret_cast<DIEllipseVertex*>(vertices);
+
for (int i = 0; i < instanceCount; i++) {
- Geometry& geom = fGeoData[i];
+ Geometry& args = fGeoData[i];
- SkScalar xRadius = geom.fXRadius;
- SkScalar yRadius = geom.fYRadius;
+ SkScalar xRadius = args.fXRadius;
+ SkScalar yRadius = args.fYRadius;
- const SkRect& bounds = geom.fBounds;
+ const SkRect& bounds = args.fBounds;
// This adjusts the "radius" to include the half-pixel border
- SkScalar offsetDx = SkScalarDiv(geom.fGeoDx, xRadius);
- SkScalar offsetDy = SkScalarDiv(geom.fGeoDy, yRadius);
+ SkScalar offsetDx = SkScalarDiv(args.fGeoDx, xRadius);
+ SkScalar offsetDy = SkScalarDiv(args.fGeoDy, yRadius);
- SkScalar innerRatioX = SkScalarDiv(xRadius, geom.fInnerXRadius);
- SkScalar innerRatioY = SkScalarDiv(yRadius, geom.fInnerYRadius);
+ SkScalar innerRatioX = SkScalarDiv(xRadius, args.fInnerXRadius);
+ SkScalar innerRatioY = SkScalarDiv(yRadius, args.fInnerYRadius);
verts[0].fPos = SkPoint::Make(bounds.fLeft, bounds.fTop);
verts[0].fOuterOffset = SkPoint::Make(-1.0f - offsetDx, -1.0f - offsetDy);
verts[3].fOuterOffset = SkPoint::Make(1.0f + offsetDx, -1.0f - offsetDy);
verts[3].fInnerOffset = SkPoint::Make(innerRatioX + offsetDx, -innerRatioY - offsetDy);
- verts += kVerticesPerQuad;
+ verts += kVertsPerEllipse;
+ }
+
+ GrDrawTarget::DrawInfo drawInfo;
+ drawInfo.setPrimitiveType(kTriangles_GrPrimitiveType);
+ drawInfo.setStartVertex(0);
+ drawInfo.setStartIndex(0);
+ drawInfo.setVerticesPerInstance(kVertsPerEllipse);
+ drawInfo.setIndicesPerInstance(kIndicesPerEllipse);
+ drawInfo.adjustStartVertex(firstVertex);
+ drawInfo.setVertexBuffer(vertexBuffer);
+ drawInfo.setIndexBuffer(indexBuffer);
+
+ int maxInstancesPerDraw = indexBuffer->maxQuads();
+
+ while (instanceCount) {
+ drawInfo.setInstanceCount(SkTMin(instanceCount, maxInstancesPerDraw));
+ drawInfo.setVertexCount(drawInfo.instanceCount() * drawInfo.verticesPerInstance());
+ drawInfo.setIndexCount(drawInfo.instanceCount() * drawInfo.indicesPerInstance());
+
+ batchTarget->draw(drawInfo);
+
+ drawInfo.setStartVertex(drawInfo.startVertex() + drawInfo.vertexCount());
+ instanceCount -= drawInfo.instanceCount();
}
- helper.issueDraws(batchTarget);
}
SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
bool fCoverageIgnored;
};
+ static const int kVertsPerEllipse = 4;
+ static const int kIndicesPerEllipse = 6;
+
BatchTracker fBatch;
SkSTArray<1, Geometry, true> fGeoData;
};
gp->initBatchTracker(batchTarget->currentBatchTracker(), init);
int instanceCount = fGeoData.count();
+ int vertexCount = kVertsPerRRect * instanceCount;
size_t vertexStride = gp->getVertexStride();
SkASSERT(vertexStride == sizeof(CircleVertex));
- // drop out the middle quad if we're stroked
- int indicesPerInstance = this->stroke() ? kIndicesPerStrokeRRect : kIndicesPerRRect;
+ const GrVertexBuffer* vertexBuffer;
SkAutoTUnref<const GrIndexBuffer> indexBuffer(
ref_rrect_index_buffer(this->stroke(), batchTarget->resourceProvider()));
+ int firstVertex;
+
+ void *vertices = batchTarget->vertexPool()->makeSpace(vertexStride,
+ vertexCount,
+ &vertexBuffer,
+ &firstVertex);
- InstancedHelper helper;
- CircleVertex* verts = reinterpret_cast<CircleVertex*>(helper.init(batchTarget,
- vertexStride, indexBuffer, kVertsPerRRect, indicesPerInstance, instanceCount));
- if (!verts || !indexBuffer) {
+ if (!vertices || !indexBuffer) {
SkDebugf("Could not allocate vertices\n");
return;
}
+ CircleVertex* verts = reinterpret_cast<CircleVertex*>(vertices);
+
for (int i = 0; i < instanceCount; i++) {
Geometry& args = fGeoData[i];
}
}
- helper.issueDraws(batchTarget);
+ // drop out the middle quad if we're stroked
+ int indexCnt = this->stroke() ? SK_ARRAY_COUNT(gRRectIndices) - 6 :
+ SK_ARRAY_COUNT(gRRectIndices);
+
+ GrDrawTarget::DrawInfo drawInfo;
+ drawInfo.setPrimitiveType(kTriangles_GrPrimitiveType);
+ drawInfo.setStartVertex(0);
+ drawInfo.setStartIndex(0);
+ drawInfo.setVerticesPerInstance(kVertsPerRRect);
+ drawInfo.setIndicesPerInstance(indexCnt);
+ drawInfo.adjustStartVertex(firstVertex);
+ drawInfo.setVertexBuffer(vertexBuffer);
+ drawInfo.setIndexBuffer(indexBuffer);
+
+ int maxInstancesPerDraw = kNumRRectsInIndexBuffer;
+
+ while (instanceCount) {
+ drawInfo.setInstanceCount(SkTMin(instanceCount, maxInstancesPerDraw));
+ drawInfo.setVertexCount(drawInfo.instanceCount() * drawInfo.verticesPerInstance());
+ drawInfo.setIndexCount(drawInfo.instanceCount() * drawInfo.indicesPerInstance());
+
+ batchTarget->draw(drawInfo);
+
+ drawInfo.setStartVertex(drawInfo.startVertex() + drawInfo.vertexCount());
+ instanceCount -= drawInfo.instanceCount();
+ }
}
SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
gp->initBatchTracker(batchTarget->currentBatchTracker(), init);
int instanceCount = fGeoData.count();
+ int vertexCount = kVertsPerRRect * instanceCount;
size_t vertexStride = gp->getVertexStride();
SkASSERT(vertexStride == sizeof(EllipseVertex));
- // drop out the middle quad if we're stroked
- int indicesPerInstance = this->stroke() ? kIndicesPerStrokeRRect : kIndicesPerRRect;
+ const GrVertexBuffer* vertexBuffer;
SkAutoTUnref<const GrIndexBuffer> indexBuffer(
ref_rrect_index_buffer(this->stroke(), batchTarget->resourceProvider()));
+ int firstVertex;
+
+ void *vertices = batchTarget->vertexPool()->makeSpace(vertexStride,
+ vertexCount,
+ &vertexBuffer,
+ &firstVertex);
- InstancedHelper helper;
- EllipseVertex* verts = reinterpret_cast<EllipseVertex*>(
- helper.init(batchTarget, vertexStride, indexBuffer, kVertsPerRRect, indicesPerInstance,
- instanceCount));
- if (!verts || !indexBuffer) {
+ if (!vertices || !indexBuffer) {
SkDebugf("Could not allocate vertices\n");
return;
}
+ EllipseVertex* verts = reinterpret_cast<EllipseVertex*>(vertices);
+
for (int i = 0; i < instanceCount; i++) {
Geometry& args = fGeoData[i];
verts++;
}
}
- helper.issueDraws(batchTarget);
+
+ // drop out the middle quad if we're stroked
+ int indexCnt = this->stroke() ? SK_ARRAY_COUNT(gRRectIndices) - 6 :
+ SK_ARRAY_COUNT(gRRectIndices);
+
+ GrDrawTarget::DrawInfo drawInfo;
+ drawInfo.setPrimitiveType(kTriangles_GrPrimitiveType);
+ drawInfo.setStartVertex(0);
+ drawInfo.setStartIndex(0);
+ drawInfo.setVerticesPerInstance(kVertsPerRRect);
+ drawInfo.setIndicesPerInstance(indexCnt);
+ drawInfo.adjustStartVertex(firstVertex);
+ drawInfo.setVertexBuffer(vertexBuffer);
+ drawInfo.setIndexBuffer(indexBuffer);
+
+ int maxInstancesPerDraw = kNumRRectsInIndexBuffer;
+
+ while (instanceCount) {
+ drawInfo.setInstanceCount(SkTMin(instanceCount, maxInstancesPerDraw));
+ drawInfo.setVertexCount(drawInfo.instanceCount() * drawInfo.verticesPerInstance());
+ drawInfo.setIndexCount(drawInfo.instanceCount() * drawInfo.indicesPerInstance());
+
+ batchTarget->draw(drawInfo);
+
+ drawInfo.setStartVertex(drawInfo.startVertex() + drawInfo.vertexCount());
+ instanceCount -= drawInfo.instanceCount();
+ }
}
SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
GrPrimitiveType primitiveType = WIREFRAME ? kLines_GrPrimitiveType
: kTriangles_GrPrimitiveType;
GrDrawTarget::DrawInfo drawInfo;
- drawInfo.init(primitiveType, vertexBuffer, firstVertex, actualCount);
+ drawInfo.setPrimitiveType(primitiveType);
+ drawInfo.setVertexBuffer(vertexBuffer);
+ drawInfo.setStartVertex(firstVertex);
+ drawInfo.setVertexCount(actualCount);
+ drawInfo.setStartIndex(0);
+ drawInfo.setIndexCount(0);
batchTarget->draw(drawInfo);
batchTarget->putBackVertices((size_t)(count - actualCount), stride);
#include "GrDrawTargetCaps.h"
#include "GrInvariantOutput.h"
#include "GrProcessor.h"
+#include "GrResourceProvider.h"
#include "GrStrokeInfo.h"
#include "GrVertexBuffer.h"
#include "SkGr.h"
draw.fHasEndRect = hasEndRect;
}
- QuadHelper helper;
- void* vertices = helper.init(batchTarget, gp->getVertexStride(), instanceCount);
- if (!vertices) {
+ SkAutoTUnref<const GrIndexBuffer> indexBuffer(
+ batchTarget->resourceProvider()->refQuadIndexBuffer());
+
+ const GrVertexBuffer* vertexBuffer;
+ int firstVertex;
+ size_t vertexStride = gp->getVertexStride();
+ void* vertices = batchTarget->vertexPool()->makeSpace(vertexStride,
+ totalRectCount * kVertsPerDash,
+ &vertexBuffer,
+ &firstVertex);
+ if (!vertices || !indexBuffer) {
+ SkDebugf("Could not allocate buffers\n");
return;
}
int curVIdx = 0;
int rectIndex = 0;
for (int i = 0; i < instanceCount; i++) {
- Geometry& geom = fGeoData[i];
+ Geometry& args = fGeoData[i];
if (!draws[i].fLineDone) {
if (fullDash) {
- setup_dashed_rect(rects[rectIndex], vertices, curVIdx, geom.fSrcRotInv,
+ setup_dashed_rect(rects[rectIndex], vertices, curVIdx, args.fSrcRotInv,
draws[i].fStartOffset, draws[i].fDevBloatX,
draws[i].fDevBloatY, draws[i].fLineLength,
- draws[i].fHalfDevStroke, geom.fIntervals[0],
- geom.fIntervals[1], draws[i].fStrokeWidth,
+ draws[i].fHalfDevStroke, args.fIntervals[0],
+ args.fIntervals[1], draws[i].fStrokeWidth,
capType, gp->getVertexStride());
} else {
SkPoint* verts = reinterpret_cast<SkPoint*>(vertices);
SkASSERT(gp->getVertexStride() == sizeof(SkPoint));
- setup_dashed_rect_pos(rects[rectIndex], curVIdx, geom.fSrcRotInv, verts);
+ setup_dashed_rect_pos(rects[rectIndex], curVIdx, args.fSrcRotInv, verts);
}
curVIdx += 4;
}
if (draws[i].fHasStartRect) {
if (fullDash) {
- setup_dashed_rect(rects[rectIndex], vertices, curVIdx, geom.fSrcRotInv,
+ setup_dashed_rect(rects[rectIndex], vertices, curVIdx, args.fSrcRotInv,
draws[i].fStartOffset, draws[i].fDevBloatX,
- draws[i].fDevBloatY, geom.fIntervals[0],
- draws[i].fHalfDevStroke, geom.fIntervals[0],
- geom.fIntervals[1], draws[i].fStrokeWidth, capType,
+ draws[i].fDevBloatY, args.fIntervals[0],
+ draws[i].fHalfDevStroke, args.fIntervals[0],
+ args.fIntervals[1], draws[i].fStrokeWidth, capType,
gp->getVertexStride());
} else {
SkPoint* verts = reinterpret_cast<SkPoint*>(vertices);
SkASSERT(gp->getVertexStride() == sizeof(SkPoint));
- setup_dashed_rect_pos(rects[rectIndex], curVIdx, geom.fSrcRotInv, verts);
+ setup_dashed_rect_pos(rects[rectIndex], curVIdx, args.fSrcRotInv, verts);
}
curVIdx += 4;
if (draws[i].fHasEndRect) {
if (fullDash) {
- setup_dashed_rect(rects[rectIndex], vertices, curVIdx, geom.fSrcRotInv,
+ setup_dashed_rect(rects[rectIndex], vertices, curVIdx, args.fSrcRotInv,
draws[i].fStartOffset, draws[i].fDevBloatX,
- draws[i].fDevBloatY, geom.fIntervals[0],
- draws[i].fHalfDevStroke, geom.fIntervals[0],
- geom.fIntervals[1], draws[i].fStrokeWidth, capType,
+ draws[i].fDevBloatY, args.fIntervals[0],
+ draws[i].fHalfDevStroke, args.fIntervals[0],
+ args.fIntervals[1], draws[i].fStrokeWidth, capType,
gp->getVertexStride());
} else {
SkPoint* verts = reinterpret_cast<SkPoint*>(vertices);
SkASSERT(gp->getVertexStride() == sizeof(SkPoint));
- setup_dashed_rect_pos(rects[rectIndex], curVIdx, geom.fSrcRotInv, verts);
+ setup_dashed_rect_pos(rects[rectIndex], curVIdx, args.fSrcRotInv, verts);
}
curVIdx += 4;
}
rectIndex++;
}
- helper.issueDraws(batchTarget);
+
+ GrDrawTarget::DrawInfo drawInfo;
+ drawInfo.setPrimitiveType(kTriangles_GrPrimitiveType);
+ drawInfo.setStartVertex(0);
+ drawInfo.setStartIndex(0);
+ drawInfo.setVerticesPerInstance(kVertsPerDash);
+ drawInfo.setIndicesPerInstance(kIndicesPerDash);
+ drawInfo.adjustStartVertex(firstVertex);
+ drawInfo.setVertexBuffer(vertexBuffer);
+ drawInfo.setIndexBuffer(indexBuffer);
+
+ int maxInstancesPerDraw = indexBuffer->maxQuads();
+ while (totalRectCount) {
+ drawInfo.setInstanceCount(SkTMin(totalRectCount, maxInstancesPerDraw));
+ drawInfo.setVertexCount(drawInfo.instanceCount() * drawInfo.verticesPerInstance());
+ drawInfo.setIndexCount(drawInfo.instanceCount() * drawInfo.indicesPerInstance());
+
+ batchTarget->draw(drawInfo);
+
+ drawInfo.setStartVertex(drawInfo.startVertex() + drawInfo.vertexCount());
+ totalRectCount -= drawInfo.instanceCount();
+ }
}
SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
projects / platform / upstream / libSkiaSharp.git / commitdiff