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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: src/gpu/GrRectRenderer.cpp

Issue 2230513004: Re-adding analytical GeoProc for rectangles (Closed) Base URL: https://skia.googlesource.com/skia@master
Patch Set: Created 4 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
« src/gpu/GrRectRenderer.h ('K') | « src/gpu/GrRectRenderer.h ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: src/gpu/GrRectRenderer.cpp
diff --git a/src/gpu/GrRectRenderer.cpp b/src/gpu/GrRectRenderer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3845759f07b21b3b1a006ee7379e8d988fa149aa
--- /dev/null
+++ b/src/gpu/GrRectRenderer.cpp
@@ -0,0 +1,411 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "GrRectRenderer.h"
+
+#include "GrBatchFlushState.h"
+#include "GrBatchTest.h"
+#include "GrGeometryProcessor.h"
+#include "GrInvariantOutput.h"
+#include "GrProcessor.h"
+#include "GrResourceProvider.h"
+#include "SkRRect.h"
+#include "SkStrokeRec.h"
+#include "batches/GrVertexBatch.h"
+#include "glsl/GrGLSLFragmentShaderBuilder.h"
+#include "glsl/GrGLSLGeometryProcessor.h"
+#include "glsl/GrGLSLProgramDataManager.h"
+#include "glsl/GrGLSLVarying.h"
+#include "glsl/GrGLSLVertexShaderBuilder.h"
+#include "glsl/GrGLSLUniformHandler.h"
+#include "glsl/GrGLSLUtil.h"
+
+namespace {
+
+struct RectVertex {
+ SkPoint fPos;
+ GrColor fColor;
+ SkPoint fCenter;
+ SkVector fDownDir;
+ SkScalar fHalfWidth;
+ SkScalar fHalfHeight;
+};
+
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * The output of this effect is the input color and coverage for an arbitrarily oriented rect. The
+ * rect is specified as:
+ * Center of the rect
+ * Unit vector point down the height of the rect
+ * Half width + 0.5
+ * Half height + 0.5
+ * The center and vector are stored in a vec4 varying ("RectEdge") with the
+ * center in the xy components and the vector in the zw components.
+ * The munged width and height are stored in a vec2 varying ("WidthHeight")
+ * with the width in x and the height in y.
+ */
+class RectGeometryProcessor : public GrGeometryProcessor {
+public:
+ RectGeometryProcessor(const SkMatrix& localMatrix) : fLocalMatrix(localMatrix){
+ this->initClassID<RectGeometryProcessor>();
+ fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType,
+ kHigh_GrSLPrecision));
+ fInColor = &this->addVertexAttrib(Attribute("inColor", kVec4ub_GrVertexAttribType));
+ fInRectEdge = &this->addVertexAttrib(Attribute("inRectEdge", kVec4f_GrVertexAttribType));
+ fInWidthHeight = &this->addVertexAttrib(Attribute("inWidthHeight",
+ kVec2f_GrVertexAttribType));
+ }
+
+ bool implementsDistanceVector() const override { return true; };
+
+ const Attribute* inPosition() const { return fInPosition; }
+ const Attribute* inColor() const { return fInColor; }
+ const Attribute* inRectEdge() const { return fInRectEdge; }
+ const Attribute* inWidthHeight() const { return fInWidthHeight; }
+
+ const SkMatrix& localMatrix() const { return fLocalMatrix; }
+
+ virtual ~RectGeometryProcessor() {}
+
+ const char* name() const override { return "RectEdge"; }
+
+ class GLSLProcessor : public GrGLSLGeometryProcessor {
+ public:
+ GLSLProcessor() {}
+
+ void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override{
+ const RectGeometryProcessor& rgp = args.fGP.cast<RectGeometryProcessor>();
+ GrGLSLVertexBuilder* vertBuilder = args.fVertBuilder;
+ GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;
+ GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
+
+ // emit attributes
+ varyingHandler->emitAttributes(rgp);
+
+ // setup the varying for the position
+ GrGLSLVertToFrag positionVary(kVec2f_GrSLType);
+ varyingHandler->addVarying("Position", &positionVary);
+ vertBuilder->codeAppendf("%s = %s;", positionVary.vsOut(), rgp.inPosition()->fName);
+
+ // setup the varying for the center point and the unit vector that points down the
+ // height of the rect
+ GrGLSLVertToFrag rectEdgeVary(kVec4f_GrSLType);
+ varyingHandler->addVarying("RectEdge", &rectEdgeVary);
+ vertBuilder->codeAppendf("%s = %s;", rectEdgeVary.vsOut(), rgp.inRectEdge()->fName);
+
+ // setup the varying for the width/2+.5 and height/2+.5
+ GrGLSLVertToFrag widthHeightVary(kVec2f_GrSLType);
+ varyingHandler->addVarying("WidthHeight", &widthHeightVary);
+ vertBuilder->codeAppendf("%s = %s;", widthHeightVary.vsOut(), rgp.inWidthHeight()->fName);
egdaniel 2016/08/12 17:37:06 100 chars
dvonbeck 2016/08/12 18:29:48 Done.
+
+ GrGLSLPPFragmentBuilder* fragBuilder = args.fFragBuilder;
+
+ // setup pass through color
+ varyingHandler->addPassThroughAttribute(rgp.inColor(), args.fOutputColor);
+
+ // Setup position
+ this->setupPosition(vertBuilder, gpArgs, rgp.inPosition()->fName);
+
+ // emit transforms
+ this->emitTransforms(vertBuilder,
+ varyingHandler,
+ uniformHandler,
+ gpArgs->fPositionVar,
+ rgp.inPosition()->fName,
+ rgp.localMatrix(),
+ args.fTransformsIn,
+ args.fTransformsOut);
+
+ // TODO: compute all these offsets, spans, and scales in the VS
+ fragBuilder->codeAppendf("float insetW = min(1.0, %s.x) - 0.5;", widthHeightVary.fsIn());
egdaniel 2016/08/12 17:37:06 100 chars
dvonbeck 2016/08/12 18:29:48 Done.
+ fragBuilder->codeAppendf("float insetH = min(1.0, %s.y) - 0.5;", widthHeightVary.fsIn());
+ fragBuilder->codeAppend("float outset = 0.5;");
+ // For rects > 1 pixel wide and tall the span's are noops (i.e., 1.0). For rects
+ // < 1 pixel wide or tall they serve to normalize the < 1 ramp to a 0 .. 1 range.
+ fragBuilder->codeAppend("float spanW = insetW + outset;");
+ fragBuilder->codeAppend("float spanH = insetH + outset;");
+ // For rects < 1 pixel wide or tall, these scale factors are used to cap the maximum
+ // value of coverage that is used. In other words it is the coverage that is
+ // used in the interior of the rect after the ramp.
+ fragBuilder->codeAppend("float scaleW = min(1.0, 2.0*insetW/spanW);");
+ fragBuilder->codeAppend("float scaleH = min(1.0, 2.0*insetH/spanH);");
+ // Compute the coverage for the rect's width
+ fragBuilder->codeAppendf("vec2 offset = %s.xy - %s.xy;",
+ positionVary.fsIn(), rectEdgeVary.fsIn());
+ fragBuilder->codeAppendf("float perpDot = abs(offset.x * %s.w - offset.y * %s.z);",
+ rectEdgeVary.fsIn(), rectEdgeVary.fsIn());
+
+ if (args.fDistanceVectorName) {
+ fragBuilder->codeAppendf("float widthDistance = %s.x - perpDot;",
+ widthHeightVary.fsIn());
+ }
+
+ fragBuilder->codeAppendf(
+ "float coverage = scaleW*clamp((%s.x-perpDot)/spanW, 0.0, 1.0);",
+ widthHeightVary.fsIn());
+ // Compute the coverage for the rect's height and merge with the width
+ fragBuilder->codeAppendf("perpDot = abs(dot(offset, %s.zw));",
+ rectEdgeVary.fsIn());
+
+ if (args.fDistanceVectorName) {
+ fragBuilder->codeAppendf("float heightDistance = %s.y - perpDot;",
+ widthHeightVary.fsIn());
+ }
+
+ fragBuilder->codeAppendf(
+ "coverage = coverage*scaleH*clamp((%s.y-perpDot)/spanH, 0.0, 1.0);",
+ widthHeightVary.fsIn());
+
+ fragBuilder->codeAppendf("%s = vec4(coverage);", args.fOutputCoverage);
+
+ if (args.fDistanceVectorName) {
+ fragBuilder->codeAppend( "// Calculating distance vector\n");
+ fragBuilder->codeAppend( "vec2 dvAxis;");
+ fragBuilder->codeAppend( "float dvLength;");
+
+ fragBuilder->codeAppend( "if (heightDistance < widthDistance) {");
+ fragBuilder->codeAppendf(" dvAxis = %s.zw;", rectEdgeVary.fsIn());
+ fragBuilder->codeAppend( " dvLength = heightDistance;");
+ fragBuilder->codeAppend( "} else {");
+ fragBuilder->codeAppendf(" dvAxis = vec2(-%s.w, %s.z);",
+ rectEdgeVary.fsIn(), rectEdgeVary.fsIn());
+ fragBuilder->codeAppend( " dvLength = widthDistance;");
+ fragBuilder->codeAppend( "}");
+
+ fragBuilder->codeAppend( "float dvSign = sign(dot(offset, dvAxis));");
+ fragBuilder->codeAppendf("%s = vec3(dvSign * dvAxis, dvLength);",
+ args.fDistanceVectorName);
+
+ }
+ }
+
+ static void GenKey(const GrGeometryProcessor& gp,
+ const GrGLSLCaps&,
+ GrProcessorKeyBuilder* b) {
+ b->add32(0x0);
+ }
+
+ void setData(const GrGLSLProgramDataManager& pdman,
+ const GrPrimitiveProcessor& gp) override {}
+
+ void setTransformData(const GrPrimitiveProcessor& primProc,
+ const GrGLSLProgramDataManager& pdman,
+ int index,
+ const SkTArray<const GrCoordTransform*, true>& transforms) override {
+ this->setTransformDataHelper<RectGeometryProcessor>(primProc, pdman, index, transforms);
+ }
+
+ private:
+ typedef GrGLSLGeometryProcessor INHERITED;
+ };
+
+ void getGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override {
+ GLSLProcessor::GenKey(*this, caps, b);
+ }
+
+ GrGLSLPrimitiveProcessor* createGLSLInstance(const GrGLSLCaps&) const override {
+ return new GLSLProcessor();
+ }
+
+private:
+ SkMatrix fLocalMatrix;
+
+ const Attribute* fInPosition;
+ const Attribute* fInColor;
+ const Attribute* fInRectEdge;
+ const Attribute* fInWidthHeight;
+
+ GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
+
+ typedef GrGeometryProcessor INHERITED;
+};
+
+GR_DEFINE_GEOMETRY_PROCESSOR_TEST(RectGeometryProcessor);
+
+sk_sp<GrGeometryProcessor> RectGeometryProcessor::TestCreate(GrProcessorTestData* d) {
+ return sk_sp<GrGeometryProcessor>(
+ new RectGeometryProcessor(GrTest::TestMatrix(d->fRandom)));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+class AnalyticRectBatch : public GrVertexBatch {
+public:
+ DEFINE_BATCH_CLASS_ID
+
+ AnalyticRectBatch(GrColor color, const SkMatrix& viewMatrix, const SkRect& rect,
+ const SkRect& croppedRect, const SkRect& bounds)
+ : INHERITED(ClassID())
+ , fViewMatrixIfUsingLocalCoords(viewMatrix) {
+ SkPoint center = SkPoint::Make(rect.centerX(), rect.centerY());
+ viewMatrix.mapPoints(&center, 1);
+ SkScalar halfWidth = viewMatrix.mapRadius(SkScalarHalf(rect.width()));
+ SkScalar halfHeight = viewMatrix.mapRadius(SkScalarHalf(rect.height()));
+ SkVector downDir = viewMatrix.mapVector(0.0f, 1.0f);
+ downDir.normalize();
+
+ SkRect deviceSpaceCroppedRect = croppedRect;
+ viewMatrix.mapRect(&deviceSpaceCroppedRect);
+
+ fGeoData.emplace_back(Geometry {color, center, downDir, halfWidth, halfHeight,
+ deviceSpaceCroppedRect});
+
+ this->setBounds(bounds, HasAABloat::kYes, IsZeroArea::kNo);
+ }
+
+ const char* name() const override { return "AnalyticRectBatch"; }
+
+ SkString dumpInfo() const override {
+ SkString string;
+ for (int i = 0; i < fGeoData.count(); ++i) {
+ string.appendf("Color: 0x%08x Rect [C:(%.2f, %.2f) D:<%.2f,%.3f> W/2:%.2f H/2:%.2f]\n",
+ fGeoData[i].fColor,
+ fGeoData[i].fCenter.x(), fGeoData[i].fCenter.y(),
+ fGeoData[i].fDownDir.x(), fGeoData[i].fDownDir.y(),
+ fGeoData[i].fHalfWidth,
+ fGeoData[i].fHalfHeight);
+ }
+ string.append(INHERITED::dumpInfo());
+ return string;
+ }
+
+ void computePipelineOptimizations(GrInitInvariantOutput* color,
+ GrInitInvariantOutput* coverage,
+ GrBatchToXPOverrides* overrides) const override {
+ // When this is called on a batch, there is only one geometry bundle
+ color->setKnownFourComponents(fGeoData[0].fColor);
+ coverage->setUnknownSingleComponent();
+ }
+
+private:
+ void initBatchTracker(const GrXPOverridesForBatch& overrides) override {
+ // Handle any overrides that affect our GP.
+ overrides.getOverrideColorIfSet(&fGeoData[0].fColor);
+ if (!overrides.readsLocalCoords()) {
+ fViewMatrixIfUsingLocalCoords.reset();
+ }
+ }
+
+ void onPrepareDraws(Target* target) const override {
+ SkMatrix localMatrix;
+ if (!fViewMatrixIfUsingLocalCoords.invert(&localMatrix)) {
+ return;
+ }
+
+ // Setup geometry processor
+ SkAutoTUnref<GrGeometryProcessor> gp(new RectGeometryProcessor(localMatrix));
+
+ int instanceCount = fGeoData.count();
+ size_t vertexStride = gp->getVertexStride();
+ SkASSERT(vertexStride == sizeof(RectVertex));
+ QuadHelper helper;
+ RectVertex* verts = reinterpret_cast<RectVertex*>(helper.init(target, vertexStride,
+ instanceCount));
+ if (!verts) {
+ return;
+ }
+
+ for (int i = 0; i < instanceCount; i++) {
+ const Geometry& geom = fGeoData[i];
+
+ GrColor color = geom.fColor;
+ SkPoint center = geom.fCenter;
+ SkVector downDir = geom.fDownDir;
+ SkScalar halfWidth = geom.fHalfWidth;
+ SkScalar halfHeight = geom.fHalfHeight;
+ SkRect croppedRect = geom.fCroppedRect;
+
+ SkVector rightDir;
+ downDir.rotateCCW(&rightDir);
+
+ verts[0].fPos = {croppedRect.fLeft, croppedRect.fTop};
+ verts[0].fColor = color;
+ verts[0].fCenter = center;
+ verts[0].fDownDir = downDir;
+ verts[0].fHalfWidth = halfWidth;
+ verts[0].fHalfHeight = halfHeight;
+
+ verts[1].fPos = {croppedRect.fRight, croppedRect.fTop};
+ verts[1].fColor = color;
+ verts[1].fCenter = center;
+ verts[1].fDownDir = downDir;
+ verts[1].fHalfWidth = halfWidth;
+ verts[1].fHalfHeight = halfHeight;
+
+ verts[2].fPos = {croppedRect.fRight, croppedRect.fBottom};
+ verts[2].fColor = color;
+ verts[2].fCenter = center;
+ verts[2].fDownDir = downDir;
+ verts[2].fHalfWidth = halfWidth;
+ verts[2].fHalfHeight = halfHeight;
+
+ verts[3].fPos = {croppedRect.fLeft, croppedRect.fBottom};
+ verts[3].fColor = color;
+ verts[3].fCenter = center;
+ verts[3].fDownDir = downDir;
+ verts[3].fHalfWidth = halfWidth;
+ verts[3].fHalfHeight = halfHeight;
+
+ verts += kVerticesPerQuad;
+ }
+ helper.recordDraw(target, gp);
+ }
+
+ bool onCombineIfPossible(GrBatch* t, const GrCaps& caps) override {
+ AnalyticRectBatch* that = t->cast<AnalyticRectBatch>();
+ if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
+ that->bounds(), caps)) {
+ return false;
+ }
+
+ if (!fViewMatrixIfUsingLocalCoords.cheapEqualTo(that->fViewMatrixIfUsingLocalCoords)) {
+ return false;
+ }
+
+ fGeoData.push_back_n(that->fGeoData.count(), that->fGeoData.begin());
+ this->joinBounds(*that);
+ return true;
+ }
+
+ struct Geometry {
+ GrColor fColor;
+ SkPoint fCenter;
+ SkVector fDownDir;
+ SkScalar fHalfWidth;
+ SkScalar fHalfHeight;
+ SkRect fCroppedRect;
+ };
+
+ SkMatrix fViewMatrixIfUsingLocalCoords;
+ SkSTArray<1, Geometry, true> fGeoData;
+
+ typedef GrVertexBatch INHERITED;
+};
+
+GrDrawBatch* GrRectRenderer::CreateAnalyticRectBatch(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkRect& rect,
+ const SkRect& croppedRect,
+ const SkRect& bounds) {
+ return new AnalyticRectBatch(color, viewMatrix, rect, croppedRect, bounds);
+}
+
+#ifdef GR_TEST_UTILS
+
+DRAW_BATCH_TEST_DEFINE(AnalyticRectBatch) {
+ SkMatrix viewMatrix = GrTest::TestMatrix(random);
+ GrColor color = GrRandomColor(random);
+ SkRect rect = GrTest::TestSquare(random);
+ SkRect croppedRect = GrTest::TestSquare(random);
+ SkRect bounds = GrTest::TestSquare(random);
+ return new AnalyticRectBatch(color, viewMatrix, rect, croppedRect, bounds);
+}
+
+#endif
« src/gpu/GrRectRenderer.h ('K') | « src/gpu/GrRectRenderer.h ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698