Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(137)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: src/gpu/batches/GrDrawAtlasBatch.cpp

Issue 1279343004: Revise DrawAtlasBatch to get rid of one copy when generating the batch. (Closed) Base URL: https://skia.googlesource.com/skia.git@master
Patch Set: Updated for comments Created 5 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « src/gpu/batches/GrDrawAtlasBatch.h ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: src/gpu/batches/GrDrawAtlasBatch.cpp
diff --git a/src/gpu/batches/GrDrawAtlasBatch.cpp b/src/gpu/batches/GrDrawAtlasBatch.cpp
index c1f244362c16691c35d698f25a437aab2aef63e1..d0a3a262bcfaf4effc8ae59a0369609fa582d9bd 100644
--- a/src/gpu/batches/GrDrawAtlasBatch.cpp
+++ b/src/gpu/batches/GrDrawAtlasBatch.cpp
@@ -7,7 +7,9 @@
#include "GrDrawAtlasBatch.h"
#include "GrBatchTest.h"
+#include "SkGr.h"
#include "SkRandom.h"
+#include "SkRSXform.h"
void GrDrawAtlasBatch::initBatchTracker(const GrPipelineOptimizations& opt) {
// Handle any color overrides
@@ -24,42 +26,27 @@ void GrDrawAtlasBatch::initBatchTracker(const GrPipelineOptimizations& opt) {
fCoverageIgnored = !opt.readsCoverage();
}
-static const GrGeometryProcessor* set_vertex_attributes(bool hasLocalCoords,
- bool hasColors,
- int* colorOffset,
- int* texOffset,
+static const GrGeometryProcessor* set_vertex_attributes(bool hasColors,
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);
- }
+ LocalCoords localCoords(LocalCoords::kHasExplicit_Type);
return GrDefaultGeoProcFactory::Create(gpColor, coverage, localCoords, viewMatrix);
}
void GrDrawAtlasBatch::generateGeometry(GrBatchTarget* batchTarget) {
- int colorOffset = -1, texOffset = -1;
// Setup geometry processor
- SkAutoTUnref<const GrGeometryProcessor> gp(
- set_vertex_attributes(true, this->hasColors(), &colorOffset,
- &texOffset, this->color(), this->viewMatrix(),
- this->coverageIgnored()));
+ SkAutoTUnref<const GrGeometryProcessor> gp(set_vertex_attributes(this->hasColors(),
+ this->color(),
+ this->viewMatrix(),
+ this->coverageIgnored()));
batchTarget->initDraw(gp, this->pipeline());
@@ -69,53 +56,103 @@ void GrDrawAtlasBatch::generateGeometry(GrBatchTarget* batchTarget) {
+ (this->hasColors() ? sizeof(GrColor) : 0));
QuadHelper helper;
- int numQuads = this->vertexCount()/4;
+ int numQuads = this->quadCount();
void* verts = helper.init(batchTarget, vertexStride, numQuads);
if (!verts) {
SkDebugf("Could not allocate vertices\n");
return;
}
- int vertexOffset = 0;
+ uint8_t* vertPtr = reinterpret_cast<uint8_t*>(verts);
for (int i = 0; i < instanceCount; i++) {
const Geometry& args = fGeoData[i];
- 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];
- }
- *(SkPoint*)((intptr_t)verts + texOffset) = args.fLocalCoords[j];
- verts = (void*)((intptr_t)verts + vertexStride);
- vertexOffset++;
- }
+ size_t allocSize = args.fVerts.count();
+ memcpy(vertPtr, args.fVerts.begin(), allocSize);
+ vertPtr += allocSize;
}
helper.issueDraw(batchTarget);
}
GrDrawAtlasBatch::GrDrawAtlasBatch(const Geometry& geometry, const SkMatrix& viewMatrix,
- const SkPoint* positions, int vertexCount,
- const GrColor* colors, const SkPoint* localCoords,
- const SkRect& bounds) {
+ int spriteCount, const SkRSXform* xforms, const SkRect* rects,
+ const SkColor* colors) {
this->initClassID<GrDrawAtlasBatch>();
- SkASSERT(positions);
- SkASSERT(localCoords);
+ SkASSERT(xforms);
+ SkASSERT(rects);
fViewMatrix = viewMatrix;
Geometry& installedGeo = fGeoData.push_back(geometry);
- installedGeo.fPositions.append(vertexCount, positions);
-
+ // Figure out stride and offsets
+ // Order within the vertex is: position [color] texCoord
+ size_t texOffset = sizeof(SkPoint);
+ size_t vertexStride = 2*sizeof(SkPoint);
robertphillips 2015/08/12 12:34:11 SkToBool(colors) ?
jvanverth1 2015/08/12 14:08:42 Done.
+ fHasColors = (nullptr != colors);
if (colors) {
- installedGeo.fColors.append(vertexCount, colors);
- fHasColors = true;
- } else {
- fHasColors = false;
+ texOffset += sizeof(GrColor);
+ vertexStride += sizeof(GrColor);
}
- installedGeo.fLocalCoords.append(vertexCount, localCoords);
- fVertexCount = vertexCount;
+ // Compute buffer size and alloc buffer
+ fQuadCount = spriteCount;
+ size_t allocSize = 4*vertexStride*spriteCount;
+ installedGeo.fVerts.reset(allocSize);
+ uint8_t* currVertex = installedGeo.fVerts.begin();
+
+ SkRect bounds;
+ bounds.setLargestInverted();
+ int paintAlpha = GrColorUnpackA(installedGeo.fColor);
+ for (int spriteIndex = 0; spriteIndex < spriteCount; ++spriteIndex) {
+ // Transform rect
+ SkPoint quad[4];
robertphillips 2015/08/12 12:34:11 const SkRect& currRect = ... ?
jvanverth1 2015/08/12 14:08:42 Done.
+ SkRect currRect = rects[spriteIndex];
+ xforms[spriteIndex].toQuad(currRect.width(), currRect.height(), quad);
+
+ // Copy colors if necessary
+ if (colors) {
+ // convert to GrColor
+ SkColor color = colors[spriteIndex];
+ if (paintAlpha != 255) {
+ color = SkColorSetA(color, SkMulDiv255Round(SkColorGetA(color), paintAlpha));
+ }
+ GrColor grColor = SkColor2GrColor(color);
+
+ *(reinterpret_cast<GrColor*>(currVertex+sizeof(SkPoint))) = grColor;
+ *(reinterpret_cast<GrColor*>(currVertex+vertexStride+sizeof(SkPoint))) = grColor;
+ *(reinterpret_cast<GrColor*>(currVertex+2*vertexStride+sizeof(SkPoint))) = grColor;
+ *(reinterpret_cast<GrColor*>(currVertex+3*vertexStride+sizeof(SkPoint))) = grColor;
+ }
+
+ // Copy position and uv to verts
+ *(reinterpret_cast<SkPoint*>(currVertex)) = quad[0];
+ *(reinterpret_cast<SkPoint*>(currVertex+texOffset)) = SkPoint::Make(currRect.fLeft,
+ currRect.fTop);
+ bounds.growToInclude(quad[0].fX, quad[0].fY);
+ currVertex += vertexStride;
+
+ *(reinterpret_cast<SkPoint*>(currVertex)) = quad[1];
+ *(reinterpret_cast<SkPoint*>(currVertex+texOffset)) = SkPoint::Make(currRect.fRight,
+ currRect.fTop);
+ bounds.growToInclude(quad[1].fX, quad[1].fY);
+ currVertex += vertexStride;
+
+ *(reinterpret_cast<SkPoint*>(currVertex)) = quad[2];
+ *(reinterpret_cast<SkPoint*>(currVertex+texOffset)) = SkPoint::Make(currRect.fRight,
+ currRect.fBottom);
+ bounds.growToInclude(quad[2].fX, quad[2].fY);
+ currVertex += vertexStride;
+
+ *(reinterpret_cast<SkPoint*>(currVertex)) = quad[3];
+ *(reinterpret_cast<SkPoint*>(currVertex+texOffset)) = SkPoint::Make(currRect.fLeft,
+ currRect.fBottom);
+ bounds.growToInclude(quad[3].fX, quad[3].fY);
+ currVertex += vertexStride;
+ }
+ viewMatrix.mapRect(&bounds);
+ // Outset for a half pixel in each direction to account for snapping in non-AA case
+ bounds.outset(0.5f, 0.5f);
this->setBounds(bounds);
}
@@ -143,7 +180,7 @@ bool GrDrawAtlasBatch::onCombineIfPossible(GrBatch* t) {
fColor = GrColor_ILLEGAL;
}
fGeoData.push_back_n(that->geoData()->count(), that->geoData()->begin());
- fVertexCount += that->vertexCount();
+ fQuadCount += that->quadCount();
this->joinBounds(that->bounds());
return true;
@@ -151,62 +188,69 @@ bool GrDrawAtlasBatch::onCombineIfPossible(GrBatch* t) {
#ifdef GR_TEST_UTILS
-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 SkRSXform random_xform(SkRandom* random) {
+ static const SkScalar kMinExtent = -100.f;
+ static const SkScalar kMaxExtent = 100.f;
+ static const SkScalar kMinScale = 0.1f;
+ static const SkScalar kMaxScale = 100.f;
+ static const SkScalar kMinRotate = -SK_ScalarPI;
+ static const SkScalar kMaxRotate = SK_ScalarPI;
+
+ SkRSXform xform = SkRSXform::MakeFromRadians(random->nextRangeScalar(kMinScale, kMaxScale),
+ random->nextRangeScalar(kMinRotate, kMaxRotate),
+ random->nextRangeScalar(kMinExtent, kMaxExtent),
+ random->nextRangeScalar(kMinExtent, kMaxExtent),
+ random->nextRangeScalar(kMinExtent, kMaxExtent),
+ random->nextRangeScalar(kMinExtent, kMaxExtent));
+ return xform;
+}
+
+static SkRect random_texRect(SkRandom* random) {
+ static const SkScalar kMinCoord = 0.0f;
+ static const SkScalar kMaxCoord = 1024.f;
+
+ SkRect texRect = SkRect::MakeLTRB(random->nextRangeScalar(kMinCoord, kMaxCoord),
+ random->nextRangeScalar(kMinCoord, kMaxCoord),
+ random->nextRangeScalar(kMinCoord, kMaxCoord),
+ random->nextRangeScalar(kMinCoord, kMaxCoord));
+ texRect.sort();
+ return texRect;
}
-static void randomize_params(size_t count, SkScalar min, SkScalar max,
- SkRandom* random,
- SkTArray<SkPoint>* positions,
- SkTArray<SkPoint>* texCoords,
+static void randomize_params(uint32_t count, SkRandom* random,
+ SkTArray<SkRSXform>* xforms,
+ SkTArray<SkRect>* texRects,
SkTArray<GrColor>* colors, bool hasColors) {
for (uint32_t v = 0; v < count; v++) {
- positions->push_back(random_point(random, min, max));
- texCoords->push_back(random_point(random, min, max));
+ xforms->push_back(random_xform(random));
+ texRects->push_back(random_texRect(random));
if (hasColors) {
colors->push_back(GrRandomColor(random));
}
}
}
-
BATCH_TEST_DEFINE(GrDrawAtlasBatch) {
uint32_t spriteCount = random->nextRangeU(1, 100);
- // TODO make 'sensible' indexbuffers
- SkTArray<SkPoint> positions;
- SkTArray<SkPoint> texCoords;
- SkTArray<GrColor> colors;
+ SkTArray<SkRSXform> xforms(spriteCount);
+ SkTArray<SkRect> texRects(spriteCount);
+ SkTArray<GrColor> colors(spriteCount);
bool hasColors = random->nextBool();
- uint32_t vertexCount = 4*spriteCount;
-
- static const SkScalar kMinVertExtent = -100.f;
- static const SkScalar kMaxVertExtent = 100.f;
- randomize_params(vertexCount, kMinVertExtent, kMaxVertExtent,
+ randomize_params(spriteCount,
random,
- &positions,
- &texCoords,
+ &xforms,
+ &texRects,
&colors, hasColors);
SkMatrix viewMatrix = GrTest::TestMatrix(random);
- SkRect bounds;
- SkDEBUGCODE(bool result = ) bounds.setBoundsCheck(positions.begin(), vertexCount);
- SkASSERT(result);
-
- viewMatrix.mapRect(&bounds);
GrDrawAtlasBatch::Geometry geometry;
geometry.fColor = GrRandomColor(random);
- return GrDrawAtlasBatch::Create(geometry, viewMatrix,
- positions.begin(), vertexCount,
- colors.begin(),
- texCoords.begin(),
- bounds);
+ return GrDrawAtlasBatch::Create(geometry, viewMatrix, spriteCount, xforms.begin(),
+ texRects.begin(), colors.begin());
}
#endif
« no previous file with comments | « src/gpu/batches/GrDrawAtlasBatch.h ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698