Reland "Initial definition of fill rect op"
This reverts commit1a2476d294. Reason for revert: Fixes printf signatures and asserts. Original change's description: > Revert "Initial definition of fill rect op" > > This reverts commitd3c92d9a36. > > Reason for revert: printf build failure on gcc, assert failures on CQ > > 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> TBR=bsalomon@google.com,csmartdalton@google.com,michaelludwig@google.com Change-Id: I415913a269ba5bcdebd169b5ebc3510673247bfd No-Presubmit: true No-Tree-Checks: true No-Try: true Bug: skia: Reviewed-on: https://skia-review.googlesource.com/c/173234 Commit-Queue: Michael Ludwig <michaelludwig@google.com> Reviewed-by: Michael Ludwig <michaelludwig@google.com>
This commit is contained in:
Michael Ludwig
Skia Commit-Bot
parent
83ea522b4a
commit
6985853f88
230
gm/drawquadset.cpp
Normal file
230
gm/drawquadset.cpp
Normal file
@ -0,0 +1,230 @@
|
||||
/*
|
||||
* 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
|
||||
@ -123,6 +123,7 @@ gm_sources = [
|
||||
"$_gm/drawlooper.cpp",
|
||||
"$_gm/drawimageset.cpp",
|
||||
"$_gm/drawminibitmaprect.cpp",
|
||||
"$_gm/drawquadset.cpp",
|
||||
"$_gm/drawregion.cpp",
|
||||
"$_gm/drawregionmodes.cpp",
|
||||
"$_gm/dropshadowimagefilter.cpp",
|
||||
|
||||
@ -262,6 +262,8 @@ skia_gpu_sources = [
|
||||
"$_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",
|
||||
|
||||
@ -155,6 +155,7 @@ public:
|
||||
kPorterDuffXferProcessor_ClassID,
|
||||
kPremulFragmentProcessor_ClassID,
|
||||
kQuadEdgeEffect_ClassID,
|
||||
kQuadPerEdgeAAGeometryProcessor_ClassID,
|
||||
kReplaceInputFragmentProcessor_ClassID,
|
||||
kRRectsGaussianEdgeFP_ClassID,
|
||||
kSeriesFragmentProcessor_ClassID,
|
||||
|
||||
@ -19,7 +19,21 @@
|
||||
// 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))
|
||||
#define NEARLY_ZERO(f1) NEARLY_EQUAL(f1, 0.f)
|
||||
// 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);
|
||||
}
|
||||
|
||||
// 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.
|
||||
@ -31,18 +45,13 @@ static bool coords_form_rect(const float xs[4], const float ys[4]) {
|
||||
}
|
||||
|
||||
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 NEARLY_ZERO(dot(e0, e1)) && NEARLY_ZERO(dot(e1, e3)) &&
|
||||
NEARLY_ZERO(dot(e2, e0)) && NEARLY_ZERO(dot(e3, e2));
|
||||
return dot_nearly_zero(e0, e1) && dot_nearly_zero(e1, e3) &&
|
||||
dot_nearly_zero(e2, e0) && dot_nearly_zero(e3, e2);
|
||||
}
|
||||
|
||||
GrQuadType GrQuad::quadType() const {
|
||||
|
||||
@ -44,6 +44,7 @@
|
||||
#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"
|
||||
@ -638,6 +639,14 @@ void GrRenderTargetContext::drawRect(const GrClip& clip,
|
||||
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());
|
||||
|
||||
@ -127,6 +127,17 @@ public:
|
||||
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'
|
||||
|
||||
554
src/gpu/ops/GrFillRectOp.cpp
Normal file
554
src/gpu/ops/GrFillRectOp.cpp
Normal file
@ -0,0 +1,554 @@
|
||||
/*
|
||||
* 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 {
|
||||
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,
|
||||
(uint32_t) (fAAFlags & GrQuadAAFlags::kLeft),
|
||||
(uint32_t) (fAAFlags & GrQuadAAFlags::kTop),
|
||||
(uint32_t) (fAAFlags & GrQuadAAFlags::kRight),
|
||||
(uint32_t) (fAAFlags & 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",
|
||||
fDeviceQuadType, 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 as the first quad's or none, except when the
|
||||
// first quad's aa type was already downgraded to none, in which case the stored type must
|
||||
// be lifted to back to the requested type.
|
||||
if (aaType != fHelper.aaType()) {
|
||||
if (aaType != GrAAType::kNone) {
|
||||
// Original quad was downgraded to non-aa, lift back up to this quad's required type
|
||||
SkASSERT(fHelper.aaType() == GrAAType::kNone);
|
||||
fHelper.setAAType(aaType);
|
||||
}
|
||||
// else the new quad could have been downgraded but the other quads can't be, so don't
|
||||
// reset the op's accumulated aa type.
|
||||
}
|
||||
|
||||
// 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
|
||||
57
src/gpu/ops/GrFillRectOp.h
Normal file
57
src/gpu/ops/GrFillRectOp.h
Normal file
@ -0,0 +1,57 @@
|
||||
/*
|
||||
* 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
|
||||
@ -134,7 +134,6 @@ namespace GrQuadPerEdgeAA {
|
||||
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,
|
||||
|
||||
@ -40,9 +40,14 @@ GrDrawOp::FixedFunctionFlags GrSimpleMeshDrawOpHelper::fixedFunctionFlags() cons
|
||||
: 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) const {
|
||||
const SkRect& thatBounds, bool noneAsCoverageAA) const {
|
||||
if (SkToBool(fProcessors) != SkToBool(that.fProcessors)) {
|
||||
return false;
|
||||
}
|
||||
@ -57,7 +62,8 @@ bool GrSimpleMeshDrawOpHelper::isCompatible(const GrSimpleMeshDrawOpHelper& that
|
||||
}
|
||||
}
|
||||
}
|
||||
bool result = fPipelineFlags == that.fPipelineFlags && fAAType == that.fAAType;
|
||||
bool result = fPipelineFlags == that.fPipelineFlags && (fAAType == that.fAAType ||
|
||||
(noneAsCoverageAA && none_as_coverage_aa_compatible(this->aaType(), that.aaType())));
|
||||
SkASSERT(!result || fCompatibleWithAlphaAsCoveage == that.fCompatibleWithAlphaAsCoveage);
|
||||
SkASSERT(!result || fUsesLocalCoords == that.fUsesLocalCoords);
|
||||
return result;
|
||||
@ -178,8 +184,8 @@ GrDrawOp::FixedFunctionFlags GrSimpleMeshDrawOpHelperWithStencil::fixedFunctionF
|
||||
|
||||
bool GrSimpleMeshDrawOpHelperWithStencil::isCompatible(
|
||||
const GrSimpleMeshDrawOpHelperWithStencil& that, const GrCaps& caps,
|
||||
const SkRect& thisBounds, const SkRect& thatBounds) const {
|
||||
return INHERITED::isCompatible(that, caps, thisBounds, thatBounds) &&
|
||||
const SkRect& thisBounds, const SkRect& thatBounds, bool noneAsCoverageAA) const {
|
||||
return INHERITED::isCompatible(that, caps, thisBounds, thatBounds, noneAsCoverageAA) &&
|
||||
fStencilSettings == that.fStencilSettings;
|
||||
}
|
||||
|
||||
|
||||
@ -53,8 +53,10 @@ public:
|
||||
|
||||
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) const;
|
||||
const SkRect& thatBounds, bool noneAACompatibleWithCoverage = false) const;
|
||||
|
||||
/**
|
||||
* Finalizes the processor set and determines whether the destination must be provided
|
||||
@ -114,6 +116,10 @@ public:
|
||||
#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; }
|
||||
|
||||
@ -165,7 +171,8 @@ public:
|
||||
using GrSimpleMeshDrawOpHelper::compatibleWithAlphaAsCoverage;
|
||||
|
||||
bool isCompatible(const GrSimpleMeshDrawOpHelperWithStencil& that, const GrCaps&,
|
||||
const SkRect& thisBounds, const SkRect& thatBounds) const;
|
||||
const SkRect& thisBounds, const SkRect& thatBounds,
|
||||
bool noneAACompatibleWithCoverage = false) const;
|
||||
|
||||
PipelineAndFixedDynamicState makePipeline(GrMeshDrawOp::Target*,
|
||||
int numPrimitiveProcessorTextures = 0);
|
||||
@ -174,6 +181,7 @@ public:
|
||||
SkString dumpInfo() const;
|
||||
#endif
|
||||
GrAAType aaType() const { return INHERITED::aaType(); }
|
||||
void setAAType(GrAAType aaType) { INHERITED::setAAType(aaType); }
|
||||
|
||||
private:
|
||||
const GrUserStencilSettings* fStencilSettings;
|
||||
|
||||
@ -299,6 +299,7 @@ DRAW_OP_TEST_EXTERN(DashOp);
|
||||
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);
|
||||
@ -326,6 +327,7 @@ void GrDrawRandomOp(SkRandom* random, GrRenderTargetContext* renderTargetContext
|
||||
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),
|
||||
|
||||
Loading…
Reference in New Issue
Block a user