src/gpu/batches/GrDrawVerticesBatch.cpp - platform/external/skia - Gitiles

 /*
  * 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 "GrBatchFlushState.h"
 #include "GrInvariantOutput.h"
 #include "GrDefaultGeoProcFactory.h"

 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);
 }

 GrDrawVerticesBatch::GrDrawVerticesBatch(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<GrDrawVerticesBatch>();
     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);
 }

 void GrDrawVerticesBatch::getInvariantOutputColor(GrInitInvariantOutput* out) const {
     // 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 GrDrawVerticesBatch::getInvariantOutputCoverage(GrInitInvariantOutput* out) const {
     out->setKnownSingleComponent(0xff);
 }

 void GrDrawVerticesBatch::initBatchTracker(const GrPipelineOptimizations& opt) {
     // Handle any color overrides
     if (!opt.readsColor()) {
         fGeoData[0].fColor = GrColor_ILLEGAL;
     }
     opt.getOverrideColorIfSet(&fGeoData[0].fColor);

     // setup batch properties
     fBatch.fColorIgnored = !opt.readsColor();
     fBatch.fColor = fGeoData[0].fColor;
     fBatch.fUsesLocalCoords = opt.readsLocalCoords();
     fBatch.fCoverageIgnored = !opt.readsCoverage();
 }

 void GrDrawVerticesBatch::onPrepareDraws(Target* target) {
     int colorOffset = -1, texOffset = -1;
     SkAutoTUnref<const GrGeometryProcessor> gp(
             set_vertex_attributes(this->hasLocalCoords(), this->hasColors(), &colorOffset,
                                   &texOffset, this->color(), this->viewMatrix(),
                                   this->coverageIgnored()));

     target->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 = target->makeVertexSpace(vertexStride, this->vertexCount(),
                                           &vertexBuffer, &firstVertex);

     if (!verts) {
         SkDebugf("Could not allocate vertices\n");
         return;
     }

     const GrIndexBuffer* indexBuffer = nullptr;
     int firstIndex = 0;

     uint16_t* indices = nullptr;
     if (this->hasIndices()) {
         indices = target->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());
     }
     target->draw(vertices);
 }

 bool GrDrawVerticesBatch::onCombineIfPossible(GrBatch* 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;
     }

     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;
 }

 ///////////////////////////////////////////////////////////////////////////////////////////////////

 #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);

     GrDrawVerticesBatch::Geometry geometry;
     geometry.fColor = GrRandomColor(random);
     return GrDrawVerticesBatch::Create(geometry, type, viewMatrix,
                                        positions.begin(), vertexCount,
                                        indices.begin(), hasIndices ? vertexCount : 0,
                                        colors.begin(),
                                        texCoords.begin(),
                                        bounds);
 }

 #endif
	/*
	* 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 "GrBatchFlushState.h"
	#include "GrInvariantOutput.h"
	#include "GrDefaultGeoProcFactory.h"

	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);
	}

	GrDrawVerticesBatch::GrDrawVerticesBatch(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<GrDrawVerticesBatch>();
	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);
	}

	void GrDrawVerticesBatch::getInvariantOutputColor(GrInitInvariantOutput* out) const {
	// 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 GrDrawVerticesBatch::getInvariantOutputCoverage(GrInitInvariantOutput* out) const {
	out->setKnownSingleComponent(0xff);
	}

	void GrDrawVerticesBatch::initBatchTracker(const GrPipelineOptimizations& opt) {
	// Handle any color overrides
	if (!opt.readsColor()) {
	fGeoData[0].fColor = GrColor_ILLEGAL;
	}
	opt.getOverrideColorIfSet(&fGeoData[0].fColor);

	// setup batch properties
	fBatch.fColorIgnored = !opt.readsColor();
	fBatch.fColor = fGeoData[0].fColor;
	fBatch.fUsesLocalCoords = opt.readsLocalCoords();
	fBatch.fCoverageIgnored = !opt.readsCoverage();
	}

	void GrDrawVerticesBatch::onPrepareDraws(Target* target) {
	int colorOffset = -1, texOffset = -1;
	SkAutoTUnref<const GrGeometryProcessor> gp(
	set_vertex_attributes(this->hasLocalCoords(), this->hasColors(), &colorOffset,
	&texOffset, this->color(), this->viewMatrix(),
	this->coverageIgnored()));

	target->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 = target->makeVertexSpace(vertexStride, this->vertexCount(),
	&vertexBuffer, &firstVertex);

	if (!verts) {
	SkDebugf("Could not allocate vertices\n");
	return;
	}

	const GrIndexBuffer* indexBuffer = nullptr;
	int firstIndex = 0;

	uint16_t* indices = nullptr;
	if (this->hasIndices()) {
	indices = target->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());
	}
	target->draw(vertices);
	}

	bool GrDrawVerticesBatch::onCombineIfPossible(GrBatch* 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;
	}

	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;
	}

	///////////////////////////////////////////////////////////////////////////////////////////////////

	#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);

	GrDrawVerticesBatch::Geometry geometry;
	geometry.fColor = GrRandomColor(random);
	return GrDrawVerticesBatch::Create(geometry, type, viewMatrix,
	positions.begin(), vertexCount,
	indices.begin(), hasIndices ? vertexCount : 0,
	colors.begin(),
	texCoords.begin(),
	bounds);
	}

	#endif