| /* |
| * Copyright 2015 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "GrDrawVerticesBatch.h" |
| |
| #include "GrDefaultGeoProcFactory.h" |
| #include "GrInvariantOutput.h" |
| #include "GrOpFlushState.h" |
| |
| static sk_sp<GrGeometryProcessor> set_vertex_attributes(bool hasLocalCoords, |
| int* colorOffset, |
| int* texOffset, |
| const SkMatrix& viewMatrix, |
| bool coverageIgnored) { |
| using namespace GrDefaultGeoProcFactory; |
| *texOffset = -1; |
| *colorOffset = -1; |
| |
| Coverage coverage(coverageIgnored ? Coverage::kNone_Type : Coverage::kSolid_Type); |
| LocalCoords localCoords(hasLocalCoords ? LocalCoords::kHasExplicit_Type : |
| LocalCoords::kUsePosition_Type); |
| *colorOffset = sizeof(SkPoint); |
| if (hasLocalCoords) { |
| *texOffset = sizeof(SkPoint) + sizeof(GrColor); |
| } |
| return GrDefaultGeoProcFactory::Make(Color(Color::kAttribute_Type), |
| coverage, localCoords, viewMatrix); |
| } |
| |
| GrDrawVerticesBatch::GrDrawVerticesBatch(GrColor color, 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) |
| : INHERITED(ClassID()) { |
| SkASSERT(positions); |
| |
| fViewMatrix = viewMatrix; |
| Mesh& mesh = fMeshes.push_back(); |
| mesh.fColor = color; |
| |
| mesh.fPositions.append(vertexCount, positions); |
| if (indices) { |
| mesh.fIndices.append(indexCount, indices); |
| } |
| |
| if (colors) { |
| fVariableColor = true; |
| mesh.fColors.append(vertexCount, colors); |
| } else { |
| fVariableColor = false; |
| } |
| |
| if (localCoords) { |
| mesh.fLocalCoords.append(vertexCount, localCoords); |
| } |
| fVertexCount = vertexCount; |
| fIndexCount = indexCount; |
| fPrimitiveType = primitiveType; |
| |
| IsZeroArea zeroArea; |
| if (GrIsPrimTypeLines(primitiveType) || kPoints_GrPrimitiveType == primitiveType) { |
| zeroArea = IsZeroArea::kYes; |
| } else { |
| zeroArea = IsZeroArea::kNo; |
| } |
| this->setBounds(bounds, HasAABloat::kNo, zeroArea); |
| } |
| |
| void GrDrawVerticesBatch::computePipelineOptimizations(GrInitInvariantOutput* color, |
| GrInitInvariantOutput* coverage, |
| GrBatchToXPOverrides* overrides) const { |
| // When this is called on a batch, there is only one mesh |
| if (fVariableColor) { |
| color->setUnknownFourComponents(); |
| } else { |
| color->setKnownFourComponents(fMeshes[0].fColor); |
| } |
| coverage->setKnownSingleComponent(0xff); |
| } |
| |
| void GrDrawVerticesBatch::initBatchTracker(const GrXPOverridesForBatch& overrides) { |
| SkASSERT(fMeshes.count() == 1); |
| GrColor overrideColor; |
| if (overrides.getOverrideColorIfSet(&overrideColor)) { |
| fMeshes[0].fColor = overrideColor; |
| fMeshes[0].fColors.reset(); |
| fVariableColor = false; |
| } |
| fCoverageIgnored = !overrides.readsCoverage(); |
| if (!overrides.readsLocalCoords()) { |
| fMeshes[0].fLocalCoords.reset(); |
| } |
| } |
| |
| void GrDrawVerticesBatch::onPrepareDraws(Target* target) const { |
| bool hasLocalCoords = !fMeshes[0].fLocalCoords.isEmpty(); |
| int colorOffset = -1, texOffset = -1; |
| sk_sp<GrGeometryProcessor> gp(set_vertex_attributes(hasLocalCoords, &colorOffset, &texOffset, |
| fViewMatrix, fCoverageIgnored)); |
| size_t vertexStride = gp->getVertexStride(); |
| |
| SkASSERT(vertexStride == sizeof(SkPoint) + (hasLocalCoords ? sizeof(SkPoint) : 0) |
| + sizeof(GrColor)); |
| |
| int instanceCount = fMeshes.count(); |
| |
| const GrBuffer* vertexBuffer; |
| int firstVertex; |
| |
| void* verts = target->makeVertexSpace(vertexStride, fVertexCount, &vertexBuffer, &firstVertex); |
| |
| if (!verts) { |
| SkDebugf("Could not allocate vertices\n"); |
| return; |
| } |
| |
| const GrBuffer* indexBuffer = nullptr; |
| int firstIndex = 0; |
| |
| uint16_t* indices = nullptr; |
| if (!fMeshes[0].fIndices.isEmpty()) { |
| indices = target->makeIndexSpace(fIndexCount, &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 Mesh& mesh = fMeshes[i]; |
| |
| // TODO we can actually cache this interleaved and then just memcopy |
| if (indices) { |
| for (int j = 0; j < mesh.fIndices.count(); ++j, ++indexOffset) { |
| *(indices + indexOffset) = mesh.fIndices[j] + vertexOffset; |
| } |
| } |
| |
| for (int j = 0; j < mesh.fPositions.count(); ++j) { |
| *((SkPoint*)verts) = mesh.fPositions[j]; |
| if (mesh.fColors.isEmpty()) { |
| *(GrColor*)((intptr_t)verts + colorOffset) = mesh.fColor; |
| } else { |
| *(GrColor*)((intptr_t)verts + colorOffset) = mesh.fColors[j]; |
| } |
| if (hasLocalCoords) { |
| *(SkPoint*)((intptr_t)verts + texOffset) = mesh.fLocalCoords[j]; |
| } |
| verts = (void*)((intptr_t)verts + vertexStride); |
| vertexOffset++; |
| } |
| } |
| |
| GrMesh mesh; |
| if (indices) { |
| mesh.initIndexed(this->primitiveType(), vertexBuffer, indexBuffer, firstVertex, |
| firstIndex, fVertexCount, fIndexCount); |
| |
| } else { |
| mesh.init(this->primitiveType(), vertexBuffer, firstVertex, fVertexCount); |
| } |
| target->draw(gp.get(), mesh); |
| } |
| |
| bool GrDrawVerticesBatch::onCombineIfPossible(GrOp* t, const GrCaps& caps) { |
| GrDrawVerticesBatch* that = t->cast<GrDrawVerticesBatch>(); |
| |
| if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(), |
| that->bounds(), caps)) { |
| return false; |
| } |
| |
| if (!this->batchablePrimitiveType() || this->primitiveType() != that->primitiveType()) { |
| return false; |
| } |
| |
| // We currently use a uniform viewmatrix for this batch |
| if (!fViewMatrix.cheapEqualTo(that->fViewMatrix)) { |
| return false; |
| } |
| |
| if (fMeshes[0].fIndices.isEmpty() != that->fMeshes[0].fIndices.isEmpty()) { |
| return false; |
| } |
| |
| if (fMeshes[0].fLocalCoords.isEmpty() != that->fMeshes[0].fLocalCoords.isEmpty()) { |
| return false; |
| } |
| |
| if (!fVariableColor) { |
| if (that->fVariableColor || that->fMeshes[0].fColor != fMeshes[0].fColor) { |
| fVariableColor = true; |
| } |
| } |
| |
| fMeshes.push_back_n(that->fMeshes.count(), that->fMeshes.begin()); |
| fVertexCount += that->fVertexCount; |
| fIndexCount += that->fIndexCount; |
| |
| this->joinBounds(*that); |
| return true; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| #ifdef GR_TEST_UTILS |
| |
| #include "GrBatchTest.h" |
| |
| 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)); |
| } |
| } |
| } |
| |
| DRAW_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); |
| |
| GrColor color = GrRandomColor(random); |
| return new GrDrawVerticesBatch(color, type, viewMatrix, positions.begin(), vertexCount, |
| indices.begin(), hasIndices ? vertexCount : 0, |
| colors.begin(), texCoords.begin(), bounds); |
| } |
| |
| #endif |