Index: src/gpu/GrDrawContext.cpp |
diff --git a/src/gpu/GrDrawContext.cpp b/src/gpu/GrDrawContext.cpp |
index 5d77f853d140d46c8b55f735fdd6d7d1089ba991..c67f6f48bff07d0057921eccf9dfbe51e6781253 100644 |
--- a/src/gpu/GrDrawContext.cpp |
+++ b/src/gpu/GrDrawContext.cpp |
@@ -10,7 +10,6 @@ |
#include "GrAtlasTextContext.h" |
#include "GrBatchTest.h" |
#include "GrColor.h" |
-#include "GrDefaultGeoProcFactory.h" |
#include "GrDrawContext.h" |
#include "GrOvalRenderer.h" |
#include "GrPathRenderer.h" |
@@ -20,6 +19,7 @@ |
#include "batches/GrBatch.h" |
#include "batches/GrDrawAtlasBatch.h" |
+#include "batches/GrDrawVerticesBatch.h" |
#include "batches/GrStrokeRectBatch.h" |
#include "SkGr.h" |
@@ -373,283 +373,6 @@ void GrDrawContext::drawNonAARectToRect(GrRenderTarget* rt, |
localMatrix); |
} |
-static const GrGeometryProcessor* set_vertex_attributes(bool hasLocalCoords, |
- bool hasColors, |
- int* colorOffset, |
- int* texOffset, |
- GrColor color, |
- const SkMatrix& viewMatrix, |
- bool coverageIgnored) { |
- using namespace GrDefaultGeoProcFactory; |
- *texOffset = -1; |
- *colorOffset = -1; |
- Color gpColor(color); |
- if (hasColors) { |
- gpColor.fType = Color::kAttribute_Type; |
- } |
- |
- Coverage coverage(coverageIgnored ? Coverage::kNone_Type : Coverage::kSolid_Type); |
- LocalCoords localCoords(hasLocalCoords ? LocalCoords::kHasExplicit_Type : |
- LocalCoords::kUsePosition_Type); |
- if (hasLocalCoords && hasColors) { |
- *colorOffset = sizeof(SkPoint); |
- *texOffset = sizeof(SkPoint) + sizeof(GrColor); |
- } else if (hasLocalCoords) { |
- *texOffset = sizeof(SkPoint); |
- } else if (hasColors) { |
- *colorOffset = sizeof(SkPoint); |
- } |
- return GrDefaultGeoProcFactory::Create(gpColor, coverage, localCoords, viewMatrix); |
-} |
- |
-class DrawVerticesBatch : public GrBatch { |
-public: |
- struct Geometry { |
- GrColor fColor; |
- SkTDArray<SkPoint> fPositions; |
- SkTDArray<uint16_t> fIndices; |
- SkTDArray<GrColor> fColors; |
- SkTDArray<SkPoint> fLocalCoords; |
- }; |
- |
- static GrBatch* Create(const Geometry& geometry, GrPrimitiveType primitiveType, |
- const SkMatrix& viewMatrix, |
- const SkPoint* positions, int vertexCount, |
- const uint16_t* indices, int indexCount, |
- const GrColor* colors, const SkPoint* localCoords, |
- const SkRect& bounds) { |
- return SkNEW_ARGS(DrawVerticesBatch, (geometry, primitiveType, viewMatrix, positions, |
- vertexCount, indices, indexCount, colors, |
- localCoords, bounds)); |
- } |
- |
- const char* name() const override { return "DrawVerticesBatch"; } |
- |
- void getInvariantOutputColor(GrInitInvariantOutput* out) const override { |
- // When this is called on a batch, there is only one geometry bundle |
- if (this->hasColors()) { |
- out->setUnknownFourComponents(); |
- } else { |
- out->setKnownFourComponents(fGeoData[0].fColor); |
- } |
- } |
- |
- void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override { |
- out->setKnownSingleComponent(0xff); |
- } |
- |
- void initBatchTracker(const GrPipelineInfo& init) override { |
- // Handle any color overrides |
- if (!init.readsColor()) { |
- fGeoData[0].fColor = GrColor_ILLEGAL; |
- } |
- init.getOverrideColorIfSet(&fGeoData[0].fColor); |
- |
- // setup batch properties |
- fBatch.fColorIgnored = !init.readsColor(); |
- fBatch.fColor = fGeoData[0].fColor; |
- fBatch.fUsesLocalCoords = init.readsLocalCoords(); |
- fBatch.fCoverageIgnored = !init.readsCoverage(); |
- } |
- |
- void generateGeometry(GrBatchTarget* batchTarget) override { |
- int colorOffset = -1, texOffset = -1; |
- SkAutoTUnref<const GrGeometryProcessor> gp( |
- set_vertex_attributes(this->hasLocalCoords(), this->hasColors(), &colorOffset, |
- &texOffset, this->color(), this->viewMatrix(), |
- this->coverageIgnored())); |
- |
- batchTarget->initDraw(gp, this->pipeline()); |
- |
- size_t vertexStride = gp->getVertexStride(); |
- |
- SkASSERT(vertexStride == sizeof(SkPoint) + (this->hasLocalCoords() ? sizeof(SkPoint) : 0) |
- + (this->hasColors() ? sizeof(GrColor) : 0)); |
- |
- int instanceCount = fGeoData.count(); |
- |
- const GrVertexBuffer* vertexBuffer; |
- int firstVertex; |
- |
- void* verts = batchTarget->makeVertSpace(vertexStride, this->vertexCount(), |
- &vertexBuffer, &firstVertex); |
- |
- if (!verts) { |
- SkDebugf("Could not allocate vertices\n"); |
- return; |
- } |
- |
- const GrIndexBuffer* indexBuffer = NULL; |
- int firstIndex = 0; |
- |
- uint16_t* indices = NULL; |
- if (this->hasIndices()) { |
- indices = batchTarget->makeIndexSpace(this->indexCount(), &indexBuffer, &firstIndex); |
- |
- if (!indices) { |
- SkDebugf("Could not allocate indices\n"); |
- return; |
- } |
- } |
- |
- int indexOffset = 0; |
- int vertexOffset = 0; |
- for (int i = 0; i < instanceCount; i++) { |
- const Geometry& args = fGeoData[i]; |
- |
- // TODO we can actually cache this interleaved and then just memcopy |
- if (this->hasIndices()) { |
- for (int j = 0; j < args.fIndices.count(); ++j, ++indexOffset) { |
- *(indices + indexOffset) = args.fIndices[j] + vertexOffset; |
- } |
- } |
- |
- for (int j = 0; j < args.fPositions.count(); ++j) { |
- *((SkPoint*)verts) = args.fPositions[j]; |
- if (this->hasColors()) { |
- *(GrColor*)((intptr_t)verts + colorOffset) = args.fColors[j]; |
- } |
- if (this->hasLocalCoords()) { |
- *(SkPoint*)((intptr_t)verts + texOffset) = args.fLocalCoords[j]; |
- } |
- verts = (void*)((intptr_t)verts + vertexStride); |
- vertexOffset++; |
- } |
- } |
- |
- GrVertices vertices; |
- if (this->hasIndices()) { |
- vertices.initIndexed(this->primitiveType(), vertexBuffer, indexBuffer, firstVertex, |
- firstIndex, this->vertexCount(), this->indexCount()); |
- |
- } else { |
- vertices.init(this->primitiveType(), vertexBuffer, firstVertex, this->vertexCount()); |
- } |
- batchTarget->draw(vertices); |
- } |
- |
- SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; } |
- |
-private: |
- DrawVerticesBatch(const Geometry& geometry, GrPrimitiveType primitiveType, |
- const SkMatrix& viewMatrix, |
- const SkPoint* positions, int vertexCount, |
- const uint16_t* indices, int indexCount, |
- const GrColor* colors, const SkPoint* localCoords, const SkRect& bounds) { |
- this->initClassID<DrawVerticesBatch>(); |
- SkASSERT(positions); |
- |
- fBatch.fViewMatrix = viewMatrix; |
- Geometry& installedGeo = fGeoData.push_back(geometry); |
- |
- installedGeo.fPositions.append(vertexCount, positions); |
- if (indices) { |
- installedGeo.fIndices.append(indexCount, indices); |
- fBatch.fHasIndices = true; |
- } else { |
- fBatch.fHasIndices = false; |
- } |
- |
- if (colors) { |
- installedGeo.fColors.append(vertexCount, colors); |
- fBatch.fHasColors = true; |
- } else { |
- fBatch.fHasColors = false; |
- } |
- |
- if (localCoords) { |
- installedGeo.fLocalCoords.append(vertexCount, localCoords); |
- fBatch.fHasLocalCoords = true; |
- } else { |
- fBatch.fHasLocalCoords = false; |
- } |
- fBatch.fVertexCount = vertexCount; |
- fBatch.fIndexCount = indexCount; |
- fBatch.fPrimitiveType = primitiveType; |
- |
- this->setBounds(bounds); |
- } |
- |
- GrPrimitiveType primitiveType() const { return fBatch.fPrimitiveType; } |
- bool batchablePrimitiveType() const { |
- return kTriangles_GrPrimitiveType == fBatch.fPrimitiveType || |
- kLines_GrPrimitiveType == fBatch.fPrimitiveType || |
- kPoints_GrPrimitiveType == fBatch.fPrimitiveType; |
- } |
- GrColor color() const { return fBatch.fColor; } |
- bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; } |
- bool colorIgnored() const { return fBatch.fColorIgnored; } |
- const SkMatrix& viewMatrix() const { return fBatch.fViewMatrix; } |
- bool hasColors() const { return fBatch.fHasColors; } |
- bool hasIndices() const { return fBatch.fHasIndices; } |
- bool hasLocalCoords() const { return fBatch.fHasLocalCoords; } |
- int vertexCount() const { return fBatch.fVertexCount; } |
- int indexCount() const { return fBatch.fIndexCount; } |
- bool coverageIgnored() const { return fBatch.fCoverageIgnored; } |
- |
- bool onCombineIfPossible(GrBatch* t) override { |
- if (!this->pipeline()->isEqual(*t->pipeline())) { |
- return false; |
- } |
- |
- DrawVerticesBatch* that = t->cast<DrawVerticesBatch>(); |
- |
- if (!this->batchablePrimitiveType() || this->primitiveType() != that->primitiveType()) { |
- return false; |
- } |
- |
- SkASSERT(this->usesLocalCoords() == that->usesLocalCoords()); |
- |
- // We currently use a uniform viewmatrix for this batch |
- if (!this->viewMatrix().cheapEqualTo(that->viewMatrix())) { |
- return false; |
- } |
- |
- if (this->hasColors() != that->hasColors()) { |
- return false; |
- } |
- |
- if (this->hasIndices() != that->hasIndices()) { |
- return false; |
- } |
- |
- if (this->hasLocalCoords() != that->hasLocalCoords()) { |
- return false; |
- } |
- |
- if (!this->hasColors() && this->color() != that->color()) { |
- return false; |
- } |
- |
- if (this->color() != that->color()) { |
- fBatch.fColor = GrColor_ILLEGAL; |
- } |
- fGeoData.push_back_n(that->geoData()->count(), that->geoData()->begin()); |
- fBatch.fVertexCount += that->vertexCount(); |
- fBatch.fIndexCount += that->indexCount(); |
- |
- this->joinBounds(that->bounds()); |
- return true; |
- } |
- |
- struct BatchTracker { |
- GrPrimitiveType fPrimitiveType; |
- SkMatrix fViewMatrix; |
- GrColor fColor; |
- bool fUsesLocalCoords; |
- bool fColorIgnored; |
- bool fCoverageIgnored; |
- bool fHasColors; |
- bool fHasIndices; |
- bool fHasLocalCoords; |
- int fVertexCount; |
- int fIndexCount; |
- }; |
- |
- BatchTracker fBatch; |
- SkSTArray<1, Geometry, true> fGeoData; |
-}; |
- |
void GrDrawContext::drawVertices(GrRenderTarget* rt, |
const GrClip& clip, |
const GrPaint& paint, |
@@ -684,12 +407,12 @@ void GrDrawContext::drawVertices(GrRenderTarget* rt, |
bounds.outset(0.5f, 0.5f); |
} |
- DrawVerticesBatch::Geometry geometry; |
+ GrDrawVerticesBatch::Geometry geometry; |
geometry.fColor = paint.getColor(); |
- SkAutoTUnref<GrBatch> batch(DrawVerticesBatch::Create(geometry, primitiveType, viewMatrix, |
- positions, vertexCount, indices, |
- indexCount, colors, texCoords, |
- bounds)); |
+ SkAutoTUnref<GrBatch> batch(GrDrawVerticesBatch::Create(geometry, primitiveType, viewMatrix, |
+ positions, vertexCount, indices, |
+ indexCount, colors, texCoords, |
+ bounds)); |
fDrawTarget->drawBatch(pipelineBuilder, batch); |
} |
@@ -1108,121 +831,3 @@ bool GrDrawContext::prepareToDraw(GrRenderTarget* rt) { |
void GrDrawContext::drawBatch(GrPipelineBuilder* pipelineBuilder, GrBatch* batch) { |
fDrawTarget->drawBatch(*pipelineBuilder, batch); |
} |
- |
-/////////////////////////////////////////////////////////////////////////////////////////////////// |
- |
-#ifdef GR_TEST_UTILS |
- |
-static uint32_t seed_vertices(GrPrimitiveType type) { |
- switch (type) { |
- case kTriangles_GrPrimitiveType: |
- case kTriangleStrip_GrPrimitiveType: |
- case kTriangleFan_GrPrimitiveType: |
- return 3; |
- case kPoints_GrPrimitiveType: |
- return 1; |
- case kLines_GrPrimitiveType: |
- case kLineStrip_GrPrimitiveType: |
- return 2; |
- } |
- SkFAIL("Incomplete switch\n"); |
- return 0; |
-} |
- |
-static uint32_t primitive_vertices(GrPrimitiveType type) { |
- switch (type) { |
- case kTriangles_GrPrimitiveType: |
- return 3; |
- case kLines_GrPrimitiveType: |
- return 2; |
- case kTriangleStrip_GrPrimitiveType: |
- case kTriangleFan_GrPrimitiveType: |
- case kPoints_GrPrimitiveType: |
- case kLineStrip_GrPrimitiveType: |
- return 1; |
- } |
- SkFAIL("Incomplete switch\n"); |
- return 0; |
-} |
- |
-static SkPoint random_point(SkRandom* random, SkScalar min, SkScalar max) { |
- SkPoint p; |
- p.fX = random->nextRangeScalar(min, max); |
- p.fY = random->nextRangeScalar(min, max); |
- return p; |
-} |
- |
-static void randomize_params(size_t count, size_t maxVertex, SkScalar min, SkScalar max, |
- SkRandom* random, |
- SkTArray<SkPoint>* positions, |
- SkTArray<SkPoint>* texCoords, bool hasTexCoords, |
- SkTArray<GrColor>* colors, bool hasColors, |
- SkTArray<uint16_t>* indices, bool hasIndices) { |
- for (uint32_t v = 0; v < count; v++) { |
- positions->push_back(random_point(random, min, max)); |
- if (hasTexCoords) { |
- texCoords->push_back(random_point(random, min, max)); |
- } |
- if (hasColors) { |
- colors->push_back(GrRandomColor(random)); |
- } |
- if (hasIndices) { |
- SkASSERT(maxVertex <= SK_MaxU16); |
- indices->push_back(random->nextULessThan((uint16_t)maxVertex)); |
- } |
- } |
-} |
- |
-BATCH_TEST_DEFINE(VerticesBatch) { |
- GrPrimitiveType type = GrPrimitiveType(random->nextULessThan(kLast_GrPrimitiveType + 1)); |
- uint32_t primitiveCount = random->nextRangeU(1, 100); |
- |
- // TODO make 'sensible' indexbuffers |
- SkTArray<SkPoint> positions; |
- SkTArray<SkPoint> texCoords; |
- SkTArray<GrColor> colors; |
- SkTArray<uint16_t> indices; |
- |
- bool hasTexCoords = random->nextBool(); |
- bool hasIndices = random->nextBool(); |
- bool hasColors = random->nextBool(); |
- |
- uint32_t vertexCount = seed_vertices(type) + (primitiveCount - 1) * primitive_vertices(type); |
- |
- static const SkScalar kMinVertExtent = -100.f; |
- static const SkScalar kMaxVertExtent = 100.f; |
- randomize_params(seed_vertices(type), vertexCount, kMinVertExtent, kMaxVertExtent, |
- random, |
- &positions, |
- &texCoords, hasTexCoords, |
- &colors, hasColors, |
- &indices, hasIndices); |
- |
- for (uint32_t i = 1; i < primitiveCount; i++) { |
- randomize_params(primitive_vertices(type), vertexCount, kMinVertExtent, kMaxVertExtent, |
- random, |
- &positions, |
- &texCoords, hasTexCoords, |
- &colors, hasColors, |
- &indices, hasIndices); |
- } |
- |
- SkMatrix viewMatrix = GrTest::TestMatrix(random); |
- SkRect bounds; |
- SkDEBUGCODE(bool result = ) bounds.setBoundsCheck(positions.begin(), vertexCount); |
- SkASSERT(result); |
- |
- viewMatrix.mapRect(&bounds); |
- |
- DrawVerticesBatch::Geometry geometry; |
- geometry.fColor = GrRandomColor(random); |
- return DrawVerticesBatch::Create(geometry, type, viewMatrix, |
- positions.begin(), vertexCount, |
- indices.begin(), hasIndices ? vertexCount : 0, |
- colors.begin(), |
- texCoords.begin(), |
- bounds); |
-} |
- |
-#endif |
- |