Revert "Initial definition of fill rect op"
This reverts commit d3c92d9a368be2d1f592bef4e65727721fc3ecf8.
Reason for revert: <INSERT REASONING HERE>
Original change's description:
> Initial definition of fill rect op
>
> Bug: skia:
> Change-Id: Ie0c99eb5163501853d1adc885bd3841f90a71924
> Reviewed-on: https://skia-review.googlesource.com/c/163486
> Reviewed-by: Brian Salomon <bsalomon@google.com>
> Commit-Queue: Michael Ludwig <michaelludwig@google.com>
TBR=bsalomon@google.com,csmartdalton@google.com,michaelludwig@google.com
Change-Id: Ib32f91a39d91aeb87982a7b19719485e4a1bf8ae
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: skia:
Reviewed-on: https://skia-review.googlesource.com/c/173233
Reviewed-by: Michael Ludwig <michaelludwig@google.com>
Commit-Queue: Michael Ludwig <michaelludwig@google.com>
diff --git a/gm/drawquadset.cpp b/gm/drawquadset.cpp
deleted file mode 100644
index 9c3c6f0..0000000
--- a/gm/drawquadset.cpp
+++ /dev/null
@@ -1,230 +0,0 @@
-/*
- * Copyright 2018 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include "gm.h"
-
-#include "GrClip.h"
-#include "GrContext.h"
-#include "GrRenderTargetContext.h"
-#include "GrSurfaceContextPriv.h"
-#include "SkGr.h"
-#include "SkGradientShader.h"
-
-static constexpr SkScalar kTileWidth = 40;
-static constexpr SkScalar kTileHeight = 30;
-
-static constexpr int kRowCount = 4;
-static constexpr int kColCount = 3;
-
-static void draw_text(SkCanvas* canvas, const char* text) {
- SkPaint paint;
- paint.setColor(SK_ColorBLACK);
- paint.setTextSize(12.0f);
- paint.setAntiAlias(true);
-
- canvas->drawString(text, 0, 0, paint);
-}
-
-static void draw_gradient_tiles(GrRenderTargetContext* rtc, const SkMatrix& view,
- bool adjustLocal) {
- GrRenderTargetContext::QuadSetEntry quads[kRowCount * kColCount];
-
- for (int i = 0; i < kRowCount; ++i) {
- for (int j = 0; j < kColCount; ++j) {
- SkRect tile = SkRect::MakeXYWH(j * kTileWidth, i * kTileHeight, kTileWidth, kTileHeight);
-
- int q = i * kColCount + j;
- quads[q].fRect = tile;
- quads[q].fColor = {1.f, 1.f, 1.f, 1.f};
-
- if (adjustLocal) {
- quads[q].fLocalMatrix.setTranslate(-tile.fLeft, -tile.fTop);
- } else {
- quads[q].fLocalMatrix.setIdentity();
- }
-
- quads[q].fAAFlags = GrQuadAAFlags::kNone;
- if (i == 0) {
- quads[q].fAAFlags |= GrQuadAAFlags::kTop;
- }
- if (i == kRowCount - 1) {
- quads[q].fAAFlags |= GrQuadAAFlags::kBottom;
- }
- if (j == 0) {
- quads[q].fAAFlags |= GrQuadAAFlags::kLeft;
- }
- if (j == kColCount - 1) {
- quads[q].fAAFlags |= GrQuadAAFlags::kRight;
- }
- }
- }
-
- // Make a shared gradient paint
- static constexpr SkPoint pts[] = { {0.f, 0.f}, {0.25f * kTileWidth, 0.25f * kTileHeight} };
- static constexpr SkColor colors[] = { SK_ColorBLUE, SK_ColorWHITE };
-
- auto gradient = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kMirror_TileMode);
- SkPaint paint;
- paint.setShader(gradient);
- GrPaint grPaint;
- SkPaintToGrPaint(rtc->surfPriv().getContext(), rtc->colorSpaceInfo(), paint, view, &grPaint);
- // And use private API to use GrFillRectOp
- rtc->drawQuadSet(GrNoClip(), std::move(grPaint), GrAA::kYes, view, quads, SK_ARRAY_COUNT(quads));
-}
-
-static void draw_color_tiles(GrRenderTargetContext* rtc, const SkMatrix& view, bool multicolor) {
- GrRenderTargetContext::QuadSetEntry quads[kRowCount * kColCount];
-
- for (int i = 0; i < kRowCount; ++i) {
- for (int j = 0; j < kColCount; ++j) {
- SkRect tile = SkRect::MakeXYWH(j * kTileWidth, i * kTileHeight, kTileWidth, kTileHeight);
-
- int q = i * kColCount + j;
- quads[q].fRect = tile;
- quads[q].fLocalMatrix.setIdentity();
-
- if (multicolor) {
- quads[q].fColor = {(i + 1.f) / kRowCount, (j + 1.f) / kColCount, .4f, 1.f};
- } else {
- quads[q].fColor = {.2f, .8f, .3f, 1.f};
- }
-
- quads[q].fAAFlags = GrQuadAAFlags::kNone;
- if (i == 0) {
- quads[q].fAAFlags |= GrQuadAAFlags::kTop;
- }
- if (i == kRowCount - 1) {
- quads[q].fAAFlags |= GrQuadAAFlags::kBottom;
- }
- if (j == 0) {
- quads[q].fAAFlags |= GrQuadAAFlags::kLeft;
- }
- if (j == kColCount - 1) {
- quads[q].fAAFlags |= GrQuadAAFlags::kRight;
- }
- }
- }
-
- GrPaint grPaint;
- // And use private API to use GrFillRectOp
- rtc->drawQuadSet(GrNoClip(), std::move(grPaint), GrAA::kYes, view, quads, SK_ARRAY_COUNT(quads));
-}
-
-static void draw_tile_boundaries(SkCanvas* canvas, const SkMatrix& local) {
- // Draw grid of red lines at interior tile boundaries.
- static constexpr SkScalar kLineOutset = 10.f;
- SkPaint paint;
- paint.setAntiAlias(true);
- paint.setColor(SK_ColorRED);
- paint.setStyle(SkPaint::kStroke_Style);
- paint.setStrokeWidth(0.f);
- for (int x = 1; x < kColCount; ++x) {
- SkPoint pts[] = {{x * kTileWidth, 0}, {x * kTileWidth, kRowCount * kTileHeight}};
- local.mapPoints(pts, 2);
- SkVector v = pts[1] - pts[0];
- v.setLength(v.length() + kLineOutset);
- canvas->drawLine(pts[1] - v, pts[0] + v, paint);
- }
- for (int y = 1; y < kRowCount; ++y) {
- SkPoint pts[] = {{0, y * kTileHeight}, {kTileWidth * kColCount, y * kTileHeight}};
- local.mapPoints(pts, 2);
- SkVector v = pts[1] - pts[0];
- v.setLength(v.length() + kLineOutset);
- canvas->drawLine(pts[1] - v, pts[0] + v, paint);
- }
-}
-
-// Tile renderers (column variation)
-typedef void (*TileRenderer)(GrRenderTargetContext*, const SkMatrix&);
-static TileRenderer kTileSets[] = {
- [](GrRenderTargetContext* rtc, const SkMatrix& view) { draw_gradient_tiles(rtc, view, true); },
- [](GrRenderTargetContext* rtc, const SkMatrix& view) { draw_gradient_tiles(rtc, view, false); },
- [](GrRenderTargetContext* rtc, const SkMatrix& view) { draw_color_tiles(rtc, view, false); },
- [](GrRenderTargetContext* rtc, const SkMatrix& view) { draw_color_tiles(rtc, view, true); },
-};
-static const char* kTileSetNames[] = { "Local", "Aligned", "Green", "Multicolor" };
-static_assert(SK_ARRAY_COUNT(kTileSets) == SK_ARRAY_COUNT(kTileSetNames), "Count mismatch");
-
-namespace skiagm {
-
-class DrawQuadSetGM : public GM {
-private:
- SkString onShortName() final { return SkString("draw_quad_set"); }
- SkISize onISize() override { return SkISize::Make(800, 800); }
-
- void onDraw(SkCanvas* canvas) override {
- GrContext* ctx = canvas->getGrContext();
- if (!ctx) {
- DrawGpuOnlyMessage(canvas);
- return;
- }
- GrRenderTargetContext* rtc = canvas->internal_private_accessTopLayerRenderTargetContext();
- SkASSERT(rtc);
-
- SkMatrix rowMatrices[5];
- // Identity
- rowMatrices[0].setIdentity();
- // Translate/scale
- rowMatrices[1].setTranslate(5.5f, 20.25f);
- rowMatrices[1].postScale(.9f, .7f);
- // Rotation
- rowMatrices[2].setRotate(20.0f);
- rowMatrices[2].preTranslate(15.f, -20.f);
- // Skew
- rowMatrices[3].setSkew(.5f, .25f);
- rowMatrices[3].preTranslate(-30.f, 0.f);
- // Perspective
- SkPoint src[4];
- SkRect::MakeWH(kColCount * kTileWidth, kRowCount * kTileHeight).toQuad(src);
- SkPoint dst[4] = {{0, 0},
- {kColCount * kTileWidth + 10.f, 15.f},
- {kColCount * kTileWidth - 28.f, kRowCount * kTileHeight + 40.f},
- {25.f, kRowCount * kTileHeight - 15.f}};
- SkAssertResult(rowMatrices[4].setPolyToPoly(src, dst, 4));
- rowMatrices[4].preTranslate(0.f, +10.f);
- static const char* matrixNames[] = { "Identity", "T+S", "Rotate", "Skew", "Perspective" };
- static_assert(SK_ARRAY_COUNT(matrixNames) == SK_ARRAY_COUNT(rowMatrices), "Count mismatch");
-
- // Print a column header
- canvas->save();
- canvas->translate(110.f, 20.f);
- for (size_t j = 0; j < SK_ARRAY_COUNT(kTileSetNames); ++j) {
- draw_text(canvas, kTileSetNames[j]);
- canvas->translate(kColCount * kTileWidth + 30.f, 0.f);
- }
- canvas->restore();
- canvas->translate(0.f, 40.f);
-
- // Render all tile variations
- for (size_t i = 0; i < SK_ARRAY_COUNT(rowMatrices); ++i) {
- canvas->save();
- canvas->translate(10.f, 0.5f * kRowCount * kTileHeight);
- draw_text(canvas, matrixNames[i]);
-
- canvas->translate(100.f, -0.5f * kRowCount * kTileHeight);
- for (size_t j = 0; j < SK_ARRAY_COUNT(kTileSets); ++j) {
- canvas->save();
- draw_tile_boundaries(canvas, rowMatrices[i]);
-
- canvas->concat(rowMatrices[i]);
- kTileSets[j](rtc, canvas->getTotalMatrix());
- // Undo the local transformation
- canvas->restore();
- // And advance to the next column
- canvas->translate(kColCount * kTileWidth + 30.f, 0.f);
- }
- // Reset back to the left edge
- canvas->restore();
- // And advance to the next row
- canvas->translate(0.f, kRowCount * kTileHeight + 20.f);
- }
- }
-};
-
-DEF_GM(return new DrawQuadSetGM();)
-
-} // namespace skiagm
diff --git a/gn/gm.gni b/gn/gm.gni
index 739090f..beeff4c 100644
--- a/gn/gm.gni
+++ b/gn/gm.gni
@@ -123,7 +123,6 @@
"$_gm/drawlooper.cpp",
"$_gm/drawimageset.cpp",
"$_gm/drawminibitmaprect.cpp",
- "$_gm/drawquadset.cpp",
"$_gm/drawregion.cpp",
"$_gm/drawregionmodes.cpp",
"$_gm/dropshadowimagefilter.cpp",
diff --git a/gn/gpu.gni b/gn/gpu.gni
index a8a5bb16..651fd16 100644
--- a/gn/gpu.gni
+++ b/gn/gpu.gni
@@ -262,8 +262,6 @@
"$_src/gpu/ops/GrDrawOp.h",
"$_src/gpu/ops/GrDrawVerticesOp.cpp",
"$_src/gpu/ops/GrDrawVerticesOp.h",
- "$_src/gpu/ops/GrFillRectOp.cpp",
- "$_src/gpu/ops/GrFillRectOp.h",
"$_src/gpu/ops/GrMeshDrawOp.cpp",
"$_src/gpu/ops/GrMeshDrawOp.h",
"$_src/gpu/ops/GrNonAAFillRectOp.cpp",
diff --git a/src/gpu/GrProcessor.h b/src/gpu/GrProcessor.h
index b8338b3..de3925d 100644
--- a/src/gpu/GrProcessor.h
+++ b/src/gpu/GrProcessor.h
@@ -155,7 +155,6 @@
kPorterDuffXferProcessor_ClassID,
kPremulFragmentProcessor_ClassID,
kQuadEdgeEffect_ClassID,
- kQuadPerEdgeAAGeometryProcessor_ClassID,
kReplaceInputFragmentProcessor_ClassID,
kRRectsGaussianEdgeFP_ClassID,
kSeriesFragmentProcessor_ClassID,
diff --git a/src/gpu/GrQuad.cpp b/src/gpu/GrQuad.cpp
index 567301d..cce49f1 100644
--- a/src/gpu/GrQuad.cpp
+++ b/src/gpu/GrQuad.cpp
@@ -19,21 +19,7 @@
// Allow some tolerance from floating point matrix transformations, but SkScalarNearlyEqual doesn't
// support comparing infinity, and coords_form_rect should return true for infinite edges
#define NEARLY_EQUAL(f1, f2) (f1 == f2 || SkScalarNearlyEqual(f1, f2, 1e-5f))
-// Similarly, support infinite rectangles by looking at the sign of infinities
-static bool dot_nearly_zero(const SkVector& e1, const SkVector& e2) {
- static constexpr auto dot = SkPoint::DotProduct;
- static constexpr auto sign = SkScalarSignAsScalar;
-
- SkScalar dotValue = dot(e1, e2);
- if (SkScalarIsNaN(dotValue)) {
- // Form vectors from the signs of infinities, and check their dot product
- dotValue = dot({sign(e1.fX), sign(e1.fY)}, {sign(e2.fX), sign(e2.fY)});
- }
-
- // Unfortunately must have a pretty healthy tolerance here or transformed rects that are
- // effectively rectilinear will have edge dot products of around .005
- return SkScalarNearlyZero(dotValue, 1e-2f);
-}
+#define NEARLY_ZERO(f1) NEARLY_EQUAL(f1, 0.f)
// This is not the most performance critical function; code using GrQuad should rely on the faster
// quad type from matrix path, so this will only be called as part of SkASSERT.
@@ -45,13 +31,18 @@
}
static bool coords_rectilinear(const float xs[4], const float ys[4]) {
+ // Edge from 0 to 1 should have the same length as edge from 3 to 2
+ // and edge from 1 to 3 should have the same length as edge from 2 to 0
+ // noo that makes it a parallelogram, need dot product between edge 0 to 1 and edge 1 to 3 = 0
+ // and 0-2 and 2-3 is 0.
+ static constexpr auto dot = SkPoint::DotProduct;
SkVector e0{xs[1] - xs[0], ys[1] - ys[0]}; // Connects to e1 and e2(repeat)
SkVector e1{xs[3] - xs[1], ys[3] - ys[1]}; // connects to e0(repeat) and e3
SkVector e2{xs[0] - xs[2], ys[0] - ys[2]}; // connects to e0 and e3(repeat)
SkVector e3{xs[2] - xs[3], ys[2] - ys[3]}; // connects to e1(repeat) and e2
- return dot_nearly_zero(e0, e1) && dot_nearly_zero(e1, e3) &&
- dot_nearly_zero(e2, e0) && dot_nearly_zero(e3, e2);
+ return NEARLY_ZERO(dot(e0, e1)) && NEARLY_ZERO(dot(e1, e3)) &&
+ NEARLY_ZERO(dot(e2, e0)) && NEARLY_ZERO(dot(e3, e2));
}
GrQuadType GrQuad::quadType() const {
diff --git a/src/gpu/GrRenderTargetContext.cpp b/src/gpu/GrRenderTargetContext.cpp
index bdcfd4e..33c470a 100644
--- a/src/gpu/GrRenderTargetContext.cpp
+++ b/src/gpu/GrRenderTargetContext.cpp
@@ -44,7 +44,6 @@
#include "ops/GrDrawAtlasOp.h"
#include "ops/GrDrawOp.h"
#include "ops/GrDrawVerticesOp.h"
-#include "ops/GrFillRectOp.h"
#include "ops/GrAAFillRRectOp.h"
#include "ops/GrLatticeOp.h"
#include "ops/GrOp.h"
@@ -639,14 +638,6 @@
this->drawShapeUsingPathRenderer(clip, std::move(paint), aa, viewMatrix, GrShape(rect, *style));
}
-void GrRenderTargetContext::drawQuadSet(const GrClip& clip, GrPaint&& paint, GrAA aa,
- const SkMatrix& viewMatrix, const QuadSetEntry quads[],
- int cnt) {
- GrAAType aaType = this->chooseAAType(aa, GrAllowMixedSamples::kNo);
- this->addDrawOp(clip, GrFillRectOp::MakeSet(fContext, std::move(paint), aaType, viewMatrix,
- quads, cnt));
-}
-
int GrRenderTargetContextPriv::maxWindowRectangles() const {
return fRenderTargetContext->fRenderTargetProxy->maxWindowRectangles(
*fRenderTargetContext->caps());
diff --git a/src/gpu/GrRenderTargetContext.h b/src/gpu/GrRenderTargetContext.h
index 4c73746..b4114f7 100644
--- a/src/gpu/GrRenderTargetContext.h
+++ b/src/gpu/GrRenderTargetContext.h
@@ -127,17 +127,6 @@
const SkRect& rect,
const SkMatrix& localMatrix);
- /** Used with drawQuadSet */
- struct QuadSetEntry {
- SkRect fRect;
- SkPMColor4f fColor; // Overrides any color on the GrPaint
- SkMatrix fLocalMatrix;
- GrQuadAAFlags fAAFlags;
- };
-
- void drawQuadSet(const GrClip& clip, GrPaint&& paint, GrAA aa, const SkMatrix& viewMatrix,
- const QuadSetEntry[], int cnt);
-
/**
* Creates an op that draws a subrectangle of a texture. The passed color is modulated by the
* texture's color. 'srcRect' specifies the rectangle of the texture to draw. 'dstRect'
diff --git a/src/gpu/ops/GrFillRectOp.cpp b/src/gpu/ops/GrFillRectOp.cpp
deleted file mode 100644
index 475d0d1..0000000
--- a/src/gpu/ops/GrFillRectOp.cpp
+++ /dev/null
@@ -1,545 +0,0 @@
-/*
- * Copyright 2018 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include "GrFillRectOp.h"
-
-#include "GrGeometryProcessor.h"
-#include "GrMeshDrawOp.h"
-#include "GrPaint.h"
-#include "GrQuad.h"
-#include "GrQuadPerEdgeAA.h"
-#include "GrSimpleMeshDrawOpHelper.h"
-#include "SkMatrix.h"
-#include "SkRect.h"
-#include "glsl/GrGLSLColorSpaceXformHelper.h"
-#include "glsl/GrGLSLGeometryProcessor.h"
-#include "glsl/GrGLSLVarying.h"
-
-namespace {
-
-using VertexSpec = GrQuadPerEdgeAA::VertexSpec;
-using ColorType = GrQuadPerEdgeAA::ColorType;
-
-// NOTE: This info structure is intentionally modeled after GrTextureOps' Quad so that they can
-// more easily be integrated together in the future.
-class TransformedQuad {
-public:
- TransformedQuad(const GrPerspQuad& deviceQuad, const GrPerspQuad& localQuad,
- const SkPMColor4f& color, GrQuadAAFlags aaFlags)
- : fDeviceQuad(deviceQuad)
- , fLocalQuad(localQuad)
- , fColor(color)
- , fAAFlags(aaFlags) {}
-
- const GrPerspQuad& deviceQuad() const { return fDeviceQuad; }
- const GrPerspQuad& localQuad() const { return fLocalQuad; }
- const SkPMColor4f& color() const { return fColor; }
- GrQuadAAFlags aaFlags() const { return fAAFlags; }
-
- void setColor(const SkPMColor4f& color) { fColor = color; }
-
- SkString dumpInfo(int index) const {
- GrQuadAAFlags edges = static_cast<GrQuadAAFlags>(fAAFlags);
- SkString str;
- str.appendf("%d: Color: [%.2f, %.2f, %.2f, %.2f], Edge AA: l%u_t%u_r%u_b%u, \n"
- " device quad: [(%.2f, %2.f, %.2f), (%.2f, %.2f, %.2f), (%.2f, %.2f, %.2f), "
- "(%.2f, %.2f, %.2f)],\n"
- " local quad: [(%.2f, %2.f, %.2f), (%.2f, %.2f, %.2f), (%.2f, %.2f, %.2f), "
- "(%.2f, %.2f, %.2f)]\n",
- index, fColor.fR, fColor.fG, fColor.fB, fColor.fA,
- edges & GrQuadAAFlags::kLeft, edges & GrQuadAAFlags::kTop,
- edges & GrQuadAAFlags::kRight, edges & GrQuadAAFlags::kBottom,
- fDeviceQuad.x(0), fDeviceQuad.y(0), fDeviceQuad.w(0),
- fDeviceQuad.x(1), fDeviceQuad.y(1), fDeviceQuad.w(1),
- fDeviceQuad.x(2), fDeviceQuad.y(2), fDeviceQuad.w(2),
- fDeviceQuad.x(3), fDeviceQuad.y(3), fDeviceQuad.w(3),
- fLocalQuad.x(0), fLocalQuad.y(0), fLocalQuad.w(0),
- fLocalQuad.x(1), fLocalQuad.y(1), fLocalQuad.w(1),
- fLocalQuad.x(2), fLocalQuad.y(2), fLocalQuad.w(2),
- fLocalQuad.x(3), fLocalQuad.y(3), fLocalQuad.w(3));
- return str;
- }
-private:
- // NOTE: The TransformedQuad does not store the types for device and local. The owning op tracks
- // the most general type for device and local across all of its merged quads.
- GrPerspQuad fDeviceQuad; // In device space, allowing rects to be combined across view matrices
- GrPerspQuad fLocalQuad; // Original rect transformed by its local matrix
- SkPMColor4f fColor;
- GrQuadAAFlags fAAFlags;
-};
-
-// A GeometryProcessor for rendering TransformedQuads using the vertex attributes from
-// GrQuadPerEdgeAA. This is similar to the TextureGeometryProcessor of GrTextureOp except that it
-// handles full GrPaints.
-class QuadPerEdgeAAGeometryProcessor : public GrGeometryProcessor {
-public:
-
- static sk_sp<GrGeometryProcessor> Make(const VertexSpec& spec) {
- return sk_sp<QuadPerEdgeAAGeometryProcessor>(new QuadPerEdgeAAGeometryProcessor(spec));
- }
-
- const char* name() const override { return "QuadPerEdgeAAGeometryProcessor"; }
-
- void getGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder* b) const override {
- // The attributes' key includes the device and local quad types implicitly since those
- // types decide the vertex attribute size
- b->add32(fAttrs.getKey());
- }
-
- GrGLSLPrimitiveProcessor* createGLSLInstance(const GrShaderCaps& caps) const override {
- class GLSLProcessor : public GrGLSLGeometryProcessor {
- public:
- void setData(const GrGLSLProgramDataManager& pdman, const GrPrimitiveProcessor& proc,
- FPCoordTransformIter&& transformIter) override {
- const auto& gp = proc.cast<QuadPerEdgeAAGeometryProcessor>();
- if (gp.fAttrs.hasLocalCoords()) {
- this->setTransformDataHelper(SkMatrix::I(), pdman, &transformIter);
- }
- }
-
- private:
- void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override {
- const auto& gp = args.fGP.cast<QuadPerEdgeAAGeometryProcessor>();
- args.fVaryingHandler->emitAttributes(gp);
- gpArgs->fPositionVar = gp.fAttrs.positions().asShaderVar();
-
- if (gp.fAttrs.hasLocalCoords()) {
- this->emitTransforms(args.fVertBuilder,
- args.fVaryingHandler,
- args.fUniformHandler,
- gp.fAttrs.localCoords().asShaderVar(),
- args.fFPCoordTransformHandler);
- }
-
- gp.fAttrs.emitColor(args, "paintColor");
- gp.fAttrs.emitCoverage(args, "aaDist");
- }
- };
- return new GLSLProcessor;
- }
-
-private:
- QuadPerEdgeAAGeometryProcessor(const VertexSpec& spec)
- : INHERITED(kQuadPerEdgeAAGeometryProcessor_ClassID)
- , fAttrs(spec) {
- SkASSERT(spec.hasVertexColors());
- this->setVertexAttributes(fAttrs.attributes(), fAttrs.attributeCount());
- }
-
- GrQuadPerEdgeAA::GPAttributes fAttrs;
-
- typedef GrGeometryProcessor INHERITED;
-};
-
-class FillRectOp final : public GrMeshDrawOp {
-private:
- using Helper = GrSimpleMeshDrawOpHelperWithStencil;
-
-public:
- static std::unique_ptr<GrDrawOp> Make(GrContext* context,
- GrPaint&& paint,
- GrAAType aaType,
- GrQuadAAFlags edgeAA,
- const GrUserStencilSettings* stencilSettings,
- const GrPerspQuad& deviceQuad,
- GrQuadType deviceQuadType,
- const GrPerspQuad& localQuad,
- GrQuadType localQuadType) {
- // Clean up deviations between aaType and edgeAA
- GrResolveAATypeForQuad(aaType, edgeAA, deviceQuad, deviceQuadType, &aaType, &edgeAA);
-
- // Analyze the paint to see if it is compatible with scissor-clearing
- SkPMColor4f color = paint.getColor4f();
- // Only non-null if the paint can be turned into a clear, it can be a local pointer since
- // the op ctor consumes the value right away if it's provided
- SkPMColor4f* clearColor = nullptr;
- if (paint.isTrivial() || paint.isConstantBlendedColor(&color)) {
- clearColor = &color;
- }
-
- return Helper::FactoryHelper<FillRectOp>(context, std::move(paint), clearColor, aaType,
- edgeAA, stencilSettings, deviceQuad, deviceQuadType, localQuad, localQuadType);
- }
-
- // Analysis of the GrPaint to determine the const blend color must be done before, passing
- // nullptr for constBlendColor disables all scissor-clear optimizations (must keep the
- // paintColor argument because it is assumed by the GrSimpleMeshDrawOpHelper). Similarly, aaType
- // is passed to Helper in the initializer list, so incongruities between aaType and edgeFlags
- // must be resolved prior to calling this constructor.
- FillRectOp(Helper::MakeArgs args, SkPMColor4f paintColor, const SkPMColor4f* constBlendColor,
- GrAAType aaType, GrQuadAAFlags edgeFlags, const GrUserStencilSettings* stencil,
- const GrPerspQuad& deviceQuad, GrQuadType deviceQuadType,
- const GrPerspQuad& localQuad, GrQuadType localQuadType)
- : INHERITED(ClassID())
- , fHelper(args, aaType, stencil)
- , fDeviceQuadType(static_cast<unsigned>(deviceQuadType))
- , fLocalQuadType(static_cast<unsigned>(localQuadType)) {
- if (constBlendColor) {
- // The GrPaint is compatible with clearing, and the constant blend color overrides the
- // paint color (although in most cases they are probably the same)
- paintColor = *constBlendColor;
- // However, just because the paint is compatible, the device quad must also be a rect
- // that is non-AA (AA aligned with pixel bounds should have already been turned into
- // non-AA).
- fClearCompatible = deviceQuadType == GrQuadType::kRect && aaType == GrAAType::kNone;
- } else {
- // Paint isn't clear compatible
- fClearCompatible = false;
- }
-
- fWideColor = !SkPMColor4fFitsInBytes(paintColor);
-
- // The color stored with the quad is the clear color if a scissor-clear is decided upon
- // when executing the op.
- fQuads.emplace_back(deviceQuad, localQuad, paintColor, edgeFlags);
- this->setBounds(deviceQuad.bounds(), HasAABloat(aaType == GrAAType::kCoverage),
- IsZeroArea::kNo);
- }
-
- const char* name() const override { return "FillRectOp"; }
-
- void visitProxies(const VisitProxyFunc& func, VisitorType) const override {
- return fHelper.visitProxies(func);
- }
-
-#ifdef SK_DEBUG
- SkString dumpInfo() const override {
- SkString str;
- str.appendf("# draws: %d\n", fQuads.count());
- str.appendf("Clear compatible: %u\n", static_cast<bool>(fClearCompatible));
- str.appendf("Device quad type: %u, local quad type: %u\n",
- static_cast<GrQuadType>(fDeviceQuadType),
- static_cast<GrQuadType>(fLocalQuadType));
- str += fHelper.dumpInfo();
- for (int i = 0; i < fQuads.count(); i++) {
- str += fQuads[i].dumpInfo(i);
-
- }
- str += INHERITED::dumpInfo();
- return str;
- }
-#endif
-
- RequiresDstTexture finalize(const GrCaps& caps, const GrAppliedClip* clip) override {
- // Initialize aggregate color analysis with the first quad's color (which always exists)
- SkASSERT(fQuads.count() > 0);
- GrProcessorAnalysisColor quadColors(fQuads[0].color());
- // Then combine the colors of any additional quads (e.g. from MakeSet)
- for (int i = 1; i < fQuads.count(); ++i) {
- quadColors = GrProcessorAnalysisColor::Combine(quadColors, fQuads[i].color());
- }
- auto result = fHelper.xpRequiresDstTexture(
- caps, clip, GrProcessorAnalysisCoverage::kSingleChannel, &quadColors);
- // If there is a constant color after analysis, that means all of the quads should be set
- // to the same color (even if they started out with different colors).
- SkPMColor4f colorOverride;
- if (quadColors.isConstant(&colorOverride)) {
- for (int i = 0; i < fQuads.count(); ++i) {
- fQuads[i].setColor(colorOverride);
- }
- }
-
- return result;
- }
-
- FixedFunctionFlags fixedFunctionFlags() const override {
- // Since the AA type of the whole primitive is kept consistent with the per edge AA flags
- // the helper's fixed function flags are appropriate.
- return fHelper.fixedFunctionFlags();
- }
-
- DEFINE_OP_CLASS_ID
-
-private:
- // For GrFillRectOp::MakeSet's use of addQuad
- // FIXME(reviewer): better to just make addQuad public?
- friend std::unique_ptr<GrDrawOp> GrFillRectOp::MakeSet(GrContext* context, GrPaint&& paint,
- GrAAType aaType, const SkMatrix& viewMatrix,
- const GrRenderTargetContext::QuadSetEntry quads[], int quadCount,
- const GrUserStencilSettings* stencilSettings);
-
- void onPrepareDraws(Target* target) override {
- TRACE_EVENT0("skia", TRACE_FUNC);
-
- using Domain = GrQuadPerEdgeAA::Domain;
- static constexpr SkRect kEmptyDomain = SkRect::MakeEmpty();
-
- VertexSpec vertexSpec(this->deviceQuadType(),
- fWideColor ? ColorType::kHalf : ColorType::kByte,
- this->localQuadType(), fHelper.usesLocalCoords(), Domain::kNo,
- fHelper.aaType());
-
- sk_sp<GrGeometryProcessor> gp = QuadPerEdgeAAGeometryProcessor::Make(vertexSpec);
- size_t vertexSize = gp->vertexStride();
-
- const GrBuffer* vbuffer;
- int vertexOffsetInBuffer = 0;
-
- // Fill the allocated vertex data
- void* vdata = target->makeVertexSpace(vertexSize, fQuads.count() * 4, &vbuffer,
- &vertexOffsetInBuffer);
- if (!vdata) {
- SkDebugf("Could not allocate vertices\n");
- return;
- }
-
- // vertices pointer advances through vdata based on Tessellate's return value
- void* vertices = vdata;
- for (int i = 0; i < fQuads.count(); ++i) {
- const auto& q = fQuads[i];
- vertices = GrQuadPerEdgeAA::Tessellate(vertices, vertexSpec, q.deviceQuad(), q.color(),
- q.localQuad(), kEmptyDomain, q.aaFlags());
- }
-
- // Configure the mesh for the vertex data
- GrMesh* mesh;
- if (fQuads.count() > 1) {
- mesh = target->allocMesh(GrPrimitiveType::kTriangles);
- sk_sp<const GrBuffer> ibuffer = target->resourceProvider()->refQuadIndexBuffer();
- if (!ibuffer) {
- SkDebugf("Could not allocate quad indices\n");
- return;
- }
- mesh->setIndexedPatterned(ibuffer.get(), 6, 4, fQuads.count(),
- GrResourceProvider::QuadCountOfQuadBuffer());
- } else {
- mesh = target->allocMesh(GrPrimitiveType::kTriangleStrip);
- mesh->setNonIndexedNonInstanced(4);
- }
- mesh->setVertexData(vbuffer, vertexOffsetInBuffer);
-
- auto pipe = fHelper.makePipeline(target);
- target->draw(std::move(gp), pipe.fPipeline, pipe.fFixedDynamicState, mesh);
- }
-
- CombineResult onCombineIfPossible(GrOp* t, const GrCaps& caps) override {
- TRACE_EVENT0("skia", TRACE_FUNC);
- const auto* that = t->cast<FillRectOp>();
-
- // Unlike most users of the draw op helper, this op can merge none-aa and coverage-aa
- // draw ops together, so pass true as the last argument.
- if (!fHelper.isCompatible(that->fHelper, caps, this->bounds(), that->bounds(), true)) {
- return CombineResult::kCannotCombine;
- }
-
- // If the processor sets are compatible, the two ops are always compatible; it just needs
- // to adjust the state of the op to be the more general quad and aa types of the two ops.
-
- // The GrQuadType enum is ordered such that higher values are more general quad types
- if (that->fDeviceQuadType > fDeviceQuadType) {
- fDeviceQuadType = that->fDeviceQuadType;
- }
- if (that->fLocalQuadType > fLocalQuadType) {
- fLocalQuadType = that->fLocalQuadType;
- }
- fClearCompatible &= that->fClearCompatible;
- fWideColor |= that->fWideColor;
-
- // The helper stores the aa type, but isCompatible(with true arg) allows the two ops' aa
- // types to be none and coverage, in which case this op's aa type must be lifted to coverage
- // so that quads with no aa edges can be batched with quads that have some/all edges aa'ed.
- if (fHelper.aaType() == GrAAType::kNone && that->fHelper.aaType() == GrAAType::kCoverage) {
- fHelper.setAAType(GrAAType::kCoverage);
- }
-
- fQuads.push_back_n(that->fQuads.count(), that->fQuads.begin());
- return CombineResult::kMerged;
- }
-
- // Similar to onCombineIfPossible, but adds a quad assuming its op would have been compatible.
- // But since it's avoiding the op list management, it must update the op's bounds. This is only
- // used with quad sets, which uses the same view matrix for each quad so this assumes that the
- // device quad type of the new quad is the same as the op's.
- void addQuad(TransformedQuad&& quad, GrQuadType localQuadType, GrAAType aaType) {
- SkASSERT(quad.deviceQuad().quadType() <= this->deviceQuadType());
-
- // The new quad's aa type should be the same, or converted to none, which means this op's
- // helper's aatype never has to be updated
- SkASSERT(aaType == fHelper.aaType() || aaType == GrAAType::kNone);
-
- // The new quad's local coordinates could differ
- if (localQuadType > this->localQuadType()) {
- fLocalQuadType = static_cast<unsigned>(localQuadType);
- }
-
- // clear compatible won't need to be updated, since device quad type and paint is the same,
- // but this quad has a new color, so maybe update wide color
- fWideColor |= !SkPMColor4fFitsInBytes(quad.color());
-
- // Update the bounds and add the quad to this op's storage
- SkRect newBounds = this->bounds();
- newBounds.joinPossiblyEmptyRect(quad.deviceQuad().bounds());
- this->setBounds(newBounds, HasAABloat(fHelper.aaType() == GrAAType::kCoverage),
- IsZeroArea::kNo);
- fQuads.push_back(std::move(quad));
- }
-
- GrQuadType deviceQuadType() const { return static_cast<GrQuadType>(fDeviceQuadType); }
- GrQuadType localQuadType() const { return static_cast<GrQuadType>(fLocalQuadType); }
-
- Helper fHelper;
- SkSTArray<1, TransformedQuad, true> fQuads;
-
- // While we always store full GrPerspQuads in memory, if the type is known to be simpler we can
- // optimize our geometry generation.
- unsigned fDeviceQuadType: 2;
- unsigned fLocalQuadType: 2;
- unsigned fWideColor: 1;
-
- // True if fQuad produced by a rectangle-preserving view matrix, is pixel aligned or non-AA,
- // and its paint is a constant blended color.
- unsigned fClearCompatible: 1;
-
- typedef GrMeshDrawOp INHERITED;
-};
-
-} // anonymous namespace
-
-namespace GrFillRectOp {
-
-std::unique_ptr<GrDrawOp> Make(GrContext* context,
- GrPaint&& paint,
- GrAAType aaType,
- GrQuadAAFlags edgeAA,
- const SkMatrix& viewMatrix,
- const SkRect& rect,
- const GrUserStencilSettings* stencilSettings) {
- return FillRectOp::Make(context, std::move(paint), aaType, edgeAA, stencilSettings,
- GrPerspQuad(rect, viewMatrix), GrQuadTypeForTransformedRect(viewMatrix),
- GrPerspQuad(rect, SkMatrix::I()), GrQuadType::kRect);
-}
-
-std::unique_ptr<GrDrawOp> MakeWithLocalMatrix(GrContext* context,
- GrPaint&& paint,
- GrAAType aaType,
- GrQuadAAFlags edgeAA,
- const SkMatrix& viewMatrix,
- const SkMatrix& localMatrix,
- const SkRect& rect,
- const GrUserStencilSettings* stencilSettings) {
- GrQuadType localQuadType = GrQuadTypeForTransformedRect(localMatrix);
- return FillRectOp::Make(context, std::move(paint), aaType, edgeAA, stencilSettings,
- GrPerspQuad(rect, viewMatrix), GrQuadTypeForTransformedRect(viewMatrix),
- GrPerspQuad(rect, localMatrix), localQuadType);
-}
-
-std::unique_ptr<GrDrawOp> MakeWithLocalRect(GrContext* context,
- GrPaint&& paint,
- GrAAType aaType,
- GrQuadAAFlags edgeAA,
- const SkMatrix& viewMatrix,
- const SkRect& rect,
- const SkRect& localRect,
- const GrUserStencilSettings* stencilSettings) {
- return FillRectOp::Make(context, std::move(paint), aaType, edgeAA, stencilSettings,
- GrPerspQuad(rect, viewMatrix), GrQuadTypeForTransformedRect(viewMatrix),
- GrPerspQuad(localRect, SkMatrix::I()), GrQuadType::kRect);
-}
-
-std::unique_ptr<GrDrawOp> MakeSet(GrContext* context,
- GrPaint&& paint,
- GrAAType aaType,
- const SkMatrix& viewMatrix,
- const GrRenderTargetContext::QuadSetEntry quads[],
- int cnt,
- const GrUserStencilSettings* stencilSettings) {
- // First make a draw op for the first quad in the set
- SkASSERT(cnt > 0);
- GrQuadType deviceQuadType = GrQuadTypeForTransformedRect(viewMatrix);
-
- paint.setColor4f(quads[0].fColor);
- std::unique_ptr<GrDrawOp> op = FillRectOp::Make(context, std::move(paint), aaType,
- quads[0].fAAFlags, stencilSettings, GrPerspQuad(quads[0].fRect, viewMatrix),
- deviceQuadType, GrPerspQuad(quads[0].fRect, quads[0].fLocalMatrix),
- GrQuadTypeForTransformedRect(quads[0].fLocalMatrix));
- auto* fillRects = op->cast<FillRectOp>();
-
- // Accumulate remaining quads similar to onCombineIfPossible() without creating an op
- for (int i = 1; i < cnt; ++i) {
- GrPerspQuad deviceQuad(quads[i].fRect, viewMatrix);
-
- GrAAType resolvedAA;
- GrQuadAAFlags resolvedEdgeFlags;
- GrResolveAATypeForQuad(aaType, quads[i].fAAFlags, deviceQuad, deviceQuadType,
- &resolvedAA, &resolvedEdgeFlags);
-
- fillRects->addQuad({ deviceQuad, GrPerspQuad(quads[i].fRect, quads[i].fLocalMatrix),
- quads[i].fColor, resolvedEdgeFlags },
- GrQuadTypeForTransformedRect(quads[i].fLocalMatrix), resolvedAA);
- }
-
- return op;
-}
-
-} // namespace GrFillRectOp
-
-#if GR_TEST_UTILS
-
-#include "GrDrawOpTest.h"
-#include "SkGr.h"
-
-GR_DRAW_OP_TEST_DEFINE(FillRectOp) {
- SkMatrix viewMatrix = GrTest::TestMatrixInvertible(random);
- SkRect rect = GrTest::TestRect(random);
-
- GrAAType aaType = GrAAType::kNone;
- if (random->nextBool()) {
- aaType = (fsaaType == GrFSAAType::kUnifiedMSAA) ? GrAAType::kMSAA : GrAAType::kCoverage;
- }
- const GrUserStencilSettings* stencil = random->nextBool() ? nullptr
- : GrGetRandomStencil(random, context);
-
- GrQuadAAFlags aaFlags = GrQuadAAFlags::kNone;
- aaFlags |= random->nextBool() ? GrQuadAAFlags::kLeft : GrQuadAAFlags::kNone;
- aaFlags |= random->nextBool() ? GrQuadAAFlags::kTop : GrQuadAAFlags::kNone;
- aaFlags |= random->nextBool() ? GrQuadAAFlags::kRight : GrQuadAAFlags::kNone;
- aaFlags |= random->nextBool() ? GrQuadAAFlags::kBottom : GrQuadAAFlags::kNone;
-
- if (random->nextBool()) {
- if (random->nextBool()) {
- if (random->nextBool()) {
- // Local matrix with a set op
- uint32_t extraQuadCt = random->nextRangeU(1, 4);
- SkTArray<GrRenderTargetContext::QuadSetEntry> quads(extraQuadCt + 1);
- quads.push_back(
- {rect, SkPMColor4f::FromBytes_RGBA(SkColorToPremulGrColor(random->nextU())),
- GrTest::TestMatrixInvertible(random), aaFlags});
- for (uint32_t i = 0; i < extraQuadCt; ++i) {
- GrQuadAAFlags aaFlags = GrQuadAAFlags::kNone;
- aaFlags |= random->nextBool() ? GrQuadAAFlags::kLeft : GrQuadAAFlags::kNone;
- aaFlags |= random->nextBool() ? GrQuadAAFlags::kTop : GrQuadAAFlags::kNone;
- aaFlags |= random->nextBool() ? GrQuadAAFlags::kRight : GrQuadAAFlags::kNone;
- aaFlags |= random->nextBool() ? GrQuadAAFlags::kBottom : GrQuadAAFlags::kNone;
-
- quads.push_back(
- {GrTest::TestRect(random),
- SkPMColor4f::FromBytes_RGBA(SkColorToPremulGrColor(random->nextU())),
- GrTest::TestMatrixInvertible(random), aaFlags});
- }
-
- return GrFillRectOp::MakeSet(context, std::move(paint), aaType, viewMatrix,
- quads.begin(), quads.count(), stencil);
- } else {
- // Single local matrix
- SkMatrix localMatrix = GrTest::TestMatrixInvertible(random);
- return GrFillRectOp::MakeWithLocalMatrix(context, std::move(paint), aaType, aaFlags,
- viewMatrix, localMatrix, rect, stencil);
- }
- } else {
- // Pass local rect directly
- SkRect localRect = GrTest::TestRect(random);
- return GrFillRectOp::MakeWithLocalRect(context, std::move(paint), aaType, aaFlags,
- viewMatrix, rect, localRect, stencil);
- }
- } else {
- // The simplest constructor
- return GrFillRectOp::Make(context, std::move(paint), aaType, aaFlags, viewMatrix, rect,
- stencil);
- }
-}
-
-#endif
diff --git a/src/gpu/ops/GrFillRectOp.h b/src/gpu/ops/GrFillRectOp.h
deleted file mode 100644
index 8d287bb..0000000
--- a/src/gpu/ops/GrFillRectOp.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright 2018 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef GrFillRectOp_DEFINED
-#define GrFillRectOp_DEFINED
-
-#include "GrRenderTargetContext.h"
-#include "GrTypesPriv.h"
-
-class GrDrawOp;
-class GrPaint;
-struct GrUserStencilSettings;
-class SkMatrix;
-struct SkRect;
-
-namespace GrFillRectOp {
-
-std::unique_ptr<GrDrawOp> Make(GrContext* context,
- GrPaint&& paint,
- GrAAType aaType,
- GrQuadAAFlags edgeAA,
- const SkMatrix& viewMatrix,
- const SkRect& rect,
- const GrUserStencilSettings* stencil = nullptr);
-
-std::unique_ptr<GrDrawOp> MakeWithLocalMatrix(GrContext* context,
- GrPaint&& paint,
- GrAAType aaType,
- GrQuadAAFlags edgeAA,
- const SkMatrix& viewMatrix,
- const SkMatrix& localMatrix,
- const SkRect& rect,
- const GrUserStencilSettings* stencil = nullptr);
-
-std::unique_ptr<GrDrawOp> MakeWithLocalRect(GrContext* context,
- GrPaint&& paint,
- GrAAType aaType,
- GrQuadAAFlags edgeAA,
- const SkMatrix& viewMatrix,
- const SkRect& rect,
- const SkRect& localRect,
- const GrUserStencilSettings* stencil = nullptr);
-
-std::unique_ptr<GrDrawOp> MakeSet(GrContext* context,
- GrPaint&& paint,
- GrAAType aaType,
- const SkMatrix& viewMatrix,
- const GrRenderTargetContext::QuadSetEntry quads[],
- int quadCount,
- const GrUserStencilSettings* stencil = nullptr);
-}
-
-#endif // GrFillRectOp_DEFINED
diff --git a/src/gpu/ops/GrQuadPerEdgeAA.h b/src/gpu/ops/GrQuadPerEdgeAA.h
index cefa2ff..1f3817f 100644
--- a/src/gpu/ops/GrQuadPerEdgeAA.h
+++ b/src/gpu/ops/GrQuadPerEdgeAA.h
@@ -134,6 +134,7 @@
Attribute fAAEdgeDistances; // named "aaEdgeDist" in SkSL
};
+
// Fill vertices with the vertex data needed to represent the given quad. The device position,
// local coords, vertex color, domain, and edge coefficients will be written and/or computed
// based on the configuration in the vertex spec; if that attribute is disabled in the spec,
diff --git a/src/gpu/ops/GrSimpleMeshDrawOpHelper.cpp b/src/gpu/ops/GrSimpleMeshDrawOpHelper.cpp
index f8a7763..928c4ff 100644
--- a/src/gpu/ops/GrSimpleMeshDrawOpHelper.cpp
+++ b/src/gpu/ops/GrSimpleMeshDrawOpHelper.cpp
@@ -40,14 +40,9 @@
: GrDrawOp::FixedFunctionFlags::kNone;
}
-static bool none_as_coverage_aa_compatible(GrAAType aa1, GrAAType aa2) {
- return (aa1 == GrAAType::kNone && aa2 == GrAAType::kCoverage) ||
- (aa1 == GrAAType::kCoverage && aa2 == GrAAType::kNone);
-}
-
bool GrSimpleMeshDrawOpHelper::isCompatible(const GrSimpleMeshDrawOpHelper& that,
const GrCaps& caps, const SkRect& thisBounds,
- const SkRect& thatBounds, bool noneAsCoverageAA) const {
+ const SkRect& thatBounds) const {
if (SkToBool(fProcessors) != SkToBool(that.fProcessors)) {
return false;
}
@@ -62,8 +57,7 @@
}
}
}
- bool result = fPipelineFlags == that.fPipelineFlags && (fAAType == that.fAAType ||
- (noneAsCoverageAA && none_as_coverage_aa_compatible(this->aaType(), that.aaType())));
+ bool result = fPipelineFlags == that.fPipelineFlags && fAAType == that.fAAType;
SkASSERT(!result || fCompatibleWithAlphaAsCoveage == that.fCompatibleWithAlphaAsCoveage);
SkASSERT(!result || fUsesLocalCoords == that.fUsesLocalCoords);
return result;
@@ -184,8 +178,8 @@
bool GrSimpleMeshDrawOpHelperWithStencil::isCompatible(
const GrSimpleMeshDrawOpHelperWithStencil& that, const GrCaps& caps,
- const SkRect& thisBounds, const SkRect& thatBounds, bool noneAsCoverageAA) const {
- return INHERITED::isCompatible(that, caps, thisBounds, thatBounds, noneAsCoverageAA) &&
+ const SkRect& thisBounds, const SkRect& thatBounds) const {
+ return INHERITED::isCompatible(that, caps, thisBounds, thatBounds) &&
fStencilSettings == that.fStencilSettings;
}
diff --git a/src/gpu/ops/GrSimpleMeshDrawOpHelper.h b/src/gpu/ops/GrSimpleMeshDrawOpHelper.h
index 69232e9..b11b7d3 100644
--- a/src/gpu/ops/GrSimpleMeshDrawOpHelper.h
+++ b/src/gpu/ops/GrSimpleMeshDrawOpHelper.h
@@ -53,10 +53,8 @@
GrDrawOp::FixedFunctionFlags fixedFunctionFlags() const;
- // noneAACompatibleWithCoverage should be set to true if the op can properly render a non-AA
- // primitive merged into a coverage-based op.
bool isCompatible(const GrSimpleMeshDrawOpHelper& that, const GrCaps&, const SkRect& thisBounds,
- const SkRect& thatBounds, bool noneAACompatibleWithCoverage = false) const;
+ const SkRect& thatBounds) const;
/**
* Finalizes the processor set and determines whether the destination must be provided
@@ -116,10 +114,6 @@
#endif
GrAAType aaType() const { return static_cast<GrAAType>(fAAType); }
- void setAAType(GrAAType aaType) {
- fAAType = static_cast<unsigned>(aaType);
- }
-
protected:
uint32_t pipelineFlags() const { return fPipelineFlags; }
@@ -171,8 +165,7 @@
using GrSimpleMeshDrawOpHelper::compatibleWithAlphaAsCoverage;
bool isCompatible(const GrSimpleMeshDrawOpHelperWithStencil& that, const GrCaps&,
- const SkRect& thisBounds, const SkRect& thatBounds,
- bool noneAACompatibleWithCoverage = false) const;
+ const SkRect& thisBounds, const SkRect& thatBounds) const;
PipelineAndFixedDynamicState makePipeline(GrMeshDrawOp::Target*,
int numPrimitiveProcessorTextures = 0);
@@ -181,7 +174,6 @@
SkString dumpInfo() const;
#endif
GrAAType aaType() const { return INHERITED::aaType(); }
- void setAAType(GrAAType aaType) { INHERITED::setAAType(aaType); }
private:
const GrUserStencilSettings* fStencilSettings;
diff --git a/tools/gpu/GrTest.cpp b/tools/gpu/GrTest.cpp
index cd44ec9..9cf50b9 100644
--- a/tools/gpu/GrTest.cpp
+++ b/tools/gpu/GrTest.cpp
@@ -299,7 +299,6 @@
DRAW_OP_TEST_EXTERN(DefaultPathOp);
DRAW_OP_TEST_EXTERN(DIEllipseOp);
DRAW_OP_TEST_EXTERN(EllipseOp);
-DRAW_OP_TEST_EXTERN(FillRectOp);
DRAW_OP_TEST_EXTERN(GrAtlasTextOp);
DRAW_OP_TEST_EXTERN(GrDrawAtlasOp);
DRAW_OP_TEST_EXTERN(GrDrawVerticesOp);
@@ -327,7 +326,6 @@
DRAW_OP_TEST_ENTRY(DefaultPathOp),
DRAW_OP_TEST_ENTRY(DIEllipseOp),
DRAW_OP_TEST_ENTRY(EllipseOp),
- DRAW_OP_TEST_ENTRY(FillRectOp),
DRAW_OP_TEST_ENTRY(GrAtlasTextOp),
DRAW_OP_TEST_ENTRY(GrDrawAtlasOp),
DRAW_OP_TEST_ENTRY(GrDrawVerticesOp),