AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Converts remaining rect ops from GrLegacyMeshDrawOp to GrMeshDrawOp subclasses.

Browse Source 
Consolidates op factory functions to a rewritten GrRectOpFactory.

Removes GrRenderTargetContext::drawNonAAFilledRect() in favor of creating and adding ops directly by the callers.

Change-Id: I57e5fc739bf4e92b4a4710c739e6d22cce82a479
Reviewed-on: https://skia-review.googlesource.com/17711
Commit-Queue: Brian Salomon <bsalomon@google.com>
Reviewed-by: Robert Phillips <robertphillips@google.com>
This commit is contained in:
Brian Salomon 2017-06-14 09:49:26 -04:00 committed by Skia Commit-Bot
parent d99148623b
commit 1ec03f33cf
26 changed files with 447 additions and 598 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
gm/bigrrectaaeffect.cpp
View File

@ -13,7 +13,7 @@
#include "SkRRect.h"
#include "effects/GrRRectEffect.h"
#include "ops/GrDrawOp.h"
#include "ops/GrNonAAFillRectOp.h"
#include "ops/GrRectOpFactory.h"
namespace skiagm {
@ -89,8 +89,8 @@ protected:
bounds.offset(SkIntToScalar(x), SkIntToScalar(y));
renderTargetContext->priv().testingOnly_addDrawOp(
GrNonAAFillRectOp::Make(std::move(grPaint), SkMatrix::I(), bounds,
nullptr, nullptr, GrAAType::kNone));
GrRectOpFactory::MakeNonAAFill(std::move(grPaint), SkMatrix::I(),
bounds, GrAAType::kNone));
}
canvas->restore();
x = x + fTestOffsetX;

6
gm/constcolorprocessor.cpp
View File

@ -18,7 +18,7 @@
#include "SkGradientShader.h"
#include "effects/GrConstColorProcessor.h"
#include "ops/GrDrawOp.h"
#include "ops/GrNonAAFillRectOp.h"
#include "ops/GrRectOpFactory.h"
namespace skiagm {
/**
@ -110,8 +110,8 @@ protected:
grPaint.addColorFragmentProcessor(std::move(fp));
renderTargetContext->priv().testingOnly_addDrawOp(
GrNonAAFillRectOp::Make(std::move(grPaint), viewMatrix, renderRect,
nullptr, nullptr, GrAAType::kNone));
GrRectOpFactory::MakeNonAAFill(std::move(grPaint), viewMatrix,
renderRect, GrAAType::kNone));
// Draw labels for the input to the processor and the processor to the right of
// the test rect. The input label appears above the processor label.

11
gm/rrects.cpp
View File

@ -12,7 +12,7 @@
#include "GrRenderTargetContextPriv.h"
#include "effects/GrRRectEffect.h"
#include "ops/GrDrawOp.h"
#include "ops/GrNonAAFillRectOp.h"
#include "ops/GrRectOpFactory.h"
#endif
#include "SkRRect.h"
@ -117,12 +117,9 @@ protected:
bounds.outset(2.f, 2.f);
renderTargetContext->priv().testingOnly_addDrawOp(
GrNonAAFillRectOp::Make(std::move(grPaint),
SkMatrix::I(),
bounds,
nullptr,
nullptr,
GrAAType::kNone));
GrRectOpFactory::MakeNonAAFill(std::move(grPaint),
SkMatrix::I(), bounds,
GrAAType::kNone));
} else {
drew = false;
}

6
gm/texturedomaineffect.cpp
View File

@ -18,7 +18,7 @@
#include "SkGradientShader.h"
#include "effects/GrTextureDomain.h"
#include "ops/GrDrawOp.h"
#include "ops/GrNonAAFillRectOp.h"
#include "ops/GrRectOpFactory.h"
namespace skiagm {
/**
@ -134,8 +134,8 @@ protected:
const SkMatrix viewMatrix = SkMatrix::MakeTrans(x, y);
grPaint.addColorFragmentProcessor(std::move(fp));
renderTargetContext->priv().testingOnly_addDrawOp(
GrNonAAFillRectOp::Make(std::move(grPaint), viewMatrix, renderRect,
nullptr, nullptr, GrAAType::kNone));
GrRectOpFactory::MakeNonAAFill(std::move(grPaint), viewMatrix,
renderRect, GrAAType::kNone));
x += renderRect.width() + kTestPad;
}
y += renderRect.height() + kTestPad;

11
gm/yuvtorgbeffect.cpp
View File

@ -19,7 +19,7 @@
#include "SkGradientShader.h"
#include "effects/GrYUVEffect.h"
#include "ops/GrDrawOp.h"
#include "ops/GrNonAAFillRectOp.h"
#include "ops/GrRectOpFactory.h"
#define YSIZE 8
#define USIZE 4
@ -133,8 +133,8 @@ protected:
SkMatrix viewMatrix;
viewMatrix.setTranslate(x, y);
renderTargetContext->priv().testingOnly_addDrawOp(
GrNonAAFillRectOp::Make(std::move(grPaint), viewMatrix, renderRect,
nullptr, nullptr, GrAAType::kNone));
GrRectOpFactory::MakeNonAAFill(std::move(grPaint), viewMatrix,
renderRect, GrAAType::kNone));
}
x += renderRect.width() + kTestPad;
}
@ -256,9 +256,8 @@ protected:
SkMatrix viewMatrix;
viewMatrix.setTranslate(x, y);
grPaint.addColorFragmentProcessor(fp);
renderTargetContext->priv().testingOnly_addDrawOp(
GrNonAAFillRectOp::Make(std::move(grPaint), viewMatrix, renderRect, nullptr,
nullptr, GrAAType::kNone));
renderTargetContext->priv().testingOnly_addDrawOp(GrRectOpFactory::MakeNonAAFill(
std::move(grPaint), viewMatrix, renderRect, GrAAType::kNone));
}
}
}

5
gn/gpu.gni
View File

@ -230,13 +230,11 @@ skia_gpu_sources = [
"$_src/gpu/ops/GrAAConvexPathRenderer.cpp",
"$_src/gpu/ops/GrAAConvexPathRenderer.h",
"$_src/gpu/ops/GrAAFillRectOp.cpp",
"$_src/gpu/ops/GrAAFillRectOp.h",
"$_src/gpu/ops/GrAAHairLinePathRenderer.cpp",
"$_src/gpu/ops/GrAAHairLinePathRenderer.h",
"$_src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp",
"$_src/gpu/ops/GrAALinearizingConvexPathRenderer.h",
"$_src/gpu/ops/GrAAStrokeRectOp.cpp",
"$_src/gpu/ops/GrAAStrokeRectOp.h",
"$_src/gpu/ops/GrAnalyticRectOp.cpp",
"$_src/gpu/ops/GrAnalyticRectOp.h",
"$_src/gpu/ops/GrAtlasTextOp.cpp",
@ -264,10 +262,8 @@ skia_gpu_sources = [
"$_src/gpu/ops/GrMeshDrawOp.h",
"$_src/gpu/ops/GrMSAAPathRenderer.cpp",
"$_src/gpu/ops/GrMSAAPathRenderer.h",
"$_src/gpu/ops/GrNonAAFillRectOp.h",
"$_src/gpu/ops/GrNonAAFillRectOp.cpp",
"$_src/gpu/ops/GrNonAAStrokeRectOp.cpp",
"$_src/gpu/ops/GrNonAAStrokeRectOp.h",
"$_src/gpu/ops/GrLatticeOp.cpp",
"$_src/gpu/ops/GrLatticeOp.h",
"$_src/gpu/ops/GrOp.cpp",
@ -275,7 +271,6 @@ skia_gpu_sources = [
"$_src/gpu/ops/GrOvalOpFactory.cpp",
"$_src/gpu/ops/GrOvalOpFactory.h",
"$_src/gpu/ops/GrRectOpFactory.h",
"$_src/gpu/ops/GrRectOpFactory.cpp",
"$_src/gpu/ops/GrRegionOp.cpp",
"$_src/gpu/ops/GrRegionOp.h",
"$_src/gpu/ops/GrSemaphoreOp.cpp",

125
src/gpu/GrRenderTargetContext.cpp
View File

@ -34,7 +34,6 @@
#include "ops/GrDrawOp.h"
#include "ops/GrDrawVerticesOp.h"
#include "ops/GrLatticeOp.h"
#include "ops/GrNonAAFillRectOp.h"
#include "ops/GrOp.h"
#include "ops/GrOvalOpFactory.h"
#include "ops/GrRectOpFactory.h"
@ -283,10 +282,9 @@ void GrRenderTargetContextPriv::absClear(const SkIRect* clearRect, const GrColor
// We don't call drawRect() here to avoid the cropping to the, possibly smaller,
// RenderTargetProxy bounds
fRenderTargetContext->drawNonAAFilledRect(GrNoClip(), std::move(paint), SkMatrix::I(),
SkRect::Make(rtRect), nullptr, nullptr, nullptr,
GrAAType::kNone);
std::unique_ptr<GrDrawOp> op = GrRectOpFactory::MakeNonAAFill(
std::move(paint), SkMatrix::I(), SkRect::Make(rtRect), GrAAType::kNone);
fRenderTargetContext->addDrawOp(GrNoClip(), std::move(op));
} else {
// This path doesn't handle coalescing of full screen clears b.c. it
// has to clear the entire render target - not just the content area.
@ -396,8 +394,9 @@ void GrRenderTargetContext::drawPaint(const GrClip& clip,
AutoCheckFlush acf(this->drawingManager());
this->drawNonAAFilledRect(clip, std::move(paint), SkMatrix::I(), r, nullptr, &localMatrix,
nullptr, GrAAType::kNone);
std::unique_ptr<GrDrawOp> op = GrRectOpFactory::MakeNonAAFillWithLocalMatrix(
std::move(paint), SkMatrix::I(), localMatrix, r, GrAAType::kNone);
this->addDrawOp(clip, std::move(op));
}
}
@ -406,10 +405,6 @@ static inline bool rect_contains_inclusive(const SkRect& rect, const SkPoint& po
point.fY >= rect.fTop && point.fY <= rect.fBottom;
}
static bool view_matrix_ok_for_aa_fill_rect(const SkMatrix& viewMatrix) {
return viewMatrix.preservesRightAngles();
}
// Attempts to crop a rect and optional local rect to the clip boundaries.
// Returns false if the draw can be skipped entirely.
static bool crop_filled_rect(int width, int height, const GrClip& clip,
@ -477,29 +472,17 @@ bool GrRenderTargetContext::drawFilledRect(const GrClip& clip,
}
}
GrAAType aaType = this->chooseAAType(aa, GrAllowMixedSamples::kNo);
std::unique_ptr<GrDrawOp> op;
if (GrAAType::kCoverage == aaType) {
// The fill path can handle rotation but not skew.
if (view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
SkRect devBoundRect;
viewMatrix.mapRect(&devBoundRect, croppedRect);
std::unique_ptr<GrLegacyMeshDrawOp> op =
GrRectOpFactory::MakeAAFill(paint, viewMatrix, rect, croppedRect, devBoundRect);
if (op) {
GrPipelineBuilder pipelineBuilder(std::move(paint), aaType);
if (ss) {
pipelineBuilder.setUserStencil(ss);
}
this->addLegacyMeshDrawOp(std::move(pipelineBuilder), clip, std::move(op));
return true;
}
}
op = GrRectOpFactory::MakeAAFill(std::move(paint), viewMatrix, rect, ss);
} else {
this->drawNonAAFilledRect(clip, std::move(paint), viewMatrix, croppedRect, nullptr, nullptr,
ss, aaType);
return true;
op = GrRectOpFactory::MakeNonAAFill(std::move(paint), viewMatrix, croppedRect, aaType, ss);
}
return false;
if (!op) {
return false;
}
this->addDrawOp(clip, std::move(op));
return true;
}
void GrRenderTargetContext::drawRect(const GrClip& clip,
@ -589,30 +572,21 @@ void GrRenderTargetContext::drawRect(const GrClip& clip,
}
}
bool snapToPixelCenters = false;
std::unique_ptr<GrLegacyMeshDrawOp> op;
std::unique_ptr<GrDrawOp> op;
GrColor color = paint.getColor();
GrAAType aaType = this->chooseAAType(aa, GrAllowMixedSamples::kNo);
if (GrAAType::kCoverage == aaType) {
// The stroke path needs the rect to remain axis aligned (no rotation or skew).
if (viewMatrix.rectStaysRect()) {
op = GrRectOpFactory::MakeAAStroke(color, viewMatrix, rect, stroke);
op = GrRectOpFactory::MakeAAStroke(std::move(paint), viewMatrix, rect, stroke);
}
} else {
// Depending on sub-pixel coordinates and the particular GPU, we may lose a corner of
// hairline rects. We jam all the vertices to pixel centers to avoid this, but not
// when MSAA is enabled because it can cause ugly artifacts.
snapToPixelCenters = stroke.getStyle() == SkStrokeRec::kHairline_Style &&
GrFSAAType::kUnifiedMSAA != fRenderTargetProxy->fsaaType();
op = GrRectOpFactory::MakeNonAAStroke(color, viewMatrix, rect, stroke,
snapToPixelCenters);
op = GrRectOpFactory::MakeNonAAStroke(std::move(paint), viewMatrix, rect, stroke,
aaType);
}
if (op) {
GrPipelineBuilder pipelineBuilder(std::move(paint), aaType);
pipelineBuilder.setSnapVerticesToPixelCenters(snapToPixelCenters);
this->addLegacyMeshDrawOp(std::move(pipelineBuilder), clip, std::move(op));
this->addDrawOp(clip, std::move(op));
return;
}
}
@ -718,9 +692,9 @@ void GrRenderTargetContextPriv::stencilRect(const GrClip& clip,
GrPaint paint;
paint.setXPFactory(GrDisableColorXPFactory::Get());
fRenderTargetContext->drawNonAAFilledRect(clip, std::move(paint), viewMatrix, rect, nullptr,
nullptr, ss, aaType);
std::unique_ptr<GrDrawOp> op =
GrRectOpFactory::MakeNonAAFill(std::move(paint), viewMatrix, rect, aaType, ss);
fRenderTargetContext->addDrawOp(clip, std::move(op));
}
bool GrRenderTargetContextPriv::drawAndStencilRect(const GrClip& clip,
@ -782,16 +756,16 @@ void GrRenderTargetContext::fillRectToRect(const GrClip& clip,
GrAAType aaType = this->chooseAAType(aa, GrAllowMixedSamples::kNo);
if (GrAAType::kCoverage != aaType) {
this->drawNonAAFilledRect(clip, std::move(paint), viewMatrix, croppedRect,
&croppedLocalRect, nullptr, nullptr, aaType);
std::unique_ptr<GrDrawOp> op = GrRectOpFactory::MakeNonAAFillWithLocalRect(
std::move(paint), viewMatrix, croppedRect, croppedLocalRect, aaType);
this->addDrawOp(clip, std::move(op));
return;
}
if (view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
std::unique_ptr<GrLegacyMeshDrawOp> op = GrAAFillRectOp::MakeWithLocalRect(
paint.getColor(), viewMatrix, croppedRect, croppedLocalRect);
GrPipelineBuilder pipelineBuilder(std::move(paint), aaType);
this->addLegacyMeshDrawOp(std::move(pipelineBuilder), clip, std::move(op));
std::unique_ptr<GrDrawOp> op = GrRectOpFactory::MakeAAFillWithLocalRect(
std::move(paint), viewMatrix, croppedRect, croppedLocalRect);
if (op) {
this->addDrawOp(clip, std::move(op));
return;
}
@ -838,16 +812,16 @@ void GrRenderTargetContext::fillRectWithLocalMatrix(const GrClip& clip,
GrAAType aaType = this->chooseAAType(aa, GrAllowMixedSamples::kNo);
if (GrAAType::kCoverage != aaType) {
this->drawNonAAFilledRect(clip, std::move(paint), viewMatrix, croppedRect, nullptr,
&localMatrix, nullptr, aaType);
std::unique_ptr<GrDrawOp> op = GrRectOpFactory::MakeNonAAFillWithLocalMatrix(
std::move(paint), viewMatrix, localMatrix, croppedRect, aaType);
this->addDrawOp(clip, std::move(op));
return;
}
if (view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
std::unique_ptr<GrLegacyMeshDrawOp> op =
GrAAFillRectOp::Make(paint.getColor(), viewMatrix, localMatrix, croppedRect);
GrPipelineBuilder pipelineBuilder(std::move(paint), aaType);
this->addLegacyMeshDrawOp(std::move(pipelineBuilder), clip, std::move(op));
std::unique_ptr<GrDrawOp> op = GrRectOpFactory::MakeAAFillWithLocalMatrix(
std::move(paint), viewMatrix, localMatrix, croppedRect);
if (op) {
this->addDrawOp(clip, std::move(op));
return;
}
@ -1462,21 +1436,6 @@ void GrRenderTargetContext::prepareForExternalIO() {
this->drawingManager()->prepareSurfaceForExternalIO(fRenderTargetProxy.get());
}
void GrRenderTargetContext::drawNonAAFilledRect(const GrClip& clip,
GrPaint&& paint,
const SkMatrix& viewMatrix,
const SkRect& rect,
const SkRect* localRect,
const SkMatrix* localMatrix,
const GrUserStencilSettings* ss,
GrAAType hwOrNoneAAType) {
SkASSERT(GrAAType::kCoverage != hwOrNoneAAType);
SkASSERT(GrAAType::kNone == hwOrNoneAAType || GrFSAAType::kNone != this->fsaaType());
std::unique_ptr<GrDrawOp> op = GrNonAAFillRectOp::Make(
std::move(paint), viewMatrix, rect, localRect, localMatrix, hwOrNoneAAType, ss);
this->addDrawOp(clip, std::move(op));
}
// Can 'path' be drawn as a pair of filled nested rectangles?
static bool fills_as_nested_rects(const SkMatrix& viewMatrix, const SkPath& path, SkRect rects[2]) {
@ -1550,13 +1509,13 @@ void GrRenderTargetContext::drawPath(const GrClip& clip,
SkRect rects[2];
if (fills_as_nested_rects(viewMatrix, path, rects)) {
std::unique_ptr<GrLegacyMeshDrawOp> op =
GrRectOpFactory::MakeAAFillNestedRects(paint.getColor(), viewMatrix, rects);
if (op) {
GrPipelineBuilder pipelineBuilder(std::move(paint), aaType);
this->addLegacyMeshDrawOp(std::move(pipelineBuilder), clip, std::move(op));
std::unique_ptr<GrDrawOp> op =
GrRectOpFactory::MakeAAFillNestedRects(std::move(paint), viewMatrix, rects);
if (!op) {
// A null return indicates that there is nothing to draw in this case.
return;
}
return;
this->addDrawOp(clip, std::move(op));
}
}
SkRect ovalRect;

9
src/gpu/GrRenderTargetContext.h
View File

@ -400,15 +400,6 @@ private:
const SkRect& rect,
const GrUserStencilSettings* ss);
void drawNonAAFilledRect(const GrClip&,
GrPaint&&,
const SkMatrix& viewMatrix,
const SkRect& rect,
const SkRect* localRect,
const SkMatrix* localMatrix,
const GrUserStencilSettings* ss,
GrAAType hwOrNoneAAType);
void internalDrawPath(
const GrClip&, GrPaint&&, GrAA, const SkMatrix&, const SkPath&, const GrStyle&);

14
src/gpu/GrSWMaskHelper.cpp
View File

@ -6,7 +6,6 @@
*/
#include "GrSWMaskHelper.h"
#include "GrCaps.h"
#include "GrContext.h"
#include "GrContextPriv.h"
@ -15,11 +14,9 @@
#include "GrShape.h"
#include "GrSurfaceContext.h"
#include "GrTextureProxy.h"
#include "ops/GrDrawOp.h"
#include "SkDistanceFieldGen.h"
#include "ops/GrNonAAFillRectOp.h"
#include "ops/GrDrawOp.h"
#include "ops/GrRectOpFactory.h"
/*
* Convert a boolean operation into a transfer mode code
@ -176,7 +173,8 @@ void GrSWMaskHelper::DrawToTargetWithShapeMask(sk_sp<GrTextureProxy> proxy,
paint.addCoverageFragmentProcessor(GrSimpleTextureEffect::Make(
resourceProvider, std::move(proxy), nullptr, maskMatrix,
GrSamplerParams::kNone_FilterMode));
renderTargetContext->addDrawOp(
clip, GrNonAAFillRectOp::Make(std::move(paint), SkMatrix::I(), dstRect, nullptr,
&invert, GrAAType::kNone, &userStencilSettings));
renderTargetContext->addDrawOp(clip,
GrRectOpFactory::MakeNonAAFillWithLocalMatrix(
std::move(paint), SkMatrix::I(), invert, dstRect,
GrAAType::kNone, &userStencilSettings));
}

9
src/gpu/GrSoftwarePathRenderer.cpp
View File

@ -12,7 +12,7 @@
#include "GrPipelineBuilder.h"
#include "GrResourceProvider.h"
#include "GrSWMaskHelper.h"
#include "ops/GrNonAAFillRectOp.h"
#include "ops/GrRectOpFactory.h"
////////////////////////////////////////////////////////////////////////////////
bool GrSoftwarePathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
@ -76,9 +76,10 @@ void GrSoftwarePathRenderer::DrawNonAARect(GrRenderTargetContext* renderTargetCo
const SkMatrix& viewMatrix,
const SkRect& rect,
const SkMatrix& localMatrix) {
renderTargetContext->addDrawOp(
clip, GrNonAAFillRectOp::Make(std::move(paint), viewMatrix, rect, nullptr, &localMatrix,
GrAAType::kNone, &userStencilSettings));
renderTargetContext->addDrawOp(clip,
GrRectOpFactory::MakeNonAAFillWithLocalMatrix(
std::move(paint), viewMatrix, localMatrix, rect,
GrAAType::kNone, &userStencilSettings));
}
void GrSoftwarePathRenderer::DrawAroundInvPath(GrRenderTargetContext* renderTargetContext,

184
src/gpu/ops/GrAAFillRectOp.cpp
View File

@ -5,21 +5,26 @@
* found in the LICENSE file.
*/
#include "GrAAFillRectOp.h"
#include "GrColor.h"
#include "GrDefaultGeoProcFactory.h"
#include "GrMeshDrawOp.h"
#include "GrOpFlushState.h"
#include "GrRectOpFactory.h"
#include "GrResourceKey.h"
#include "GrResourceProvider.h"
#include "GrTypes.h"
#include "SkMatrix.h"
#include "SkRect.h"
#include "ops/GrSimpleMeshDrawOpHelper.h"
GR_DECLARE_STATIC_UNIQUE_KEY(gAAFillRectIndexBufferKey);
static void set_inset_fan(SkPoint* pts, size_t stride, const SkRect& r, SkScalar dx, SkScalar dy) {
static inline bool view_matrix_ok_for_aa_fill_rect(const SkMatrix& viewMatrix) {
return viewMatrix.preservesRightAngles();
}
static inline void set_inset_fan(SkPoint* pts, size_t stride, const SkRect& r, SkScalar dx,
SkScalar dy) {
pts->setRectFan(r.fLeft + dx, r.fTop + dy, r.fRight - dx, r.fBottom - dy, stride);
}
@ -153,16 +158,34 @@ static void generate_aa_fill_rect_geometry(intptr_t verts,
}
}
class AAFillRectOp final : public GrLegacyMeshDrawOp {
namespace {
class AAFillRectOp final : public GrMeshDrawOp {
private:
using Helper = GrSimpleMeshDrawOpHelperWithStencil;
public:
DEFINE_OP_CLASS_ID
AAFillRectOp(GrColor color,
static std::unique_ptr<GrDrawOp> Make(GrPaint&& paint,
const SkMatrix& viewMatrix,
const SkRect& rect,
const SkRect& devRect,
const SkMatrix* localMatrix,
const GrUserStencilSettings* stencil) {
SkASSERT(view_matrix_ok_for_aa_fill_rect(viewMatrix));
return Helper::FactoryHelper<AAFillRectOp>(std::move(paint), viewMatrix, rect, devRect,
localMatrix, stencil);
}
AAFillRectOp(const Helper::MakeArgs& helperArgs,
GrColor color,
const SkMatrix& viewMatrix,
const SkRect& rect,
const SkRect& devRect,
const SkMatrix* localMatrix)
: INHERITED(ClassID()) {
const SkMatrix* localMatrix,
const GrUserStencilSettings* stencil)
: INHERITED(ClassID()), fHelper(helperArgs, GrAAType::kCoverage, stencil) {
if (localMatrix) {
void* mem = fRectData.push_back_n(sizeof(RectWithLocalMatrixInfo));
new (mem) RectWithLocalMatrixInfo(color, viewMatrix, rect, devRect, *localMatrix);
@ -189,38 +212,29 @@ public:
info->color(), rect.fLeft, rect.fTop, rect.fRight, rect.fBottom);
info = this->next(info);
}
str.append(DumpPipelineInfo(*this->pipeline()));
return str;
}
void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
GrColor color;
if (optimizations.getOverrideColorIfSet(&color)) {
this->first()->setColor(color);
}
fCanTweakAlphaForCoverage = optimizations.canTweakAlphaForCoverage();
fNeedsLocalCoords = optimizations.readsLocalCoords();
FixedFunctionFlags fixedFunctionFlags() const override { return fHelper.fixedFunctionFlags(); }
bool xpRequiresDstTexture(const GrCaps& caps, const GrAppliedClip* clip) override {
GrColor color = this->first()->color();
bool result = fHelper.xpRequiresDstTexture(
caps, clip, GrProcessorAnalysisCoverage::kSingleChannel, &color);
this->first()->setColor(color);
return result;
}
private:
void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
GrProcessorAnalysisCoverage* coverage) const override {
color->setToConstant(this->first()->color());
*coverage = GrProcessorAnalysisCoverage::kSingleChannel;
}
void onPrepareDraws(Target* target) const override {
using namespace GrDefaultGeoProcFactory;
Color color(Color::kPremulGrColorAttribute_Type);
Coverage::Type coverageType;
if (fCanTweakAlphaForCoverage) {
coverageType = Coverage::kSolid_Type;
} else {
coverageType = Coverage::kAttribute_Type;
}
LocalCoords lc =
fNeedsLocalCoords ? LocalCoords::kHasExplicit_Type : LocalCoords::kUnused_Type;
Coverage::Type coverageType = fHelper.compatibleWithAlphaAsCoverage()
? Coverage::kSolid_Type
: Coverage::kAttribute_Type;
LocalCoords lc = fHelper.usesLocalCoords() ? LocalCoords::kHasExplicit_Type
: LocalCoords::kUnused_Type;
sk_sp<GrGeometryProcessor> gp =
GrDefaultGeoProcFactory::Make(color, coverageType, lc, SkMatrix::I());
if (!gp) {
@ -245,7 +259,7 @@ private:
for (int i = 0; i < fRectCnt; i++) {
intptr_t verts =
reinterpret_cast<intptr_t>(vertices) + i * kVertsPerAAFillRect * vertexStride;
if (fNeedsLocalCoords) {
if (fHelper.usesLocalCoords()) {
if (info->hasLocalMatrix()) {
localMatrix = &static_cast<const RectWithLocalMatrixInfo*>(info)->localMatrix();
} else {
@ -253,28 +267,19 @@ private:
}
}
generate_aa_fill_rect_geometry(verts, vertexStride, info->color(), info->viewMatrix(),
info->rect(), info->devRect(), fCanTweakAlphaForCoverage,
localMatrix);
info->rect(), info->devRect(),
fHelper.compatibleWithAlphaAsCoverage(), localMatrix);
info = this->next(info);
}
helper.recordDraw(target, gp.get(), this->pipeline());
helper.recordDraw(target, gp.get(), fHelper.makePipeline(target));
}
bool onCombineIfPossible(GrOp* t, const GrCaps& caps) override {
AAFillRectOp* that = t->cast<AAFillRectOp>();
if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
that->bounds(), caps)) {
if (!fHelper.isCompatible(that->fHelper, caps, this->bounds(), that->bounds())) {
return false;
}
SkASSERT(fNeedsLocalCoords == that->fNeedsLocalCoords);
// In the event of two ops, one who can tweak, one who cannot, we just fall back to not
// tweaking.
if (fCanTweakAlphaForCoverage && !that->fCanTweakAlphaForCoverage) {
fCanTweakAlphaForCoverage = false;
}
fRectData.push_back_n(that->fRectData.count(), that->fRectData.begin());
fRectCnt += that->fRectCnt;
this->joinBounds(*that);
@ -333,55 +338,63 @@ private:
return reinterpret_cast<const RectInfo*>(next);
}
bool fNeedsLocalCoords;
bool fCanTweakAlphaForCoverage;
SkSTArray<4 * sizeof(RectWithLocalMatrixInfo), uint8_t, true> fRectData;
Helper fHelper;
int fRectCnt;
typedef GrLegacyMeshDrawOp INHERITED;
typedef GrMeshDrawOp INHERITED;
};
namespace GrAAFillRectOp {
} // anonymous namespace
std::unique_ptr<GrLegacyMeshDrawOp> Make(GrColor color,
const SkMatrix& viewMatrix,
const SkRect& rect,
const SkRect& devRect) {
return std::unique_ptr<GrLegacyMeshDrawOp>(
new AAFillRectOp(color, viewMatrix, rect, devRect, nullptr));
namespace GrRectOpFactory {
std::unique_ptr<GrDrawOp> MakeAAFill(GrPaint&& paint, const SkMatrix& viewMatrix,
const SkRect& rect, const GrUserStencilSettings* stencil) {
if (!view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
return nullptr;
}
SkRect devRect;
if (!viewMatrix.mapRect(&devRect, rect)) {
return nullptr;
}
return AAFillRectOp::Make(std::move(paint), viewMatrix, rect, devRect, nullptr, stencil);
}
std::unique_ptr<GrLegacyMeshDrawOp> Make(GrColor color,
const SkMatrix& viewMatrix,
const SkMatrix& localMatrix,
const SkRect& rect,
const SkRect& devRect) {
return std::unique_ptr<GrLegacyMeshDrawOp>(
new AAFillRectOp(color, viewMatrix, rect, devRect, &localMatrix));
std::unique_ptr<GrDrawOp> MakeAAFillWithDevRect(GrPaint&& paint, const SkMatrix& viewMatrix,
const SkRect& rect, const SkRect& devRect) {
if (!view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
return nullptr;
}
return AAFillRectOp::Make(std::move(paint), viewMatrix, rect, devRect, nullptr, nullptr);
}
std::unique_ptr<GrLegacyMeshDrawOp> Make(GrColor color,
const SkMatrix& viewMatrix,
const SkMatrix& localMatrix,
const SkRect& rect) {
std::unique_ptr<GrDrawOp> MakeAAFillWithLocalMatrix(GrPaint&& paint, const SkMatrix& viewMatrix,
const SkMatrix& localMatrix,
const SkRect& rect) {
if (!view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
return nullptr;
}
SkRect devRect;
viewMatrix.mapRect(&devRect, rect);
return Make(color, viewMatrix, localMatrix, rect, devRect);
return AAFillRectOp::Make(std::move(paint), viewMatrix, rect, devRect, &localMatrix, nullptr);
}
std::unique_ptr<GrLegacyMeshDrawOp> MakeWithLocalRect(GrColor color,
const SkMatrix& viewMatrix,
const SkRect& rect,
const SkRect& localRect) {
std::unique_ptr<GrDrawOp> MakeAAFillWithLocalRect(GrPaint&& paint, const SkMatrix& viewMatrix,
const SkRect& rect, const SkRect& localRect) {
if (!view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
return nullptr;
}
SkRect devRect;
viewMatrix.mapRect(&devRect, rect);
SkMatrix localMatrix;
if (!localMatrix.setRectToRect(rect, localRect, SkMatrix::kFill_ScaleToFit)) {
return nullptr;
}
return Make(color, viewMatrix, localMatrix, rect, devRect);
return AAFillRectOp::Make(std::move(paint), viewMatrix, rect, devRect, &localMatrix, nullptr);
}
};
} // namespace GrRectOpFactory
///////////////////////////////////////////////////////////////////////////////////////////////////
@ -389,21 +402,22 @@ std::unique_ptr<GrLegacyMeshDrawOp> MakeWithLocalRect(GrColor color,
#include "GrDrawOpTest.h"
GR_LEGACY_MESH_DRAW_OP_TEST_DEFINE(AAFillRectOp) {
GrColor color = GrRandomColor(random);
SkMatrix viewMatrix = GrTest::TestMatrixInvertible(random);
GR_DRAW_OP_TEST_DEFINE(AAFillRectOp) {
SkMatrix viewMatrix;
do {
viewMatrix = GrTest::TestMatrixInvertible(random);
} while (!view_matrix_ok_for_aa_fill_rect(viewMatrix));
SkRect rect = GrTest::TestRect(random);
SkRect devRect = GrTest::TestRect(random);
return GrAAFillRectOp::Make(color, viewMatrix, rect, devRect);
}
GR_LEGACY_MESH_DRAW_OP_TEST_DEFINE(AAFillRectOpLocalMatrix) {
GrColor color = GrRandomColor(random);
SkMatrix viewMatrix = GrTest::TestMatrixInvertible(random);
SkMatrix localMatrix = GrTest::TestMatrix(random);
SkRect rect = GrTest::TestRect(random);
SkRect devRect = GrTest::TestRect(random);
return GrAAFillRectOp::Make(color, viewMatrix, localMatrix, rect, devRect);
SkRect devRect;
viewMatrix.mapRect(&devRect, rect);
const SkMatrix* localMatrix = nullptr;
SkMatrix m;
if (random->nextBool()) {
m = GrTest::TestMatrix(random);
}
const GrUserStencilSettings* stencil =
random->nextBool() ? nullptr : GrGetRandomStencil(random, context);
return AAFillRectOp::Make(std::move(paint), viewMatrix, rect, devRect, localMatrix, stencil);
}
#endif

41
src/gpu/ops/GrAAFillRectOp.h
View File

@ -1,41 +0,0 @@
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrAAFillRectOp_DEFINED
#define GrAAFillRectOp_DEFINED
#include "GrColor.h"
#include "SkRefCnt.h"
class GrLegacyMeshDrawOp;
class SkMatrix;
struct SkRect;
namespace GrAAFillRectOp {
std::unique_ptr<GrLegacyMeshDrawOp> Make(GrColor color,
const SkMatrix& viewMatrix,
const SkRect& rect,
const SkRect& devRect);
std::unique_ptr<GrLegacyMeshDrawOp> Make(GrColor color,
const SkMatrix& viewMatrix,
const SkMatrix& localMatrix,
const SkRect& rect);
std::unique_ptr<GrLegacyMeshDrawOp> Make(GrColor color,
const SkMatrix& viewMatrix,
const SkMatrix& localMatrix,
const SkRect& rect,
const SkRect& devRect);
std::unique_ptr<GrLegacyMeshDrawOp> MakeWithLocalRect(GrColor color,
const SkMatrix& viewMatrix,
const SkRect& rect,
const SkRect& localRect);
};
#endif

147
src/gpu/ops/GrAAStrokeRectOp.cpp
View File

@ -5,12 +5,12 @@
* found in the LICENSE file.
*/
#include "GrAAStrokeRectOp.h"
#include "GrDefaultGeoProcFactory.h"
#include "GrOpFlushState.h"
#include "GrRectOpFactory.h"
#include "GrResourceKey.h"
#include "GrResourceProvider.h"
#include "GrSimpleMeshDrawOpHelper.h"
#include "SkStrokeRec.h"
GR_DECLARE_STATIC_UNIQUE_KEY(gMiterIndexBufferKey);
@ -110,13 +110,26 @@ static sk_sp<GrGeometryProcessor> create_stroke_rect_gp(bool tweakAlphaForCovera
viewMatrix);
}
class AAStrokeRectOp final : public GrLegacyMeshDrawOp {
namespace {
class AAStrokeRectOp final : public GrMeshDrawOp {
private:
using Helper = GrSimpleMeshDrawOpHelper;
public:
DEFINE_OP_CLASS_ID
AAStrokeRectOp(GrColor color, const SkMatrix& viewMatrix, const SkRect& devOutside,
const SkRect& devInside)
: INHERITED(ClassID()), fViewMatrix(viewMatrix) {
static std::unique_ptr<GrDrawOp> Make(GrPaint&& paint, const SkMatrix& viewMatrix,
const SkRect& devOutside, const SkRect& devInside) {
return Helper::FactoryHelper<AAStrokeRectOp>(std::move(paint), viewMatrix, devOutside,
devInside);
}
AAStrokeRectOp(const Helper::MakeArgs& helperArgs, GrColor color, const SkMatrix& viewMatrix,
const SkRect& devOutside, const SkRect& devInside)
: INHERITED(ClassID())
, fHelper(helperArgs, GrAAType::kCoverage)
, fViewMatrix(viewMatrix) {
SkASSERT(!devOutside.isEmpty());
SkASSERT(!devInside.isEmpty());
@ -125,30 +138,35 @@ public:
fMiterStroke = true;
}
static std::unique_ptr<GrLegacyMeshDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
const SkRect& rect, const SkStrokeRec& stroke) {
static std::unique_ptr<GrDrawOp> Make(GrPaint&& paint, const SkMatrix& viewMatrix,
const SkRect& rect, const SkStrokeRec& stroke) {
bool isMiter;
if (!allowed_stroke(stroke, &isMiter)) {
return nullptr;
}
return Helper::FactoryHelper<AAStrokeRectOp>(std::move(paint), viewMatrix, rect, stroke,
isMiter);
}
AAStrokeRectOp* op = new AAStrokeRectOp();
op->fMiterStroke = isMiter;
RectInfo& info = op->fRects.push_back();
AAStrokeRectOp(const Helper::MakeArgs& helperArgs, GrColor color, const SkMatrix& viewMatrix,
const SkRect& rect, const SkStrokeRec& stroke, bool isMiter)
: INHERITED(ClassID())
, fHelper(helperArgs, GrAAType::kCoverage)
, fViewMatrix(viewMatrix) {
fMiterStroke = isMiter;
RectInfo& info = fRects.push_back();
compute_rects(&info.fDevOutside, &info.fDevOutsideAssist, &info.fDevInside,
&info.fDegenerate, viewMatrix, rect, stroke.getWidth(), isMiter);
info.fColor = color;
if (isMiter) {
op->setBounds(info.fDevOutside, HasAABloat::kYes, IsZeroArea::kNo);
this->setBounds(info.fDevOutside, HasAABloat::kYes, IsZeroArea::kNo);
} else {
// The outer polygon of the bevel stroke is an octagon specified by the points of a
// pair of overlapping rectangles where one is wide and the other is narrow.
SkRect bounds = info.fDevOutside;
bounds.joinPossiblyEmptyRect(info.fDevOutsideAssist);
op->setBounds(bounds, HasAABloat::kYes, IsZeroArea::kNo);
this->setBounds(bounds, HasAABloat::kYes, IsZeroArea::kNo);
}
op->fViewMatrix = viewMatrix;
return std::unique_ptr<GrLegacyMeshDrawOp>(op);
}
const char* name() const override { return "AAStrokeRect"; }
@ -166,20 +184,18 @@ public:
info.fDevOutsideAssist.fBottom, info.fDevInside.fLeft, info.fDevInside.fTop,
info.fDevInside.fRight, info.fDevInside.fBottom, info.fDegenerate);
}
string.append(DumpPipelineInfo(*this->pipeline()));
string.append(INHERITED::dumpInfo());
return string;
}
private:
AAStrokeRectOp() : INHERITED(ClassID()) {}
FixedFunctionFlags fixedFunctionFlags() const override { return fHelper.fixedFunctionFlags(); }
void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
GrProcessorAnalysisCoverage* coverage) const override {
color->setToConstant(fRects[0].fColor);
*coverage = GrProcessorAnalysisCoverage::kSingleChannel;
bool xpRequiresDstTexture(const GrCaps& caps, const GrAppliedClip* clip) override {
return fHelper.xpRequiresDstTexture(caps, clip, GrProcessorAnalysisCoverage::kSingleChannel,
&fRects.back().fColor);
}
void applyPipelineOptimizations(const PipelineOptimizations&) override;
private:
void onPrepareDraws(Target*) const override;
static const int kMiterIndexCnt = 3 * 24;
@ -192,8 +208,6 @@ private:
static const GrBuffer* GetIndexBuffer(GrResourceProvider* resourceProvider, bool miterStroke);
bool usesLocalCoords() const { return fUsesLocalCoords; }
bool canTweakAlphaForCoverage() const { return fCanTweakAlphaForCoverage; }
const SkMatrix& viewMatrix() const { return fViewMatrix; }
bool miterStroke() const { return fMiterStroke; }
@ -221,29 +235,20 @@ private:
bool fDegenerate;
};
Helper fHelper;
SkSTArray<1, RectInfo, true> fRects;
bool fUsesLocalCoords;
bool fCanTweakAlphaForCoverage;
SkMatrix fViewMatrix;
bool fMiterStroke;
typedef GrLegacyMeshDrawOp INHERITED;
typedef GrMeshDrawOp INHERITED;
};
void AAStrokeRectOp::applyPipelineOptimizations(const PipelineOptimizations& optimizations) {
optimizations.getOverrideColorIfSet(&fRects[0].fColor);
fUsesLocalCoords = optimizations.readsLocalCoords();
fCanTweakAlphaForCoverage = optimizations.canTweakAlphaForCoverage();
fCanTweakAlphaForCoverage = optimizations.canTweakAlphaForCoverage();
}
} // anonymous namespace
void AAStrokeRectOp::onPrepareDraws(Target* target) const {
bool canTweakAlphaForCoverage = this->canTweakAlphaForCoverage();
sk_sp<GrGeometryProcessor> gp(create_stroke_rect_gp(canTweakAlphaForCoverage,
sk_sp<GrGeometryProcessor> gp(create_stroke_rect_gp(fHelper.compatibleWithAlphaAsCoverage(),
this->viewMatrix(),
this->usesLocalCoords()));
fHelper.usesLocalCoords()));
if (!gp) {
SkDebugf("Couldn't create GrGeometryProcessor\n");
return;
@ -251,7 +256,7 @@ void AAStrokeRectOp::onPrepareDraws(Target* target) const {
size_t vertexStride = gp->getVertexStride();
SkASSERT(canTweakAlphaForCoverage
SkASSERT(fHelper.compatibleWithAlphaAsCoverage()
? vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorAttr)
: vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr));
int innerVertexNum = 4;
@ -284,9 +289,9 @@ void AAStrokeRectOp::onPrepareDraws(Target* target) const {
info.fDevInside,
fMiterStroke,
info.fDegenerate,
canTweakAlphaForCoverage);
fHelper.compatibleWithAlphaAsCoverage());
}
helper.recordDraw(target, gp.get(), this->pipeline());
helper.recordDraw(target, gp.get(), fHelper.makePipeline(target));
}
const GrBuffer* AAStrokeRectOp::GetIndexBuffer(GrResourceProvider* resourceProvider,
@ -386,8 +391,7 @@ const GrBuffer* AAStrokeRectOp::GetIndexBuffer(GrResourceProvider* resourceProvi
bool AAStrokeRectOp::onCombineIfPossible(GrOp* t, const GrCaps& caps) {
AAStrokeRectOp* that = t->cast<AAStrokeRectOp>();
if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
that->bounds(), caps)) {
if (!fHelper.isCompatible(that->fHelper, caps, this->bounds(), that->bounds())) {
return false;
}
@ -397,18 +401,11 @@ bool AAStrokeRectOp::onCombineIfPossible(GrOp* t, const GrCaps& caps) {
}
// We apply the viewmatrix to the rect points on the cpu. However, if the pipeline uses
// local coords then we won't be able to combine. We could actually upload the viewmatrix
// using vertex attributes in these cases, but haven't investigated that
if (this->usesLocalCoords() && !this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
// local coords then we won't be able to combine. TODO: Upload local coords as an attribute.
if (fHelper.usesLocalCoords() && !this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
return false;
}
// In the event of two ops, one who can tweak, one who cannot, we just fall back to not
// tweaking.
if (this->canTweakAlphaForCoverage() != that->canTweakAlphaForCoverage()) {
fCanTweakAlphaForCoverage = false;
}
fRects.push_back_n(that->fRects.count(), that->fRects.begin());
this->joinBounds(*that);
return true;
@ -569,31 +566,43 @@ void AAStrokeRectOp::generateAAStrokeRectGeometry(void* vertices,
}
}
namespace GrAAStrokeRectOp {
namespace GrRectOpFactory {
std::unique_ptr<GrLegacyMeshDrawOp> MakeFillBetweenRects(GrColor color,
const SkMatrix& viewMatrix,
const SkRect& devOutside,
const SkRect& devInside) {
return std::unique_ptr<GrLegacyMeshDrawOp>(
new AAStrokeRectOp(color, viewMatrix, devOutside, devInside));
std::unique_ptr<GrDrawOp> MakeAAFillNestedRects(GrPaint&& paint,
const SkMatrix& viewMatrix,
const SkRect rects[2]) {
SkASSERT(viewMatrix.rectStaysRect());
SkASSERT(!rects[0].isEmpty() && !rects[1].isEmpty());
SkRect devOutside, devInside;
viewMatrix.mapRect(&devOutside, rects[0]);
viewMatrix.mapRect(&devInside, rects[1]);
if (devInside.isEmpty()) {
if (devOutside.isEmpty()) {
return nullptr;
}
return MakeAAFillWithDevRect(std::move(paint), viewMatrix, rects[0], devOutside);
}
return AAStrokeRectOp::Make(std::move(paint), viewMatrix, devOutside, devInside);
}
std::unique_ptr<GrLegacyMeshDrawOp> Make(GrColor color,
const SkMatrix& viewMatrix,
const SkRect& rect,
const SkStrokeRec& stroke) {
return AAStrokeRectOp::Make(color, viewMatrix, rect, stroke);
}
std::unique_ptr<GrDrawOp> MakeAAStroke(GrPaint&& paint,
const SkMatrix& viewMatrix,
const SkRect& rect,
const SkStrokeRec& stroke) {
return AAStrokeRectOp::Make(std::move(paint), viewMatrix, rect, stroke);
}
} // namespace GrRectOpFactory
///////////////////////////////////////////////////////////////////////////////////////////////////
#if GR_TEST_UTILS
#include "GrDrawOpTest.h"
GR_LEGACY_MESH_DRAW_OP_TEST_DEFINE(AAStrokeRectOp) {
GR_DRAW_OP_TEST_DEFINE(AAStrokeRectOp) {
bool miterStroke = random->nextBool();
// Create either a empty rect or a non-empty rect.
@ -602,14 +611,12 @@ GR_LEGACY_MESH_DRAW_OP_TEST_DEFINE(AAStrokeRectOp) {
SkScalar minDim = SkMinScalar(rect.width(), rect.height());
SkScalar strokeWidth = random->nextUScalar1() * minDim;
GrColor color = GrRandomColor(random);
SkStrokeRec rec(SkStrokeRec::kFill_InitStyle);
rec.setStrokeStyle(strokeWidth);
rec.setStrokeParams(SkPaint::kButt_Cap,
miterStroke ? SkPaint::kMiter_Join : SkPaint::kBevel_Join, 1.f);
SkMatrix matrix = GrTest::TestMatrixRectStaysRect(random);
return GrAAStrokeRectOp::Make(color, matrix, rect, rec);
return GrRectOpFactory::MakeAAStroke(std::move(paint), matrix, rect, rec);
}
#endif

32
src/gpu/ops/GrAAStrokeRectOp.h
View File

@ -1,32 +0,0 @@
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrAAStrokeRectOp_DEFINED
#define GrAAStrokeRectOp_DEFINED
#include "GrColor.h"
#include "SkRefCnt.h"
class GrLegacyMeshDrawOp;
class SkMatrix;
struct SkRect;
class SkStrokeRec;
namespace GrAAStrokeRectOp {
std::unique_ptr<GrLegacyMeshDrawOp> MakeFillBetweenRects(GrColor color,
const SkMatrix& viewMatrix,
const SkRect& devOutside,
const SkRect& devInside);
std::unique_ptr<GrLegacyMeshDrawOp> Make(GrColor color,
const SkMatrix& viewMatrix,
const SkRect& rect,
const SkStrokeRec& stroke);
}
#endif

8
src/gpu/ops/GrDefaultPathRenderer.cpp
View File

@ -6,7 +6,6 @@
*/
#include "GrDefaultPathRenderer.h"
#include "GrContext.h"
#include "GrDefaultGeoProcFactory.h"
#include "GrDrawOpTest.h"
@ -20,9 +19,8 @@
#include "SkStrokeRec.h"
#include "SkTLazy.h"
#include "SkTraceEvent.h"
#include "ops/GrMeshDrawOp.h"
#include "ops/GrNonAAFillRectOp.h"
#include "ops/GrRectOpFactory.h"
GrDefaultPathRenderer::GrDefaultPathRenderer() {
}
@ -522,8 +520,8 @@ bool GrDefaultPathRenderer::internalDrawPath(GrRenderTargetContext* renderTarget
viewMatrix;
renderTargetContext->addDrawOp(
clip,
GrNonAAFillRectOp::Make(std::move(paint), viewM, bounds, nullptr, &localMatrix,
aaType, passes[p]));
GrRectOpFactory::MakeNonAAFillWithLocalMatrix(
std::move(paint), viewM, localMatrix, bounds, aaType, passes[p]));
} else {
std::unique_ptr<GrLegacyMeshDrawOp> op =
DefaultPathOp::Make(paint.getColor(), path, srcSpaceTol, newCoverage,

7
src/gpu/ops/GrMSAAPathRenderer.cpp
View File

@ -6,7 +6,6 @@
*/
#include "GrMSAAPathRenderer.h"
#include "GrAuditTrail.h"
#include "GrClip.h"
#include "GrDefaultGeoProcFactory.h"
@ -26,7 +25,7 @@
#include "glsl/GrGLSLUtil.h"
#include "glsl/GrGLSLVertexShaderBuilder.h"
#include "ops/GrMeshDrawOp.h"
#include "ops/GrNonAAFillRectOp.h"
#include "ops/GrRectOpFactory.h"
static const float kTolerance = 0.5f;
@ -667,8 +666,8 @@ bool GrMSAAPathRenderer::internalDrawPath(GrRenderTargetContext* renderTargetCon
(reverse && viewMatrix.hasPerspective()) ? SkMatrix::I() : viewMatrix;
renderTargetContext->addDrawOp(
clip,
GrNonAAFillRectOp::Make(std::move(paint), viewM, bounds, nullptr, &localMatrix,
aaType, passes[1]));
GrRectOpFactory::MakeNonAAFillWithLocalMatrix(std::move(paint), viewM, localMatrix,
bounds, aaType, passes[1]));
}
return true;
}

63
src/gpu/ops/GrNonAAFillRectOp.cpp
View File

@ -5,7 +5,6 @@
* found in the LICENSE file.
*/
#include "GrNonAAFillRectOp.h"
#include "GrAppliedClip.h"
#include "GrColor.h"
#include "GrDefaultGeoProcFactory.h"
@ -14,6 +13,7 @@
#include "GrOpFlushState.h"
#include "GrPrimitiveProcessor.h"
#include "GrQuad.h"
#include "GrRectOpFactory.h"
#include "GrResourceProvider.h"
#include "GrSimpleMeshDrawOpHelper.h"
#include "SkMatrixPriv.h"
@ -358,25 +358,45 @@ private:
} // anonymous namespace
namespace GrNonAAFillRectOp {
namespace GrRectOpFactory {
std::unique_ptr<GrDrawOp> Make(GrPaint&& paint,
const SkMatrix& viewMatrix,
const SkRect& rect,
const SkRect* localRect,
const SkMatrix* localMatrix,
GrAAType aaType,
const GrUserStencilSettings* stencilSettings) {
if (!viewMatrix.hasPerspective() && (!localMatrix || !localMatrix->hasPerspective())) {
return NonAAFillRectOp::Make(std::move(paint), viewMatrix, rect, localRect, localMatrix,
aaType, stencilSettings);
std::unique_ptr<GrDrawOp> MakeNonAAFill(GrPaint&& paint, const SkMatrix& viewMatrix,
const SkRect& rect, GrAAType aaType,
const GrUserStencilSettings* stencilSettings) {
if (viewMatrix.hasPerspective()) {
return NonAAFillRectPerspectiveOp::Make(std::move(paint), viewMatrix, rect, nullptr,
nullptr, aaType, stencilSettings);
} else {
return NonAAFillRectPerspectiveOp::Make(std::move(paint), viewMatrix, rect, localRect,
localMatrix, aaType, stencilSettings);
return NonAAFillRectOp::Make(std::move(paint), viewMatrix, rect, nullptr, nullptr, aaType,
stencilSettings);
}
}
}; // namespace GrNonAAFillRectOp
std::unique_ptr<GrDrawOp> MakeNonAAFillWithLocalMatrix(
GrPaint&& paint, const SkMatrix& viewMatrix, const SkMatrix& localMatrix,
const SkRect& rect, GrAAType aaType, const GrUserStencilSettings* stencilSettings) {
if (viewMatrix.hasPerspective() || localMatrix.hasPerspective()) {
return NonAAFillRectPerspectiveOp::Make(std::move(paint), viewMatrix, rect, nullptr,
&localMatrix, aaType, stencilSettings);
} else {
return NonAAFillRectOp::Make(std::move(paint), viewMatrix, rect, nullptr, &localMatrix,
aaType, stencilSettings);
}
}
std::unique_ptr<GrDrawOp> MakeNonAAFillWithLocalRect(GrPaint&& paint, const SkMatrix& viewMatrix,
const SkRect& rect, const SkRect& localRect,
GrAAType aaType) {
if (viewMatrix.hasPerspective()) {
return NonAAFillRectPerspectiveOp::Make(std::move(paint), viewMatrix, rect, &localRect,
nullptr, aaType, nullptr);
} else {
return NonAAFillRectOp::Make(std::move(paint), viewMatrix, rect, &localRect, nullptr,
aaType, nullptr);
}
}
} // namespace GrRectOpFactory
///////////////////////////////////////////////////////////////////////////////////////////////////
@ -385,14 +405,17 @@ GR_DRAW_OP_TEST_DEFINE(NonAAFillRectOp) {
SkRect localRect = GrTest::TestRect(random);
SkMatrix viewMatrix = GrTest::TestMatrixInvertible(random);
SkMatrix localMatrix = GrTest::TestMatrix(random);
bool hasLocalRect = random->nextBool();
bool hasLocalMatrix = random->nextBool();
const GrUserStencilSettings* stencil = GrGetRandomStencil(random, context);
GrAAType aaType = GrAAType::kNone;
if (fsaaType == GrFSAAType::kUnifiedMSAA) {
aaType = random->nextBool() ? GrAAType::kMSAA : GrAAType::kNone;
}
return GrNonAAFillRectOp::Make(std::move(paint), viewMatrix, rect,
hasLocalRect ? &localRect : nullptr,
hasLocalMatrix ? &localMatrix : nullptr, aaType, stencil);
const SkRect* lr = random->nextBool() ? &localRect : nullptr;
const SkMatrix* lm = random->nextBool() ? &localMatrix : nullptr;
if (viewMatrix.hasPerspective() || (lm && lm->hasPerspective())) {
return NonAAFillRectOp::Make(std::move(paint), viewMatrix, rect, lr, lm, aaType, stencil);
} else {
return NonAAFillRectPerspectiveOp::Make(std::move(paint), viewMatrix, rect, lr, lm, aaType,
stencil);
}
}

31
src/gpu/ops/GrNonAAFillRectOp.h
View File

@ -1,31 +0,0 @@
/*
* Copyright 2017 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrNonAAFillRectOp_DEFINED
#define GrNonAAFillRectOp_DEFINED
#include <memory>
#include "GrColor.h"
#include "GrDrawOp.h"
class GrPaint;
class SkMatrix;
struct SkRect;
struct GrUserStencilSettings;
enum class GrAAType : unsigned;
namespace GrNonAAFillRectOp {
std::unique_ptr<GrDrawOp> Make(GrPaint&&,
const SkMatrix& viewMatrix,
const SkRect& rect,
const SkRect* localRect,
const SkMatrix* localMatrix,
GrAAType,
const GrUserStencilSettings* = nullptr);
};
#endif

122
src/gpu/ops/GrNonAAStrokeRectOp.cpp
View File

@ -5,15 +5,15 @@
* found in the LICENSE file.
*/
#include "GrNonAAStrokeRectOp.h"
#include "GrColor.h"
#include "GrDefaultGeoProcFactory.h"
#include "GrDrawOpTest.h"
#include "GrMeshDrawOp.h"
#include "GrOpFlushState.h"
#include "SkStrokeRec.h"
#include "GrRectOpFactory.h"
#include "GrSimpleMeshDrawOpHelper.h"
#include "SkRandom.h"
#include "SkStrokeRec.h"
/* create a triangle strip that strokes the specified rect. There are 8
unique vertices, but we repeat the last 2 to close up. Alternatively we
@ -46,7 +46,12 @@ inline static bool allowed_stroke(const SkStrokeRec& stroke) {
(stroke.getJoin() == SkPaint::kMiter_Join && stroke.getMiter() > SK_ScalarSqrt2);
}
class NonAAStrokeRectOp final : public GrLegacyMeshDrawOp {
namespace {
class NonAAStrokeRectOp final : public GrMeshDrawOp {
private:
using Helper = GrSimpleMeshDrawOpHelper;
public:
DEFINE_OP_CLASS_ID
@ -58,31 +63,44 @@ public:
"Color: 0x%08x, Rect [L: %.2f, T: %.2f, R: %.2f, B: %.2f], "
"StrokeWidth: %.2f\n",
fColor, fRect.fLeft, fRect.fTop, fRect.fRight, fRect.fBottom, fStrokeWidth);
string.append(DumpPipelineInfo(*this->pipeline()));
string.append(INHERITED::dumpInfo());
return string;
}
static std::unique_ptr<GrLegacyMeshDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
const SkRect& rect, const SkStrokeRec& stroke,
bool snapToPixelCenters) {
static std::unique_ptr<GrDrawOp> Make(GrPaint&& paint, const SkMatrix& viewMatrix,
const SkRect& rect, const SkStrokeRec& stroke,
GrAAType aaType) {
if (!allowed_stroke(stroke)) {
return nullptr;
}
NonAAStrokeRectOp* op = new NonAAStrokeRectOp();
op->fColor = color;
op->fViewMatrix = viewMatrix;
op->fRect = rect;
// Sort the rect for hairlines
op->fRect.sort();
op->fStrokeWidth = stroke.getWidth();
Helper::Flags flags = Helper::Flags::kNone;
// Depending on sub-pixel coordinates and the particular GPU, we may lose a corner of
// hairline rects. We jam all the vertices to pixel centers to avoid this, but not
// when MSAA is enabled because it can cause ugly artifacts.
if (stroke.getStyle() == SkStrokeRec::kHairline_Style && aaType != GrAAType::kMSAA) {
flags |= Helper::Flags::kSnapVerticesToPixelCenters;
}
return Helper::FactoryHelper<NonAAStrokeRectOp>(std::move(paint), flags, viewMatrix, rect,
stroke, aaType);
}
SkScalar rad = SkScalarHalf(op->fStrokeWidth);
NonAAStrokeRectOp(const Helper::MakeArgs& helperArgs, GrColor color, Helper::Flags flags,
const SkMatrix& viewMatrix, const SkRect& rect, const SkStrokeRec& stroke,
GrAAType aaType)
: INHERITED(ClassID()), fHelper(helperArgs, aaType, flags) {
fColor = color;
fViewMatrix = viewMatrix;
fRect = rect;
// Sort the rect for hairlines
fRect.sort();
fStrokeWidth = stroke.getWidth();
SkScalar rad = SkScalarHalf(fStrokeWidth);
SkRect bounds = rect;
bounds.outset(rad, rad);
// If our caller snaps to pixel centers then we have to round out the bounds
if (snapToPixelCenters) {
if (flags & Helper::Flags::kSnapVerticesToPixelCenters) {
viewMatrix.mapRect(&bounds);
// We want to be consistent with how we snap non-aa lines. To match what we do in
// GrGLSLVertexShaderBuilder, we first floor all the vertex values and then add half a
@ -92,28 +110,27 @@ public:
SkScalarFloorToScalar(bounds.fRight),
SkScalarFloorToScalar(bounds.fBottom));
bounds.offset(0.5f, 0.5f);
op->setBounds(bounds, HasAABloat::kNo, IsZeroArea::kNo);
this->setBounds(bounds, HasAABloat::kNo, IsZeroArea::kNo);
} else {
op->setTransformedBounds(bounds, op->fViewMatrix, HasAABloat::kNo, IsZeroArea::kNo);
this->setTransformedBounds(bounds, fViewMatrix, HasAABloat::kNo, IsZeroArea::kNo);
}
return std::unique_ptr<GrLegacyMeshDrawOp>(op);
}
FixedFunctionFlags fixedFunctionFlags() const override { return fHelper.fixedFunctionFlags(); }
bool xpRequiresDstTexture(const GrCaps& caps, const GrAppliedClip* clip) override {
bool result = fHelper.xpRequiresDstTexture(caps, clip, GrProcessorAnalysisCoverage::kNone,
&fColor);
return result;
}
private:
NonAAStrokeRectOp() : INHERITED(ClassID()) {}
void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
GrProcessorAnalysisCoverage* coverage) const override {
color->setToConstant(fColor);
*coverage = GrProcessorAnalysisCoverage::kNone;
}
void onPrepareDraws(Target* target) const override {
sk_sp<GrGeometryProcessor> gp;
{
using namespace GrDefaultGeoProcFactory;
Color color(fColor);
LocalCoords::Type localCoordsType = fNeedsLocalCoords
LocalCoords::Type localCoordsType = fHelper.usesLocalCoords()
? LocalCoords::kUsePosition_Type
: LocalCoords::kUnused_Type;
gp = GrDefaultGeoProcFactory::Make(color, Coverage::kSolid_Type, localCoordsType,
@ -159,12 +176,7 @@ private:
GrMesh mesh(primType);
mesh.setNonIndexedNonInstanced(vertexCount);
mesh.setVertexData(vertexBuffer, firstVertex);
target->draw(gp.get(), this->pipeline(), mesh);
}
void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
optimizations.getOverrideColorIfSet(&fColor);
fNeedsLocalCoords = optimizations.readsLocalCoords();
target->draw(gp.get(), fHelper.makePipeline(target), mesh);
}
bool onCombineIfPossible(GrOp* t, const GrCaps&) override {
@ -173,42 +185,46 @@ private:
return false;
}
Helper fHelper;
GrColor fColor;
SkMatrix fViewMatrix;
SkRect fRect;
SkScalar fStrokeWidth;
bool fNeedsLocalCoords;
const static int kVertsPerHairlineRect = 5;
const static int kVertsPerStrokeRect = 10;
typedef GrLegacyMeshDrawOp INHERITED;
typedef GrMeshDrawOp INHERITED;
};
namespace GrNonAAStrokeRectOp {
} // anonymous namespace
std::unique_ptr<GrLegacyMeshDrawOp> Make(GrColor color,
const SkMatrix& viewMatrix,
const SkRect& rect,
const SkStrokeRec& stroke,
bool snapToPixelCenters) {
return NonAAStrokeRectOp::Make(color, viewMatrix, rect, stroke, snapToPixelCenters);
}
namespace GrRectOpFactory {
std::unique_ptr<GrDrawOp> MakeNonAAStroke(GrPaint&& paint,
const SkMatrix& viewMatrix,
const SkRect& rect,
const SkStrokeRec& stroke,
GrAAType aaType) {
return NonAAStrokeRectOp::Make(std::move(paint), viewMatrix, rect, stroke, aaType);
}
} // namespace GrRectOpFactory
#if GR_TEST_UTILS
GR_LEGACY_MESH_DRAW_OP_TEST_DEFINE(NonAAStrokeRectOp) {
GR_DRAW_OP_TEST_DEFINE(NonAAStrokeRectOp) {
SkMatrix viewMatrix = GrTest::TestMatrix(random);
GrColor color = GrRandomColor(random);
SkRect rect = GrTest::TestRect(random);
SkScalar strokeWidth = random->nextBool() ? 0.0f : 2.0f;
SkPaint paint;
paint.setStrokeWidth(strokeWidth);
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeJoin(SkPaint::kMiter_Join);
SkStrokeRec strokeRec(paint);
return GrNonAAStrokeRectOp::Make(color, viewMatrix, rect, strokeRec, random->nextBool());
SkPaint strokePaint;
strokePaint.setStrokeWidth(strokeWidth);
strokePaint.setStyle(SkPaint::kStroke_Style);
strokePaint.setStrokeJoin(SkPaint::kMiter_Join);
SkStrokeRec strokeRec(strokePaint);
GrAAType aaType = GrAAType::kNone;
if (fsaaType == GrFSAAType::kUnifiedMSAA) {
aaType = random->nextBool() ? GrAAType::kMSAA : GrAAType::kNone;
}
return NonAAStrokeRectOp::Make(std::move(paint), viewMatrix, rect, strokeRec, aaType);
}
#endif

28
src/gpu/ops/GrNonAAStrokeRectOp.h
View File

@ -1,28 +0,0 @@
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrNonAAStrokeRectOp_DEFINED
#define GrNonAAStrokeRectOp_DEFINED
#include "GrColor.h"
#include "SkRefCnt.h"
class GrLegacyMeshDrawOp;
struct SkRect;
class SkStrokeRec;
class SkMatrix;
namespace GrNonAAStrokeRectOp {
std::unique_ptr<GrLegacyMeshDrawOp> Make(GrColor color,
const SkMatrix& viewMatrix,
const SkRect& rect,
const SkStrokeRec&,
bool snapToPixelCenters);
}
#endif

34
src/gpu/ops/GrRectOpFactory.cpp
View File

@ -1,34 +0,0 @@
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "GrRectOpFactory.h"
#include "GrAAStrokeRectOp.h"
#include "GrMeshDrawOp.h"
#include "SkStrokeRec.h"
namespace GrRectOpFactory {
std::unique_ptr<GrLegacyMeshDrawOp> MakeAAFillNestedRects(GrColor color,
const SkMatrix& viewMatrix,
const SkRect rects[2]) {
SkASSERT(viewMatrix.rectStaysRect());
SkASSERT(!rects[0].isEmpty() && !rects[1].isEmpty());
SkRect devOutside, devInside;
viewMatrix.mapRect(&devOutside, rects[0]);
viewMatrix.mapRect(&devInside, rects[1]);
if (devInside.isEmpty()) {
if (devOutside.isEmpty()) {
return nullptr;
}
return GrAAFillRectOp::Make(color, viewMatrix, devOutside, devOutside);
}
return GrAAStrokeRectOp::MakeFillBetweenRects(color, viewMatrix, devOutside, devInside);
}
};

92
src/gpu/ops/GrRectOpFactory.h
View File

@ -1,5 +1,5 @@
/*
* Copyright 2015 Google Inc.
* Copyright 2017 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
@ -8,58 +8,66 @@
#ifndef GrRectOpFactory_DEFINED
#define GrRectOpFactory_DEFINED
#include "GrAAFillRectOp.h"
#include "GrAAStrokeRectOp.h"
#include "GrAnalyticRectOp.h"
#include "GrColor.h"
#include "GrMeshDrawOp.h"
#include "GrNonAAStrokeRectOp.h"
#include "GrPaint.h"
#include "SkMatrix.h"
#include "SkRefCnt.h"
#include <memory>
#include "GrTypes.h"
enum class GrAAType : unsigned;
class GrDrawOp;
class GrPaint;
struct GrUserStencilSettings;
class SkMatrix;
struct SkRect;
class SkStrokeRec;
/**
* A factory for returning GrDrawOps which can draw rectangles.
* A set of factory functions for drawing rectangles including fills, strokes, coverage-antialiased,
* and non-antialiased. The non-antialiased ops can be used with MSAA. As with other GrDrawOp
* factories, the GrPaint is only consumed by these methods if a valid op is returned. If null is
* returned then the paint is unmodified and may still be used.
*/
namespace GrRectOpFactory {
/** AA Fill */
inline std::unique_ptr<GrLegacyMeshDrawOp> MakeAAFill(const GrPaint& paint,
const SkMatrix& viewMatrix,
const SkRect& rect,
const SkRect& croppedRect,
const SkRect& devRect) {
return GrAAFillRectOp::Make(paint.getColor(), viewMatrix, croppedRect, devRect);
}
std::unique_ptr<GrDrawOp> MakeAAFill(GrPaint&&, const SkMatrix&, const SkRect&,
const GrUserStencilSettings* = nullptr);
inline std::unique_ptr<GrLegacyMeshDrawOp> MakeAAFill(GrColor color,
const SkMatrix& viewMatrix,
const SkMatrix& localMatrix,
const SkRect& rect,
const SkRect& devRect) {
return GrAAFillRectOp::Make(color, viewMatrix, localMatrix, rect, devRect);
}
// Using this method to supply a device rect simply saves recalculation if the device rect is known.
std::unique_ptr<GrDrawOp> MakeAAFillWithDevRect(GrPaint&&, const SkMatrix& viewMatrix,
const SkRect& rect, const SkRect& devRect);
inline std::unique_ptr<GrLegacyMeshDrawOp> MakeNonAAStroke(GrColor color,
const SkMatrix& viewMatrix,
const SkRect& rect,
const SkStrokeRec& strokeRec,
bool snapToPixelCenters) {
return GrNonAAStrokeRectOp::Make(color, viewMatrix, rect, strokeRec, snapToPixelCenters);
}
std::unique_ptr<GrDrawOp> MakeAAFillWithLocalMatrix(GrPaint&&, const SkMatrix& viewMatrix,
const SkMatrix& localMatrix, const SkRect&);
inline std::unique_ptr<GrLegacyMeshDrawOp> MakeAAStroke(GrColor color,
const SkMatrix& viewMatrix,
const SkRect& rect,
const SkStrokeRec& stroke) {
return GrAAStrokeRectOp::Make(color, viewMatrix, rect, stroke);
}
std::unique_ptr<GrDrawOp> MakeAAFillWithLocalRect(GrPaint&&, const SkMatrix&, const SkRect& rect,
const SkRect& localRect);
// First rect is outer; second rect is inner
std::unique_ptr<GrLegacyMeshDrawOp> MakeAAFillNestedRects(GrColor, const SkMatrix& viewMatrix,
const SkRect rects[2]);
};
/** Non-AA Fill - GrAAType must be either kNone or kMSAA. */
std::unique_ptr<GrDrawOp> MakeNonAAFill(GrPaint&&, const SkMatrix& viewMatrix, const SkRect& rect,
GrAAType, const GrUserStencilSettings* = nullptr);
std::unique_ptr<GrDrawOp> MakeNonAAFillWithLocalMatrix(GrPaint&&, const SkMatrix& viewMatrix,
const SkMatrix& localMatrix, const SkRect&,
GrAAType,
const GrUserStencilSettings* = nullptr);
std::unique_ptr<GrDrawOp> MakeNonAAFillWithLocalRect(GrPaint&&, const SkMatrix&, const SkRect& rect,
const SkRect& localRect, GrAAType);
/** AA Stroke */
std::unique_ptr<GrDrawOp> MakeAAStroke(GrPaint&&, const SkMatrix&, const SkRect&,
const SkStrokeRec&);
// rects[0] == outer rectangle, rects[1] == inner rectangle. Null return means there is nothing to
// draw rather than failure.
std::unique_ptr<GrDrawOp> MakeAAFillNestedRects(GrPaint&&, const SkMatrix&, const SkRect rects[2]);
/** Non-AA Stroke - GrAAType must be either kNone or kMSAA. */
std::unique_ptr<GrDrawOp> MakeNonAAStroke(GrPaint&&, const SkMatrix&, const SkRect&,
const SkStrokeRec&, GrAAType);
} // namespace GrRectOpFactory
#endif

22
src/gpu/ops/GrSimpleMeshDrawOpHelper.h
View File

@ -35,19 +35,26 @@ public:
template <typename Op, typename... OpArgs>
static std::unique_ptr<GrDrawOp> FactoryHelper(GrPaint&& paint, OpArgs... opArgs);
GrSimpleMeshDrawOpHelper(const MakeArgs& args, GrAAType aaType,
GrUserStencilSettings* stencilSettings = nullptr)
enum class Flags : uint32_t {
kNone = 0x0,
kSnapVerticesToPixelCenters = 0x1,
};
GR_DECL_BITFIELD_CLASS_OPS_FRIENDS(Flags);
GrSimpleMeshDrawOpHelper(const MakeArgs& args, GrAAType aaType, Flags flags = Flags::kNone)
: fProcessors(args.fProcessorSet)
, fPipelineFlags(args.fSRGBFlags)
, fAAType((int)aaType)
, fRequiresDstTexture(false)
, fUsesLocalCoords(false)
, fCompatibleWithAlphaAsCoveage(false) {
SkASSERT(!stencilSettings);
SkDEBUGCODE(fDidAnalysis = false);
if (GrAATypeIsHW(aaType)) {
fPipelineFlags |= GrPipeline::kHWAntialias_Flag;
}
if (flags & Flags::kSnapVerticesToPixelCenters) {
fPipelineFlags |= GrPipeline::kSnapVerticesToPixelCenters_Flag;
}
}
~GrSimpleMeshDrawOpHelper() {
@ -167,6 +174,7 @@ private:
class GrSimpleMeshDrawOpHelperWithStencil : private GrSimpleMeshDrawOpHelper {
public:
using MakeArgs = GrSimpleMeshDrawOpHelper::MakeArgs;
using Flags = GrSimpleMeshDrawOpHelper::Flags;
// using declarations can't be templated, so this is a pass through function instead.
template <typename Op, typename... OpArgs>
@ -176,8 +184,9 @@ public:
}
GrSimpleMeshDrawOpHelperWithStencil(const MakeArgs& args, GrAAType aaType,
const GrUserStencilSettings* stencilSettings)
: INHERITED(args, aaType)
const GrUserStencilSettings* stencilSettings,
Flags flags = Flags::kNone)
: INHERITED(args, aaType, flags)
, fStencilSettings(stencilSettings ? stencilSettings
: &GrUserStencilSettings::kUnused) {}
@ -191,6 +200,7 @@ public:
using GrSimpleMeshDrawOpHelper::xpRequiresDstTexture;
using GrSimpleMeshDrawOpHelper::usesLocalCoords;
using GrSimpleMeshDrawOpHelper::compatibleWithAlphaAsCoverage;
bool isCompatible(const GrSimpleMeshDrawOpHelperWithStencil& that, const GrCaps& caps,
const SkRect& aBounds, const SkRect& bBounds) const {
@ -227,4 +237,6 @@ std::unique_ptr<GrDrawOp> GrSimpleMeshDrawOpHelper::FactoryHelper(GrPaint&& pain
}
}
GR_MAKE_BITFIELD_CLASS_OPS(GrSimpleMeshDrawOpHelper::Flags)
#endif

10
src/gpu/ops/GrStencilAndCoverPathRenderer.cpp
View File

@ -17,7 +17,7 @@
#include "GrResourceProvider.h"
#include "GrStencilPathOp.h"
#include "GrStyle.h"
#include "ops/GrNonAAFillRectOp.h"
#include "ops/GrRectOpFactory.h"
GrPathRenderer* GrStencilAndCoverPathRenderer::Create(GrResourceProvider* resourceProvider,
const GrCaps& caps) {
@ -134,10 +134,10 @@ bool GrStencilAndCoverPathRenderer::onDrawPath(const DrawPathArgs& args) {
if (GrAAType::kMixedSamples == coverAAType) {
coverAAType = GrAAType::kNone;
}
args.fRenderTargetContext->addDrawOp(
*args.fClip,
GrNonAAFillRectOp::Make(std::move(args.fPaint), viewM, bounds, nullptr, &invert,
coverAAType, &kInvertedCoverPass));
args.fRenderTargetContext->addDrawOp(*args.fClip,
GrRectOpFactory::MakeNonAAFillWithLocalMatrix(
std::move(args.fPaint), viewM, invert,
bounds, coverAAType, &kInvertedCoverPass));
}
} else {
std::unique_ptr<GrDrawOp> op =

8
tests/ProcessorTest.cpp
View File

@ -19,7 +19,7 @@
#include "GrResourceProvider.h"
#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "ops/GrNonAAFillRectOp.h"
#include "ops/GrRectOpFactory.h"
#include "ops/GrTestMeshDrawOp.h"
namespace {
@ -270,9 +270,9 @@ void test_draw_op(GrRenderTargetContext* rtc, sk_sp<GrFragmentProcessor> fp,
paint.addColorFragmentProcessor(std::move(fp));
paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
auto op = GrNonAAFillRectOp::Make(std::move(paint), SkMatrix::I(),
SkRect::MakeWH(rtc->width(), rtc->height()), nullptr, nullptr,
GrAAType::kNone);
auto op = GrRectOpFactory::MakeNonAAFill(std::move(paint), SkMatrix::I(),
SkRect::MakeWH(rtc->width(), rtc->height()),
GrAAType::kNone);
rtc->addDrawOp(GrNoClip(), std::move(op));
}

14
tools/gpu/GrTest.cpp
View File

@ -472,25 +472,24 @@ void GrDrawingManager::testingOnly_removeOnFlushCallbackObject(GrOnFlushCallback
#define DRAW_OP_TEST_ENTRY(Op) Op##__Test
LEGACY_MESH_DRAW_OP_TEST_EXTERN(AAConvexPathOp);
LEGACY_MESH_DRAW_OP_TEST_EXTERN(AAFillRectOp);
LEGACY_MESH_DRAW_OP_TEST_EXTERN(AAFillRectOpLocalMatrix);
LEGACY_MESH_DRAW_OP_TEST_EXTERN(AAFlatteningConvexPathOp)
LEGACY_MESH_DRAW_OP_TEST_EXTERN(AAHairlineOp);
LEGACY_MESH_DRAW_OP_TEST_EXTERN(AAStrokeRectOp);
LEGACY_MESH_DRAW_OP_TEST_EXTERN(AnalyticRectOp);
LEGACY_MESH_DRAW_OP_TEST_EXTERN(DashOp);
LEGACY_MESH_DRAW_OP_TEST_EXTERN(DefaultPathOp);
LEGACY_MESH_DRAW_OP_TEST_EXTERN(GrDrawAtlasOp);
LEGACY_MESH_DRAW_OP_TEST_EXTERN(NonAAStrokeRectOp);
LEGACY_MESH_DRAW_OP_TEST_EXTERN(SmallPathOp);
LEGACY_MESH_DRAW_OP_TEST_EXTERN(TesselatingPathOp);
LEGACY_MESH_DRAW_OP_TEST_EXTERN(TextBlobOp);
LEGACY_MESH_DRAW_OP_TEST_EXTERN(VerticesOp);
DRAW_OP_TEST_EXTERN(AAFillRectOp)
DRAW_OP_TEST_EXTERN(AAStrokeRectOp);
DRAW_OP_TEST_EXTERN(CircleOp)
DRAW_OP_TEST_EXTERN(DIEllipseOp);
DRAW_OP_TEST_EXTERN(EllipseOp);
DRAW_OP_TEST_EXTERN(NonAAFillRectOp)
DRAW_OP_TEST_EXTERN(NonAAStrokeRectOp);
DRAW_OP_TEST_EXTERN(RRectOp);
void GrDrawRandomOp(SkRandom* random, GrRenderTargetContext* renderTargetContext, GrPaint&& paint) {
@ -498,16 +497,12 @@ void GrDrawRandomOp(SkRandom* random, GrRenderTargetContext* renderTargetContext
using MakeTestLegacyMeshDrawOpFn = std::unique_ptr<GrLegacyMeshDrawOp>(SkRandom*, GrContext*);
static constexpr MakeTestLegacyMeshDrawOpFn* gLegacyFactories[] = {
DRAW_OP_TEST_ENTRY(AAConvexPathOp),
DRAW_OP_TEST_ENTRY(AAFillRectOp),
DRAW_OP_TEST_ENTRY(AAFillRectOpLocalMatrix),
DRAW_OP_TEST_ENTRY(AAFlatteningConvexPathOp),
DRAW_OP_TEST_ENTRY(AAHairlineOp),
DRAW_OP_TEST_ENTRY(AAStrokeRectOp),
DRAW_OP_TEST_ENTRY(AnalyticRectOp),
DRAW_OP_TEST_ENTRY(DashOp),
DRAW_OP_TEST_ENTRY(DefaultPathOp),
DRAW_OP_TEST_ENTRY(GrDrawAtlasOp),
DRAW_OP_TEST_ENTRY(NonAAStrokeRectOp),
DRAW_OP_TEST_ENTRY(SmallPathOp),
DRAW_OP_TEST_ENTRY(TesselatingPathOp),
DRAW_OP_TEST_ENTRY(TextBlobOp),
@ -516,10 +511,13 @@ void GrDrawRandomOp(SkRandom* random, GrRenderTargetContext* renderTargetContext
using MakeDrawOpFn = std::unique_ptr<GrDrawOp>(GrPaint&&, SkRandom*, GrContext*, GrFSAAType);
static constexpr MakeDrawOpFn* gFactories[] = {
DRAW_OP_TEST_ENTRY(AAFillRectOp),
DRAW_OP_TEST_ENTRY(AAStrokeRectOp),
DRAW_OP_TEST_ENTRY(CircleOp),
DRAW_OP_TEST_ENTRY(DIEllipseOp),
DRAW_OP_TEST_ENTRY(EllipseOp),
DRAW_OP_TEST_ENTRY(NonAAFillRectOp),
DRAW_OP_TEST_ENTRY(NonAAStrokeRectOp),
DRAW_OP_TEST_ENTRY(RRectOp),
};