Add a separate draw function to GrRenderTargetContext for GrMeshDrawOp derived classes.
The first phase of deferring GrPipeline creation until flush will apply only to GrDrawOp subclasses that do not derive from GrMeshDrawOp. This change prepares for that by creating separate draw functions on GrRenderTargetContext for GrMeshDrawOp-derived ops. This is temporary and will incrementally be undone as pipeline-creation deferral rolls out to the GrMeshDrawOps in a later phase of this work.
Change-Id: I0f5b71fe913f3273cfe9e965f7d8bbe7f01ad0ef
Reviewed-on: https://skia-review.googlesource.com/9481
Commit-Queue: Brian Salomon <bsalomon@google.com>
Reviewed-by: Robert Phillips <robertphillips@google.com>
diff --git a/gm/beziereffects.cpp b/gm/beziereffects.cpp
index d2d4aa9..54c28a7 100644
--- a/gm/beziereffects.cpp
+++ b/gm/beziereffects.cpp
@@ -34,9 +34,10 @@
const char* name() const override { return "BezierCubicOrConicTestOp"; }
- static std::unique_ptr<GrDrawOp> Make(sk_sp<GrGeometryProcessor> gp, const SkRect& rect,
- GrColor color, const SkScalar klmEqs[9], SkScalar sign) {
- return std::unique_ptr<GrDrawOp>(
+ static std::unique_ptr<GrMeshDrawOp> Make(sk_sp<GrGeometryProcessor> gp, const SkRect& rect,
+ GrColor color, const SkScalar klmEqs[9],
+ SkScalar sign) {
+ return std::unique_ptr<GrMeshDrawOp>(
new BezierCubicOrConicTestOp(gp, rect, color, klmEqs, sign));
}
@@ -195,10 +196,10 @@
GrPaint grPaint;
grPaint.setXPFactory(GrPorterDuffXPFactory::Get(SkBlendMode::kSrc));
- std::unique_ptr<GrDrawOp> op =
+ std::unique_ptr<GrMeshDrawOp> op =
BezierCubicOrConicTestOp::Make(gp, bounds, color, klmEqs, klmSigns[c]);
- renderTargetContext->priv().testingOnly_addDrawOp(
+ renderTargetContext->priv().testingOnly_addMeshDrawOp(
std::move(grPaint), GrAAType::kNone, std::move(op));
}
++col;
@@ -328,10 +329,10 @@
GrPaint grPaint;
grPaint.setXPFactory(GrPorterDuffXPFactory::Get(SkBlendMode::kSrc));
- std::unique_ptr<GrDrawOp> op =
+ std::unique_ptr<GrMeshDrawOp> op =
BezierCubicOrConicTestOp::Make(gp, bounds, color, klmEqs, 1.f);
- renderTargetContext->priv().testingOnly_addDrawOp(
+ renderTargetContext->priv().testingOnly_addMeshDrawOp(
std::move(grPaint), GrAAType::kNone, std::move(op));
}
++col;
@@ -394,9 +395,10 @@
DEFINE_OP_CLASS_ID
const char* name() const override { return "BezierQuadTestOp"; }
- static std::unique_ptr<GrDrawOp> Make(sk_sp<GrGeometryProcessor> gp, const SkRect& rect,
- GrColor color, const GrPathUtils::QuadUVMatrix& devToUV) {
- return std::unique_ptr<GrDrawOp>(new BezierQuadTestOp(gp, rect, color, devToUV));
+ static std::unique_ptr<GrMeshDrawOp> Make(sk_sp<GrGeometryProcessor> gp, const SkRect& rect,
+ GrColor color,
+ const GrPathUtils::QuadUVMatrix& devToUV) {
+ return std::unique_ptr<GrMeshDrawOp>(new BezierQuadTestOp(gp, rect, color, devToUV));
}
private:
@@ -545,10 +547,10 @@
GrPathUtils::QuadUVMatrix DevToUV(pts);
- std::unique_ptr<GrDrawOp> op =
+ std::unique_ptr<GrMeshDrawOp> op =
BezierQuadTestOp::Make(gp, bounds, color, DevToUV);
- renderTargetContext->priv().testingOnly_addDrawOp(
+ renderTargetContext->priv().testingOnly_addMeshDrawOp(
std::move(grPaint), GrAAType::kNone, std::move(op));
}
++col;
diff --git a/gm/bigrrectaaeffect.cpp b/gm/bigrrectaaeffect.cpp
index f4e00fb..94e7339 100644
--- a/gm/bigrrectaaeffect.cpp
+++ b/gm/bigrrectaaeffect.cpp
@@ -86,9 +86,9 @@
SkRect bounds = testBounds;
bounds.offset(SkIntToScalar(x), SkIntToScalar(y));
- std::unique_ptr<GrDrawOp> op(GrRectOpFactory::MakeNonAAFill(
+ std::unique_ptr<GrMeshDrawOp> op(GrRectOpFactory::MakeNonAAFill(
0xff000000, SkMatrix::I(), bounds, nullptr, nullptr));
- renderTargetContext->priv().testingOnly_addDrawOp(
+ renderTargetContext->priv().testingOnly_addMeshDrawOp(
std::move(grPaint), GrAAType::kNone, std::move(op));
}
canvas->restore();
diff --git a/gm/constcolorprocessor.cpp b/gm/constcolorprocessor.cpp
index 831ba69..cf20879 100644
--- a/gm/constcolorprocessor.cpp
+++ b/gm/constcolorprocessor.cpp
@@ -109,9 +109,9 @@
grPaint.addColorFragmentProcessor(std::move(fp));
- std::unique_ptr<GrDrawOp> op(GrRectOpFactory::MakeNonAAFill(
+ std::unique_ptr<GrMeshDrawOp> op(GrRectOpFactory::MakeNonAAFill(
grPaint.getColor(), viewMatrix, renderRect, nullptr, nullptr));
- renderTargetContext->priv().testingOnly_addDrawOp(
+ renderTargetContext->priv().testingOnly_addMeshDrawOp(
std::move(grPaint), GrAAType::kNone, std::move(op));
// Draw labels for the input to the processor and the processor to the right of
diff --git a/gm/convexpolyeffect.cpp b/gm/convexpolyeffect.cpp
index 1be92da..0ce7ba7 100644
--- a/gm/convexpolyeffect.cpp
+++ b/gm/convexpolyeffect.cpp
@@ -46,8 +46,8 @@
const char* name() const override { return "PolyBoundsOp"; }
- static std::unique_ptr<GrDrawOp> Make(const SkRect& rect, GrColor color) {
- return std::unique_ptr<GrDrawOp>(new PolyBoundsOp(rect, color));
+ static std::unique_ptr<GrMeshDrawOp> Make(const SkRect& rect, GrColor color) {
+ return std::unique_ptr<GrMeshDrawOp>(new PolyBoundsOp(rect, color));
}
private:
@@ -183,10 +183,10 @@
grPaint.setXPFactory(GrPorterDuffXPFactory::Get(SkBlendMode::kSrc));
grPaint.addCoverageFragmentProcessor(std::move(fp));
- std::unique_ptr<GrDrawOp> op = PolyBoundsOp::Make(p.getBounds(), 0xff000000);
+ std::unique_ptr<GrMeshDrawOp> op = PolyBoundsOp::Make(p.getBounds(), 0xff000000);
- renderTargetContext->priv().testingOnly_addDrawOp(std::move(grPaint),
- GrAAType::kNone, std::move(op));
+ renderTargetContext->priv().testingOnly_addMeshDrawOp(
+ std::move(grPaint), GrAAType::kNone, std::move(op));
x += SkScalarCeilToScalar(path->getBounds().width() + kDX);
}
@@ -223,10 +223,10 @@
grPaint.setXPFactory(GrPorterDuffXPFactory::Get(SkBlendMode::kSrc));
grPaint.addCoverageFragmentProcessor(std::move(fp));
- std::unique_ptr<GrDrawOp> op = PolyBoundsOp::Make(rect, 0xff000000);
+ std::unique_ptr<GrMeshDrawOp> op = PolyBoundsOp::Make(rect, 0xff000000);
- renderTargetContext->priv().testingOnly_addDrawOp(std::move(grPaint),
- GrAAType::kNone, std::move(op));
+ renderTargetContext->priv().testingOnly_addMeshDrawOp(
+ std::move(grPaint), GrAAType::kNone, std::move(op));
x += SkScalarCeilToScalar(rect.width() + kDX);
}
diff --git a/gm/etc1.cpp b/gm/etc1.cpp
index e960a26..d35f144 100644
--- a/gm/etc1.cpp
+++ b/gm/etc1.cpp
@@ -99,10 +99,10 @@
SkRect rect = SkRect::MakeXYWH(kPad, kPad, kTexWidth, kTexHeight);
- std::unique_ptr<GrDrawOp> op(GrRectOpFactory::MakeNonAAFill(
+ std::unique_ptr<GrMeshDrawOp> op(GrRectOpFactory::MakeNonAAFill(
GrColor_WHITE, SkMatrix::I(), rect, nullptr, nullptr));
- renderTargetContext->priv().testingOnly_addDrawOp(
- std::move(grPaint), GrAAType::kNone, std::move(op));
+ renderTargetContext->priv().testingOnly_addMeshDrawOp(std::move(grPaint), GrAAType::kNone,
+ std::move(op));
}
private:
diff --git a/gm/rrects.cpp b/gm/rrects.cpp
index d4f5bdf..032b0c3 100644
--- a/gm/rrects.cpp
+++ b/gm/rrects.cpp
@@ -114,9 +114,9 @@
SkRect bounds = rrect.getBounds();
bounds.outset(2.f, 2.f);
- std::unique_ptr<GrDrawOp> op(GrRectOpFactory::MakeNonAAFill(
+ std::unique_ptr<GrMeshDrawOp> op(GrRectOpFactory::MakeNonAAFill(
0xff000000, SkMatrix::I(), bounds, nullptr, nullptr));
- renderTargetContext->priv().testingOnly_addDrawOp(
+ renderTargetContext->priv().testingOnly_addMeshDrawOp(
std::move(grPaint), GrAAType::kNone, std::move(op));
} else {
drew = false;
diff --git a/gm/texturedomaineffect.cpp b/gm/texturedomaineffect.cpp
index 2d96bea..3d68ead 100644
--- a/gm/texturedomaineffect.cpp
+++ b/gm/texturedomaineffect.cpp
@@ -135,9 +135,9 @@
const SkMatrix viewMatrix = SkMatrix::MakeTrans(x, y);
grPaint.addColorFragmentProcessor(std::move(fp));
- std::unique_ptr<GrDrawOp> op(GrRectOpFactory::MakeNonAAFill(
+ std::unique_ptr<GrMeshDrawOp> op(GrRectOpFactory::MakeNonAAFill(
GrColor_WHITE, viewMatrix, renderRect, nullptr, nullptr));
- renderTargetContext->priv().testingOnly_addDrawOp(
+ renderTargetContext->priv().testingOnly_addMeshDrawOp(
std::move(grPaint), GrAAType::kNone, std::move(op));
x += renderRect.width() + kTestPad;
}
diff --git a/gm/yuvtorgbeffect.cpp b/gm/yuvtorgbeffect.cpp
index 85f31d2..5bfcc69 100644
--- a/gm/yuvtorgbeffect.cpp
+++ b/gm/yuvtorgbeffect.cpp
@@ -133,9 +133,9 @@
grPaint.addColorFragmentProcessor(std::move(fp));
SkMatrix viewMatrix;
viewMatrix.setTranslate(x, y);
- std::unique_ptr<GrDrawOp> op(GrRectOpFactory::MakeNonAAFill(
+ std::unique_ptr<GrMeshDrawOp> op(GrRectOpFactory::MakeNonAAFill(
GrColor_WHITE, viewMatrix, renderRect, nullptr, nullptr));
- renderTargetContext->priv().testingOnly_addDrawOp(
+ renderTargetContext->priv().testingOnly_addMeshDrawOp(
std::move(grPaint), GrAAType::kNone, std::move(op));
}
x += renderRect.width() + kTestPad;
@@ -258,10 +258,10 @@
SkMatrix viewMatrix;
viewMatrix.setTranslate(x, y);
grPaint.addColorFragmentProcessor(fp);
- std::unique_ptr<GrDrawOp> op(GrRectOpFactory::MakeNonAAFill(
+ std::unique_ptr<GrMeshDrawOp> op(GrRectOpFactory::MakeNonAAFill(
GrColor_WHITE, viewMatrix, renderRect, nullptr, nullptr));
- renderTargetContext->priv().testingOnly_addDrawOp(std::move(grPaint),
- GrAAType::kNone, std::move(op));
+ renderTargetContext->priv().testingOnly_addMeshDrawOp(
+ std::move(grPaint), GrAAType::kNone, std::move(op));
}
}
}
diff --git a/src/gpu/GrDrawOpTest.cpp b/src/gpu/GrDrawOpTest.cpp
index fcf70e0..c2bf2c6 100644
--- a/src/gpu/GrDrawOpTest.cpp
+++ b/src/gpu/GrDrawOpTest.cpp
@@ -6,14 +6,14 @@
*/
#include "GrDrawOpTest.h"
-#include "ops/GrDrawOp.h"
#include "SkRandom.h"
#include "SkTypes.h"
+#include "ops/GrMeshDrawOp.h"
#if GR_TEST_UTILS
#define DRAW_OP_TEST_EXTERN(Op) \
- extern std::unique_ptr<GrDrawOp> Op##__Test(SkRandom*, GrContext* context);
+ extern std::unique_ptr<GrMeshDrawOp> Op##__Test(SkRandom*, GrContext* context);
#define DRAW_OP_TEST_ENTRY(Op) Op##__Test
@@ -37,8 +37,8 @@
DRAW_OP_TEST_EXTERN(TextBlobOp);
DRAW_OP_TEST_EXTERN(VerticesOp);
-std::unique_ptr<GrDrawOp> GrRandomDrawOp(SkRandom* random, GrContext* context) {
- using MakeTestDrawOpFn = std::unique_ptr<GrDrawOp>(SkRandom* random, GrContext* context);
+std::unique_ptr<GrMeshDrawOp> GrRandomDrawOp(SkRandom* random, GrContext* context) {
+ using MakeTestDrawOpFn = std::unique_ptr<GrMeshDrawOp>(SkRandom* random, GrContext* context);
static constexpr MakeTestDrawOpFn* gFactories[] = {
DRAW_OP_TEST_ENTRY(AAConvexPathOp),
DRAW_OP_TEST_ENTRY(AADistanceFieldPathOp),
diff --git a/src/gpu/GrDrawOpTest.h b/src/gpu/GrDrawOpTest.h
index 8c98597..43bd21a 100644
--- a/src/gpu/GrDrawOpTest.h
+++ b/src/gpu/GrDrawOpTest.h
@@ -13,20 +13,20 @@
#if GR_TEST_UTILS
-class GrDrawOp;
class GrContext;
+class GrMeshDrawOp;
class SkRandom;
/** This function returns a randomly configured GrDrawOp for testing purposes. */
-std::unique_ptr<GrDrawOp> GrRandomDrawOp(SkRandom*, GrContext*);
+std::unique_ptr<GrMeshDrawOp> GrRandomDrawOp(SkRandom*, GrContext*);
/** GrDrawOp subclasses should define test factory functions using this macro. */
#define DRAW_OP_TEST_DEFINE(Op) \
- std::unique_ptr<GrDrawOp> Op##__Test(SkRandom* random, GrContext* context)
+ std::unique_ptr<GrMeshDrawOp> Op##__Test(SkRandom* random, GrContext* context)
/** This macro may be used if the test factory function must be made a friend of a class. */
#define DRAW_OP_TEST_FRIEND(Op) \
- friend std::unique_ptr<GrDrawOp> Op##__Test(SkRandom* random, GrContext* context);
+ friend std::unique_ptr<GrMeshDrawOp> Op##__Test(SkRandom* random, GrContext* context);
#endif
#endif
diff --git a/src/gpu/GrRenderTargetContext.cpp b/src/gpu/GrRenderTargetContext.cpp
index 1d891df..5937054 100644
--- a/src/gpu/GrRenderTargetContext.cpp
+++ b/src/gpu/GrRenderTargetContext.cpp
@@ -507,13 +507,12 @@
return true;
}
- std::unique_ptr<GrDrawOp> op;
GrAAType aaType;
if (GrCaps::InstancedSupport::kNone != fContext->caps()->instancedSupport()) {
InstancedRendering* ir = this->getOpList()->instancedRendering();
- op = ir->recordRect(croppedRect, viewMatrix, paint.getColor(), aa, fInstancedPipelineInfo,
- &aaType);
+ std::unique_ptr<GrDrawOp> op = ir->recordRect(croppedRect, viewMatrix, paint.getColor(), aa,
+ fInstancedPipelineInfo, &aaType);
if (op) {
GrPipelineBuilder pipelineBuilder(std::move(paint), aaType);
if (ss) {
@@ -529,14 +528,14 @@
if (view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
SkRect devBoundRect;
viewMatrix.mapRect(&devBoundRect, croppedRect);
-
- op = GrRectOpFactory::MakeAAFill(paint, viewMatrix, rect, croppedRect, devBoundRect);
+ std::unique_ptr<GrMeshDrawOp> op =
+ GrRectOpFactory::MakeAAFill(paint, viewMatrix, rect, croppedRect, devBoundRect);
if (op) {
GrPipelineBuilder pipelineBuilder(std::move(paint), aaType);
if (ss) {
pipelineBuilder.setUserStencil(ss);
}
- this->addDrawOp(pipelineBuilder, clip, std::move(op));
+ this->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
return true;
}
}
@@ -637,7 +636,7 @@
}
bool snapToPixelCenters = false;
- std::unique_ptr<GrDrawOp> op;
+ std::unique_ptr<GrMeshDrawOp> op;
GrColor color = paint.getColor();
GrAAType aaType = this->decideAAType(aa);
@@ -659,7 +658,7 @@
if (op) {
GrPipelineBuilder pipelineBuilder(std::move(paint), aaType);
pipelineBuilder.setSnapVerticesToPixelCenters(snapToPixelCenters);
- this->addDrawOp(pipelineBuilder, clip, std::move(op));
+ this->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
return;
}
}
@@ -893,10 +892,10 @@
}
if (view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
- std::unique_ptr<GrDrawOp> op =
+ std::unique_ptr<GrMeshDrawOp> op =
GrAAFillRectOp::Make(paint.getColor(), viewMatrix, localMatrix, croppedRect);
GrPipelineBuilder pipelineBuilder(std::move(paint), aaType);
- this->addDrawOp(pipelineBuilder, clip, std::move(op));
+ this->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
return;
}
@@ -939,14 +938,14 @@
return;
}
- std::unique_ptr<GrDrawOp> op = GrDrawVerticesOp::Make(
+ std::unique_ptr<GrMeshDrawOp> op = GrDrawVerticesOp::Make(
paint.getColor(), primitiveType, viewMatrix, positions, vertexCount, indices,
indexCount, colors, texCoords, bounds, colorArrayType);
if (!op) {
return;
}
GrPipelineBuilder pipelineBuilder(std::move(paint), GrAAType::kNone);
- this->addDrawOp(pipelineBuilder, clip, std::move(op));
+ this->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
}
void GrRenderTargetContext::drawVertices(const GrClip& clip,
@@ -962,13 +961,13 @@
AutoCheckFlush acf(this->drawingManager());
SkASSERT(vertices);
- std::unique_ptr<GrDrawOp> op =
+ std::unique_ptr<GrMeshDrawOp> op =
GrDrawVerticesOp::Make(paint.getColor(), std::move(vertices), viewMatrix, flags);
if (!op) {
return;
}
GrPipelineBuilder pipelineBuilder(std::move(paint), GrAAType::kNone);
- this->addDrawOp(pipelineBuilder, clip, std::move(op));
+ this->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
}
///////////////////////////////////////////////////////////////////////////////
@@ -987,10 +986,10 @@
AutoCheckFlush acf(this->drawingManager());
- std::unique_ptr<GrDrawOp> op =
+ std::unique_ptr<GrMeshDrawOp> op =
GrDrawAtlasOp::Make(paint.getColor(), viewMatrix, spriteCount, xform, texRect, colors);
GrPipelineBuilder pipelineBuilder(std::move(paint), GrAAType::kNone);
- this->addDrawOp(pipelineBuilder, clip, std::move(op));
+ this->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
}
///////////////////////////////////////////////////////////////////////////////
@@ -1043,15 +1042,16 @@
aaType = this->decideAAType(aa);
if (GrAAType::kCoverage == aaType) {
const GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
- std::unique_ptr<GrDrawOp> op = GrOvalOpFactory::MakeRRectOp(paint.getColor(),
- paint.usesDistanceVectorField(),
- viewMatrix,
- rrect,
- stroke,
- shaderCaps);
+ std::unique_ptr<GrMeshDrawOp> op =
+ GrOvalOpFactory::MakeRRectOp(paint.getColor(),
+ paint.usesDistanceVectorField(),
+ viewMatrix,
+ rrect,
+ stroke,
+ shaderCaps);
if (op) {
GrPipelineBuilder pipelineBuilder(std::move(paint), aaType);
- this->addDrawOp(pipelineBuilder, *clip, std::move(op));
+ this->addMeshDrawOp(pipelineBuilder, *clip, std::move(op));
return;
}
}
@@ -1085,11 +1085,11 @@
// TODO: add instancing support?
const GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
- std::unique_ptr<GrDrawOp> op = GrShadowRRectOp::Make(paint.getColor(), viewMatrix, rrect,
- blurRadius, stroke, shaderCaps);
+ std::unique_ptr<GrMeshDrawOp> op = GrShadowRRectOp::Make(paint.getColor(), viewMatrix, rrect,
+ blurRadius, stroke, shaderCaps);
if (op) {
GrPipelineBuilder pipelineBuilder(std::move(paint), GrAAType::kNone);
- this->addDrawOp(pipelineBuilder, clip, std::move(op));
+ this->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
return;
}
}
@@ -1231,9 +1231,9 @@
return this->drawPath(clip, std::move(paint), aa, viewMatrix, path, style);
}
- std::unique_ptr<GrDrawOp> op = GrRegionOp::Make(paint.getColor(), viewMatrix, region);
+ std::unique_ptr<GrMeshDrawOp> op = GrRegionOp::Make(paint.getColor(), viewMatrix, region);
GrPipelineBuilder pipelineBuilder(std::move(paint), GrAAType::kNone);
- this->addDrawOp(pipelineBuilder, clip, std::move(op));
+ this->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
}
void GrRenderTargetContext::drawOval(const GrClip& clip,
@@ -1272,11 +1272,11 @@
aaType = this->decideAAType(aa);
if (GrAAType::kCoverage == aaType) {
const GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
- std::unique_ptr<GrDrawOp> op =
+ std::unique_ptr<GrMeshDrawOp> op =
GrOvalOpFactory::MakeOvalOp(paint.getColor(), viewMatrix, oval, stroke, shaderCaps);
if (op) {
GrPipelineBuilder pipelineBuilder(std::move(paint), aaType);
- this->addDrawOp(pipelineBuilder, clip, std::move(op));
+ this->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
return;
}
}
@@ -1306,17 +1306,17 @@
GrAAType aaType = this->decideAAType(aa);
if (GrAAType::kCoverage == aaType) {
const GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
- std::unique_ptr<GrDrawOp> op = GrOvalOpFactory::MakeArcOp(paint.getColor(),
- viewMatrix,
- oval,
- startAngle,
- sweepAngle,
- useCenter,
- style,
- shaderCaps);
+ std::unique_ptr<GrMeshDrawOp> op = GrOvalOpFactory::MakeArcOp(paint.getColor(),
+ viewMatrix,
+ oval,
+ startAngle,
+ sweepAngle,
+ useCenter,
+ style,
+ shaderCaps);
if (op) {
GrPipelineBuilder pipelineBuilder(std::move(paint), aaType);
- this->addDrawOp(pipelineBuilder, clip, std::move(op));
+ this->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
return;
}
}
@@ -1340,11 +1340,11 @@
AutoCheckFlush acf(this->drawingManager());
- std::unique_ptr<GrDrawOp> op = GrLatticeOp::MakeNonAA(paint.getColor(), viewMatrix, imageWidth,
- imageHeight, std::move(iter), dst);
+ std::unique_ptr<GrMeshDrawOp> op = GrLatticeOp::MakeNonAA(
+ paint.getColor(), viewMatrix, imageWidth, imageHeight, std::move(iter), dst);
GrPipelineBuilder pipelineBuilder(std::move(paint), GrAAType::kNone);
- this->addDrawOp(pipelineBuilder, clip, std::move(op));
+ this->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
}
void GrRenderTargetContext::prepareForExternalIO() {
@@ -1375,13 +1375,13 @@
GrAAType hwOrNoneAAType) {
SkASSERT(GrAAType::kCoverage != hwOrNoneAAType);
SkASSERT(hwOrNoneAAType == GrAAType::kNone || this->isStencilBufferMultisampled());
- std::unique_ptr<GrDrawOp> op = GrRectOpFactory::MakeNonAAFill(paint.getColor(), viewMatrix,
- rect, localRect, localMatrix);
+ std::unique_ptr<GrMeshDrawOp> op = GrRectOpFactory::MakeNonAAFill(paint.getColor(), viewMatrix,
+ rect, localRect, localMatrix);
GrPipelineBuilder pipelineBuilder(std::move(paint), hwOrNoneAAType);
if (ss) {
pipelineBuilder.setUserStencil(ss);
}
- this->addDrawOp(pipelineBuilder, clip, std::move(op));
+ this->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
}
// Can 'path' be drawn as a pair of filled nested rectangles?
@@ -1457,11 +1457,11 @@
SkRect rects[2];
if (fills_as_nested_rects(viewMatrix, path, rects)) {
- std::unique_ptr<GrDrawOp> op =
+ std::unique_ptr<GrMeshDrawOp> op =
GrRectOpFactory::MakeAAFillNestedRects(paint.getColor(), viewMatrix, rects);
if (op) {
GrPipelineBuilder pipelineBuilder(std::move(paint), aaType);
- this->addDrawOp(pipelineBuilder, clip, std::move(op));
+ this->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
}
return;
}
@@ -1471,11 +1471,11 @@
if (isOval && !path.isInverseFillType()) {
const GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
- std::unique_ptr<GrDrawOp> op = GrOvalOpFactory::MakeOvalOp(
+ std::unique_ptr<GrMeshDrawOp> op = GrOvalOpFactory::MakeOvalOp(
paint.getColor(), viewMatrix, ovalRect, style.strokeRec(), shaderCaps);
if (op) {
GrPipelineBuilder pipelineBuilder(std::move(paint), aaType);
- this->addDrawOp(pipelineBuilder, clip, std::move(op));
+ this->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
return;
}
}
@@ -1673,6 +1673,12 @@
}
}
+uint32_t GrRenderTargetContext::addMeshDrawOp(const GrPipelineBuilder& pipelineBuilder,
+ const GrClip& clip,
+ std::unique_ptr<GrMeshDrawOp> op) {
+ return this->addDrawOp(pipelineBuilder, clip, std::move(op));
+}
+
uint32_t GrRenderTargetContext::addDrawOp(const GrPipelineBuilder& pipelineBuilder,
const GrClip& clip,
std::unique_ptr<GrDrawOp> op) {
diff --git a/src/gpu/GrRenderTargetContext.h b/src/gpu/GrRenderTargetContext.h
index 1126c76..479fc93 100644
--- a/src/gpu/GrRenderTargetContext.h
+++ b/src/gpu/GrRenderTargetContext.h
@@ -23,6 +23,7 @@
class GrDrawOp;
class GrFixedClip;
class GrPipelineBuilder;
+class GrMeshDrawOp;
class GrRenderTarget;
class GrRenderTargetContextPriv;
class GrRenderTargetOpList;
@@ -414,24 +415,24 @@
return GrAAType::kCoverage;
}
- friend class GrAtlasTextBlob; // for access to addDrawOp
- friend class GrStencilAndCoverTextContext; // for access to addDrawOp
+ friend class GrAtlasTextBlob; // for access to add[Mesh]DrawOp
+ friend class GrStencilAndCoverTextContext; // for access to add[Mesh]DrawOp
friend class GrDrawingManager; // for ctor
friend class GrRenderTargetContextPriv;
- friend class GrSWMaskHelper; // for access to addDrawOp
+ friend class GrSWMaskHelper; // for access to add[Mesh]DrawOp
// All the path renderers currently make their own ops
- friend class GrSoftwarePathRenderer; // for access to addDrawOp
- friend class GrAAConvexPathRenderer; // for access to addDrawOp
- friend class GrDashLinePathRenderer; // for access to addDrawOp
- friend class GrAAHairLinePathRenderer; // for access to addDrawOp
- friend class GrAALinearizingConvexPathRenderer; // for access to addDrawOp
- friend class GrAADistanceFieldPathRenderer; // for access to addDrawOp
- friend class GrDefaultPathRenderer; // for access to addDrawOp
- friend class GrMSAAPathRenderer; // for access to addDrawOp
- friend class GrStencilAndCoverPathRenderer; // for access to addDrawOp
- friend class GrTessellatingPathRenderer; // for access to addDrawOp
+ friend class GrSoftwarePathRenderer; // for access to add[Mesh]DrawOp
+ friend class GrAAConvexPathRenderer; // for access to add[Mesh]DrawOp
+ friend class GrDashLinePathRenderer; // for access to add[Mesh]DrawOp
+ friend class GrAAHairLinePathRenderer; // for access to add[Mesh]DrawOp
+ friend class GrAALinearizingConvexPathRenderer; // for access to add[Mesh]DrawOp
+ friend class GrAADistanceFieldPathRenderer; // for access to add[Mesh]DrawOp
+ friend class GrDefaultPathRenderer; // for access to add[Mesh]DrawOp
+ friend class GrMSAAPathRenderer; // for access to add[Mesh]DrawOp
+ friend class GrStencilAndCoverPathRenderer; // for access to add[Mesh]DrawOp
+ friend class GrTessellatingPathRenderer; // for access to add[Mesh]DrawOp
// for a unit test
friend void test_draw_op(GrContext*, GrRenderTargetContext*,
sk_sp<GrFragmentProcessor>, sk_sp<GrTextureProxy>);
@@ -472,10 +473,12 @@
bool onWritePixels(const SkImageInfo& srcInfo, const void* srcBuffer,
size_t srcRowBytes, int x, int y, uint32_t flags) override;
- // This performs processing specific to GrDrawOp-derived ops before recording them into the
- // op list. It returns the id of the opList to which the op was added, or 0, if it was
+ // These perform processing specific to Gr[Mesh]DrawOp-derived ops before recording them into
+ // the op list. They return the id of the opList to which the op was added, or 0, if it was
// dropped (e.g., due to clipping).
uint32_t addDrawOp(const GrPipelineBuilder&, const GrClip&, std::unique_ptr<GrDrawOp>);
+ uint32_t addMeshDrawOp(const GrPipelineBuilder&, const GrClip&,
+ std::unique_ptr<GrMeshDrawOp> op);
// Makes a copy of the dst if it is necessary for the draw and returns the texture that should
// be used by GrXferProcessor to access the destination color. If the texture is nullptr then
diff --git a/src/gpu/GrRenderTargetContextPriv.h b/src/gpu/GrRenderTargetContextPriv.h
index 842e23c..430abd0 100644
--- a/src/gpu/GrRenderTargetContextPriv.h
+++ b/src/gpu/GrRenderTargetContextPriv.h
@@ -108,11 +108,9 @@
return fRenderTargetContext->fRenderTargetProxy->uniqueID();
}
- uint32_t testingOnly_addDrawOp(GrPaint&&,
- GrAAType,
- std::unique_ptr<GrDrawOp>,
- const GrUserStencilSettings* = nullptr,
- bool snapToCenters = false);
+ uint32_t testingOnly_addMeshDrawOp(GrPaint&&, GrAAType, std::unique_ptr<GrMeshDrawOp>,
+ const GrUserStencilSettings* = nullptr,
+ bool snapToCenters = false);
bool refsWrappedObjects() const {
return fRenderTargetContext->fRenderTargetProxy->refsWrappedObjects();
diff --git a/src/gpu/GrSWMaskHelper.cpp b/src/gpu/GrSWMaskHelper.cpp
index f7e518b..6b6f1e6 100644
--- a/src/gpu/GrSWMaskHelper.cpp
+++ b/src/gpu/GrSWMaskHelper.cpp
@@ -175,11 +175,11 @@
SkMatrix maskMatrix = SkMatrix::MakeTrans(SkIntToScalar(-textureOriginInDeviceSpace.fX),
SkIntToScalar(-textureOriginInDeviceSpace.fY));
maskMatrix.preConcat(viewMatrix);
- std::unique_ptr<GrDrawOp> op = GrRectOpFactory::MakeNonAAFill(paint.getColor(), SkMatrix::I(),
- dstRect, nullptr, &invert);
+ std::unique_ptr<GrMeshDrawOp> op = GrRectOpFactory::MakeNonAAFill(
+ paint.getColor(), SkMatrix::I(), dstRect, nullptr, &invert);
paint.addCoverageFragmentProcessor(GrSimpleTextureEffect::Make(
texture, nullptr, maskMatrix, GrSamplerParams::kNone_FilterMode));
GrPipelineBuilder pipelineBuilder(std::move(paint), GrAAType::kNone);
pipelineBuilder.setUserStencil(&userStencilSettings);
- renderTargetContext->addDrawOp(pipelineBuilder, clip, std::move(op));
+ renderTargetContext->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
}
diff --git a/src/gpu/GrSoftwarePathRenderer.cpp b/src/gpu/GrSoftwarePathRenderer.cpp
index eb5495c..31ed746 100644
--- a/src/gpu/GrSoftwarePathRenderer.cpp
+++ b/src/gpu/GrSoftwarePathRenderer.cpp
@@ -77,12 +77,12 @@
const SkMatrix& viewMatrix,
const SkRect& rect,
const SkMatrix& localMatrix) {
- std::unique_ptr<GrDrawOp> op(GrRectOpFactory::MakeNonAAFill(paint.getColor(), viewMatrix, rect,
- nullptr, &localMatrix));
+ std::unique_ptr<GrMeshDrawOp> op(GrRectOpFactory::MakeNonAAFill(paint.getColor(), viewMatrix,
+ rect, nullptr, &localMatrix));
GrPipelineBuilder pipelineBuilder(std::move(paint), GrAAType::kNone);
pipelineBuilder.setUserStencil(&userStencilSettings);
- renderTargetContext->addDrawOp(pipelineBuilder, clip, std::move(op));
+ renderTargetContext->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
}
void GrSoftwarePathRenderer::DrawAroundInvPath(GrRenderTargetContext* renderTargetContext,
diff --git a/src/gpu/ops/GrAAConvexPathRenderer.cpp b/src/gpu/ops/GrAAConvexPathRenderer.cpp
index 4a2c6e2..68f4357 100644
--- a/src/gpu/ops/GrAAConvexPathRenderer.cpp
+++ b/src/gpu/ops/GrAAConvexPathRenderer.cpp
@@ -725,9 +725,9 @@
class AAConvexPathOp final : public GrMeshDrawOp {
public:
DEFINE_OP_CLASS_ID
- static std::unique_ptr<GrDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
- const SkPath& path) {
- return std::unique_ptr<GrDrawOp>(new AAConvexPathOp(color, viewMatrix, path));
+ static std::unique_ptr<GrMeshDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
+ const SkPath& path) {
+ return std::unique_ptr<GrMeshDrawOp>(new AAConvexPathOp(color, viewMatrix, path));
}
const char* name() const override { return "AAConvexPathOp"; }
@@ -972,13 +972,13 @@
SkPath path;
args.fShape->asPath(&path);
- std::unique_ptr<GrDrawOp> op =
+ std::unique_ptr<GrMeshDrawOp> op =
AAConvexPathOp::Make(args.fPaint.getColor(), *args.fViewMatrix, path);
GrPipelineBuilder pipelineBuilder(std::move(args.fPaint), args.fAAType);
pipelineBuilder.setUserStencil(args.fUserStencilSettings);
- args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, std::move(op));
+ args.fRenderTargetContext->addMeshDrawOp(pipelineBuilder, *args.fClip, std::move(op));
return true;
diff --git a/src/gpu/ops/GrAADistanceFieldPathRenderer.cpp b/src/gpu/ops/GrAADistanceFieldPathRenderer.cpp
index a856ba6..e77dfa9 100644
--- a/src/gpu/ops/GrAADistanceFieldPathRenderer.cpp
+++ b/src/gpu/ops/GrAADistanceFieldPathRenderer.cpp
@@ -141,11 +141,11 @@
using ShapeCache = SkTDynamicHash<ShapeData, ShapeData::Key>;
using ShapeDataList = GrAADistanceFieldPathRenderer::ShapeDataList;
- static std::unique_ptr<GrDrawOp> Make(GrColor color, const GrShape& shape,
- const SkMatrix& viewMatrix, GrDrawOpAtlas* atlas,
- ShapeCache* shapeCache, ShapeDataList* shapeList,
- bool gammaCorrect) {
- return std::unique_ptr<GrDrawOp>(new AADistanceFieldPathOp(
+ static std::unique_ptr<GrMeshDrawOp> Make(GrColor color, const GrShape& shape,
+ const SkMatrix& viewMatrix, GrDrawOpAtlas* atlas,
+ ShapeCache* shapeCache, ShapeDataList* shapeList,
+ bool gammaCorrect) {
+ return std::unique_ptr<GrMeshDrawOp>(new AADistanceFieldPathOp(
color, shape, viewMatrix, atlas, shapeCache, shapeList, gammaCorrect));
}
@@ -757,13 +757,13 @@
}
}
- std::unique_ptr<GrDrawOp> op = AADistanceFieldPathOp::Make(
+ std::unique_ptr<GrMeshDrawOp> op = AADistanceFieldPathOp::Make(
args.fPaint.getColor(), *args.fShape, *args.fViewMatrix, fAtlas.get(), &fShapeCache,
&fShapeList, args.fGammaCorrect);
GrPipelineBuilder pipelineBuilder(std::move(args.fPaint), args.fAAType);
pipelineBuilder.setUserStencil(args.fUserStencilSettings);
- args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, std::move(op));
+ args.fRenderTargetContext->addMeshDrawOp(pipelineBuilder, *args.fClip, std::move(op));
return true;
}
diff --git a/src/gpu/ops/GrAAFillRectOp.cpp b/src/gpu/ops/GrAAFillRectOp.cpp
index c66e7ee..850a3c9 100644
--- a/src/gpu/ops/GrAAFillRectOp.cpp
+++ b/src/gpu/ops/GrAAFillRectOp.cpp
@@ -342,35 +342,36 @@
namespace GrAAFillRectOp {
-std::unique_ptr<GrDrawOp> Make(GrColor color,
- const SkMatrix& viewMatrix,
- const SkRect& rect,
- const SkRect& devRect) {
- return std::unique_ptr<GrDrawOp>(new AAFillRectOp(color, viewMatrix, rect, devRect, nullptr));
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkRect& rect,
+ const SkRect& devRect) {
+ return std::unique_ptr<GrMeshDrawOp>(
+ new AAFillRectOp(color, viewMatrix, rect, devRect, nullptr));
}
-std::unique_ptr<GrDrawOp> Make(GrColor color,
- const SkMatrix& viewMatrix,
- const SkMatrix& localMatrix,
- const SkRect& rect,
- const SkRect& devRect) {
- return std::unique_ptr<GrDrawOp>(
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkMatrix& localMatrix,
+ const SkRect& rect,
+ const SkRect& devRect) {
+ return std::unique_ptr<GrMeshDrawOp>(
new AAFillRectOp(color, viewMatrix, rect, devRect, &localMatrix));
}
-std::unique_ptr<GrDrawOp> Make(GrColor color,
- const SkMatrix& viewMatrix,
- const SkMatrix& localMatrix,
- const SkRect& rect) {
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkMatrix& localMatrix,
+ const SkRect& rect) {
SkRect devRect;
viewMatrix.mapRect(&devRect, rect);
return Make(color, viewMatrix, localMatrix, rect, devRect);
}
-std::unique_ptr<GrDrawOp> MakeWithLocalRect(GrColor color,
- const SkMatrix& viewMatrix,
- const SkRect& rect,
- const SkRect& localRect) {
+std::unique_ptr<GrMeshDrawOp> MakeWithLocalRect(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkRect& rect,
+ const SkRect& localRect) {
SkRect devRect;
viewMatrix.mapRect(&devRect, rect);
SkMatrix localMatrix;
diff --git a/src/gpu/ops/GrAAFillRectOp.h b/src/gpu/ops/GrAAFillRectOp.h
index ff9844e..c047eed 100644
--- a/src/gpu/ops/GrAAFillRectOp.h
+++ b/src/gpu/ops/GrAAFillRectOp.h
@@ -11,31 +11,31 @@
#include "GrColor.h"
#include "SkRefCnt.h"
-class GrDrawOp;
+class GrMeshDrawOp;
class SkMatrix;
struct SkRect;
namespace GrAAFillRectOp {
-std::unique_ptr<GrDrawOp> Make(GrColor color,
- const SkMatrix& viewMatrix,
- const SkRect& rect,
- const SkRect& devRect);
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkRect& rect,
+ const SkRect& devRect);
-std::unique_ptr<GrDrawOp> Make(GrColor color,
- const SkMatrix& viewMatrix,
- const SkMatrix& localMatrix,
- const SkRect& rect);
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkMatrix& localMatrix,
+ const SkRect& rect);
-std::unique_ptr<GrDrawOp> Make(GrColor color,
- const SkMatrix& viewMatrix,
- const SkMatrix& localMatrix,
- const SkRect& rect,
- const SkRect& devRect);
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkMatrix& localMatrix,
+ const SkRect& rect,
+ const SkRect& devRect);
-std::unique_ptr<GrDrawOp> MakeWithLocalRect(GrColor color,
- const SkMatrix& viewMatrix,
- const SkRect& rect,
- const SkRect& localRect);
+std::unique_ptr<GrMeshDrawOp> MakeWithLocalRect(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkRect& rect,
+ const SkRect& localRect);
};
#endif
diff --git a/src/gpu/ops/GrAAHairLinePathRenderer.cpp b/src/gpu/ops/GrAAHairLinePathRenderer.cpp
index 408740d..e373b97 100644
--- a/src/gpu/ops/GrAAHairLinePathRenderer.cpp
+++ b/src/gpu/ops/GrAAHairLinePathRenderer.cpp
@@ -676,18 +676,18 @@
public:
DEFINE_OP_CLASS_ID
- static std::unique_ptr<GrDrawOp> Make(GrColor color,
- const SkMatrix& viewMatrix,
- const SkPath& path,
- const GrStyle& style,
- const SkIRect& devClipBounds) {
+ static std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkPath& path,
+ const GrStyle& style,
+ const SkIRect& devClipBounds) {
SkScalar hairlineCoverage;
uint8_t newCoverage = 0xff;
if (GrPathRenderer::IsStrokeHairlineOrEquivalent(style, viewMatrix, &hairlineCoverage)) {
newCoverage = SkScalarRoundToInt(hairlineCoverage * 0xff);
}
- return std::unique_ptr<GrDrawOp>(
+ return std::unique_ptr<GrMeshDrawOp>(
new AAHairlineOp(color, newCoverage, viewMatrix, path, devClipBounds));
}
@@ -949,11 +949,11 @@
&devClipBounds);
SkPath path;
args.fShape->asPath(&path);
- std::unique_ptr<GrDrawOp> op = AAHairlineOp::Make(args.fPaint.getColor(), *args.fViewMatrix,
- path, args.fShape->style(), devClipBounds);
+ std::unique_ptr<GrMeshDrawOp> op = AAHairlineOp::Make(
+ args.fPaint.getColor(), *args.fViewMatrix, path, args.fShape->style(), devClipBounds);
GrPipelineBuilder pipelineBuilder(std::move(args.fPaint), args.fAAType);
pipelineBuilder.setUserStencil(args.fUserStencilSettings);
- args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, std::move(op));
+ args.fRenderTargetContext->addMeshDrawOp(pipelineBuilder, *args.fClip, std::move(op));
return true;
}
diff --git a/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp b/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp
index f0ff12b..bdec758 100644
--- a/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp
+++ b/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp
@@ -120,14 +120,14 @@
class AAFlatteningConvexPathOp final : public GrMeshDrawOp {
public:
DEFINE_OP_CLASS_ID
- static std::unique_ptr<GrDrawOp> Make(GrColor color,
- const SkMatrix& viewMatrix,
- const SkPath& path,
- SkScalar strokeWidth,
- SkStrokeRec::Style style,
- SkPaint::Join join,
- SkScalar miterLimit) {
- return std::unique_ptr<GrDrawOp>(new AAFlatteningConvexPathOp(
+ static std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkPath& path,
+ SkScalar strokeWidth,
+ SkStrokeRec::Style style,
+ SkPaint::Join join,
+ SkScalar miterLimit) {
+ return std::unique_ptr<GrMeshDrawOp>(new AAFlatteningConvexPathOp(
color, viewMatrix, path, strokeWidth, style, join, miterLimit));
}
@@ -335,14 +335,14 @@
SkPaint::Join join = fill ? SkPaint::Join::kMiter_Join : stroke.getJoin();
SkScalar miterLimit = stroke.getMiter();
- std::unique_ptr<GrDrawOp> op =
+ std::unique_ptr<GrMeshDrawOp> op =
AAFlatteningConvexPathOp::Make(args.fPaint.getColor(), *args.fViewMatrix, path,
strokeWidth, stroke.getStyle(), join, miterLimit);
GrPipelineBuilder pipelineBuilder(std::move(args.fPaint), args.fAAType);
pipelineBuilder.setUserStencil(args.fUserStencilSettings);
- args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, std::move(op));
+ args.fRenderTargetContext->addMeshDrawOp(pipelineBuilder, *args.fClip, std::move(op));
return true;
}
diff --git a/src/gpu/ops/GrAAStrokeRectOp.cpp b/src/gpu/ops/GrAAStrokeRectOp.cpp
index 207b95f..3780752 100644
--- a/src/gpu/ops/GrAAStrokeRectOp.cpp
+++ b/src/gpu/ops/GrAAStrokeRectOp.cpp
@@ -125,8 +125,8 @@
fMiterStroke = true;
}
- static std::unique_ptr<GrDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
- const SkRect& rect, const SkStrokeRec& stroke) {
+ static std::unique_ptr<GrMeshDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
+ const SkRect& rect, const SkStrokeRec& stroke) {
bool isMiter;
if (!allowed_stroke(stroke, &isMiter)) {
return nullptr;
@@ -140,7 +140,7 @@
info.fColor = color;
op->setBounds(info.fDevOutside, HasAABloat::kYes, IsZeroArea::kNo);
op->fViewMatrix = viewMatrix;
- return std::unique_ptr<GrDrawOp>(op);
+ return std::unique_ptr<GrMeshDrawOp>(op);
}
const char* name() const override { return "AAStrokeRect"; }
@@ -562,17 +562,18 @@
namespace GrAAStrokeRectOp {
-std::unique_ptr<GrDrawOp> MakeFillBetweenRects(GrColor color,
- const SkMatrix& viewMatrix,
- const SkRect& devOutside,
- const SkRect& devInside) {
- return std::unique_ptr<GrDrawOp>(new AAStrokeRectOp(color, viewMatrix, devOutside, devInside));
+std::unique_ptr<GrMeshDrawOp> MakeFillBetweenRects(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkRect& devOutside,
+ const SkRect& devInside) {
+ return std::unique_ptr<GrMeshDrawOp>(
+ new AAStrokeRectOp(color, viewMatrix, devOutside, devInside));
}
-std::unique_ptr<GrDrawOp> Make(GrColor color,
- const SkMatrix& viewMatrix,
- const SkRect& rect,
- const SkStrokeRec& stroke) {
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkRect& rect,
+ const SkStrokeRec& stroke) {
return AAStrokeRectOp::Make(color, viewMatrix, rect, stroke);
}
}
diff --git a/src/gpu/ops/GrAAStrokeRectOp.h b/src/gpu/ops/GrAAStrokeRectOp.h
index d9f830e..4dfbe64 100644
--- a/src/gpu/ops/GrAAStrokeRectOp.h
+++ b/src/gpu/ops/GrAAStrokeRectOp.h
@@ -11,22 +11,22 @@
#include "GrColor.h"
#include "SkRefCnt.h"
-class GrDrawOp;
+class GrMeshDrawOp;
class SkMatrix;
struct SkRect;
class SkStrokeRec;
namespace GrAAStrokeRectOp {
-std::unique_ptr<GrDrawOp> MakeFillBetweenRects(GrColor color,
- const SkMatrix& viewMatrix,
- const SkRect& devOutside,
- const SkRect& devInside);
+std::unique_ptr<GrMeshDrawOp> MakeFillBetweenRects(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkRect& devOutside,
+ const SkRect& devInside);
-std::unique_ptr<GrDrawOp> Make(GrColor color,
- const SkMatrix& viewMatrix,
- const SkRect& rect,
- const SkStrokeRec& stroke);
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkRect& rect,
+ const SkStrokeRec& stroke);
}
#endif
diff --git a/src/gpu/ops/GrAnalyticRectOp.cpp b/src/gpu/ops/GrAnalyticRectOp.cpp
index 711ce33..5dbfd5e 100644
--- a/src/gpu/ops/GrAnalyticRectOp.cpp
+++ b/src/gpu/ops/GrAnalyticRectOp.cpp
@@ -377,12 +377,12 @@
typedef GrMeshDrawOp INHERITED;
};
-std::unique_ptr<GrDrawOp> GrAnalyticRectOp::Make(GrColor color,
- const SkMatrix& viewMatrix,
- const SkRect& rect,
- const SkRect& croppedRect,
- const SkRect& bounds) {
- return std::unique_ptr<GrDrawOp>(
+std::unique_ptr<GrMeshDrawOp> GrAnalyticRectOp::Make(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkRect& rect,
+ const SkRect& croppedRect,
+ const SkRect& bounds) {
+ return std::unique_ptr<GrMeshDrawOp>(
new AnalyticRectOp(color, viewMatrix, rect, croppedRect, bounds));
}
@@ -394,7 +394,7 @@
SkRect rect = GrTest::TestSquare(random);
SkRect croppedRect = GrTest::TestSquare(random);
SkRect bounds = GrTest::TestSquare(random);
- return std::unique_ptr<GrDrawOp>(
+ return std::unique_ptr<GrMeshDrawOp>(
new AnalyticRectOp(color, viewMatrix, rect, croppedRect, bounds));
}
diff --git a/src/gpu/ops/GrAnalyticRectOp.h b/src/gpu/ops/GrAnalyticRectOp.h
index 1266879..4331794 100644
--- a/src/gpu/ops/GrAnalyticRectOp.h
+++ b/src/gpu/ops/GrAnalyticRectOp.h
@@ -11,7 +11,7 @@
#include "GrColor.h"
#include "SkRefCnt.h"
-class GrDrawOp;
+class GrMeshDrawOp;
class SkMatrix;
struct SkRect;
@@ -27,11 +27,11 @@
*/
class GrAnalyticRectOp {
public:
- static std::unique_ptr<GrDrawOp> Make(GrColor color,
- const SkMatrix& viewMatrix,
- const SkRect& rect,
- const SkRect& croppedRect,
- const SkRect& bounds);
+ static std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkRect& rect,
+ const SkRect& croppedRect,
+ const SkRect& bounds);
};
#endif // GrAnalyticRectOp_DEFINED
diff --git a/src/gpu/ops/GrDashLinePathRenderer.cpp b/src/gpu/ops/GrDashLinePathRenderer.cpp
index 1c43cb5..9f170ff 100644
--- a/src/gpu/ops/GrDashLinePathRenderer.cpp
+++ b/src/gpu/ops/GrDashLinePathRenderer.cpp
@@ -11,6 +11,7 @@
#include "GrGpu.h"
#include "GrPipelineBuilder.h"
#include "ops/GrDashOp.h"
+#include "ops/GrMeshDrawOp.h"
bool GrDashLinePathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
SkPoint pts[2];
@@ -45,7 +46,7 @@
}
SkPoint pts[2];
SkAssertResult(args.fShape->asLine(pts, nullptr));
- std::unique_ptr<GrDrawOp> op = GrDashOp::MakeDashLineOp(
+ std::unique_ptr<GrMeshDrawOp> op = GrDashOp::MakeDashLineOp(
args.fPaint.getColor(), *args.fViewMatrix, pts, aaMode, args.fShape->style());
if (!op) {
return false;
@@ -54,6 +55,6 @@
GrPipelineBuilder pipelineBuilder(std::move(args.fPaint), args.fAAType);
pipelineBuilder.setUserStencil(args.fUserStencilSettings);
- args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, std::move(op));
+ args.fRenderTargetContext->addMeshDrawOp(pipelineBuilder, *args.fClip, std::move(op));
return true;
}
diff --git a/src/gpu/ops/GrDashOp.cpp b/src/gpu/ops/GrDashOp.cpp
index d91e86b..1372a8b 100644
--- a/src/gpu/ops/GrDashOp.cpp
+++ b/src/gpu/ops/GrDashOp.cpp
@@ -251,9 +251,9 @@
SkScalar fPerpendicularScale;
};
- static std::unique_ptr<GrDrawOp> Make(const LineData& geometry, GrColor color, SkPaint::Cap cap,
- AAMode aaMode, bool fullDash) {
- return std::unique_ptr<GrDrawOp>(new DashOp(geometry, color, cap, aaMode, fullDash));
+ static std::unique_ptr<GrMeshDrawOp> Make(const LineData& geometry, GrColor color,
+ SkPaint::Cap cap, AAMode aaMode, bool fullDash) {
+ return std::unique_ptr<GrMeshDrawOp>(new DashOp(geometry, color, cap, aaMode, fullDash));
}
const char* name() const override { return "DashOp"; }
@@ -681,11 +681,11 @@
typedef GrMeshDrawOp INHERITED;
};
-std::unique_ptr<GrDrawOp> GrDashOp::MakeDashLineOp(GrColor color,
- const SkMatrix& viewMatrix,
- const SkPoint pts[2],
- AAMode aaMode,
- const GrStyle& style) {
+std::unique_ptr<GrMeshDrawOp> GrDashOp::MakeDashLineOp(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkPoint pts[2],
+ AAMode aaMode,
+ const GrStyle& style) {
SkASSERT(GrDashOp::CanDrawDashLine(pts, style, viewMatrix));
const SkScalar* intervals = style.dashIntervals();
SkScalar phase = style.dashPhase();
diff --git a/src/gpu/ops/GrDashOp.h b/src/gpu/ops/GrDashOp.h
index 2f4a30f..6ffd326 100644
--- a/src/gpu/ops/GrDashOp.h
+++ b/src/gpu/ops/GrDashOp.h
@@ -12,7 +12,7 @@
#include "GrTypesPriv.h"
#include "SkPathEffect.h"
-class GrDrawOp;
+class GrMeshDrawOp;
class GrStyle;
namespace GrDashOp {
@@ -23,8 +23,8 @@
};
static const int kAAModeCnt = static_cast<int>(AAMode::kCoverageWithMSAA) + 1;
-std::unique_ptr<GrDrawOp> MakeDashLineOp(GrColor, const SkMatrix& viewMatrix, const SkPoint pts[2],
- AAMode, const GrStyle& style);
+std::unique_ptr<GrMeshDrawOp> MakeDashLineOp(GrColor, const SkMatrix& viewMatrix,
+ const SkPoint pts[2], AAMode, const GrStyle& style);
bool CanDrawDashLine(const SkPoint pts[2], const GrStyle& style, const SkMatrix& viewMatrix);
}
diff --git a/src/gpu/ops/GrDefaultPathRenderer.cpp b/src/gpu/ops/GrDefaultPathRenderer.cpp
index f2be968..300090d 100644
--- a/src/gpu/ops/GrDefaultPathRenderer.cpp
+++ b/src/gpu/ops/GrDefaultPathRenderer.cpp
@@ -98,11 +98,11 @@
public:
DEFINE_OP_CLASS_ID
- static std::unique_ptr<GrDrawOp> Make(GrColor color, const SkPath& path, SkScalar tolerance,
- uint8_t coverage, const SkMatrix& viewMatrix,
- bool isHairline, const SkRect& devBounds) {
- return std::unique_ptr<GrDrawOp>(new DefaultPathOp(color, path, tolerance, coverage,
- viewMatrix, isHairline, devBounds));
+ static std::unique_ptr<GrMeshDrawOp> Make(GrColor color, const SkPath& path, SkScalar tolerance,
+ uint8_t coverage, const SkMatrix& viewMatrix,
+ bool isHairline, const SkRect& devBounds) {
+ return std::unique_ptr<GrMeshDrawOp>(new DefaultPathOp(color, path, tolerance, coverage,
+ viewMatrix, isHairline, devBounds));
}
const char* name() const override { return "DefaultPathOp"; }
@@ -546,16 +546,16 @@
}
const SkMatrix& viewM = (reverse && viewMatrix.hasPerspective()) ? SkMatrix::I() :
viewMatrix;
- std::unique_ptr<GrDrawOp> op(GrRectOpFactory::MakeNonAAFill(
+ std::unique_ptr<GrMeshDrawOp> op(GrRectOpFactory::MakeNonAAFill(
paint.getColor(), viewM, bounds, nullptr, &localMatrix));
SkASSERT(GrDrawFace::kBoth == drawFace[p]);
GrPipelineBuilder pipelineBuilder(std::move(paint), aaType);
pipelineBuilder.setDrawFace(drawFace[p]);
pipelineBuilder.setUserStencil(passes[p]);
- renderTargetContext->addDrawOp(pipelineBuilder, clip, std::move(op));
+ renderTargetContext->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
} else {
- std::unique_ptr<GrDrawOp> op =
+ std::unique_ptr<GrMeshDrawOp> op =
DefaultPathOp::Make(paint.getColor(), path, srcSpaceTol, newCoverage,
viewMatrix, isHairline, devBounds);
bool stencilPass = stencilOnly || passCount > 1;
@@ -566,7 +566,7 @@
GrPipelineBuilder pipelineBuilder(std::move(passPaint), aaType);
pipelineBuilder.setDrawFace(drawFace[p]);
pipelineBuilder.setUserStencil(passes[p]);
- renderTargetContext->addDrawOp(pipelineBuilder, clip, std::move(op));
+ renderTargetContext->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
}
}
return true;
diff --git a/src/gpu/ops/GrDrawAtlasOp.h b/src/gpu/ops/GrDrawAtlasOp.h
index d6a211d..cde345e 100644
--- a/src/gpu/ops/GrDrawAtlasOp.h
+++ b/src/gpu/ops/GrDrawAtlasOp.h
@@ -16,10 +16,10 @@
public:
DEFINE_OP_CLASS_ID
- static std::unique_ptr<GrDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
- int spriteCount, const SkRSXform* xforms,
- const SkRect* rects, const SkColor* colors) {
- return std::unique_ptr<GrDrawOp>(
+ static std::unique_ptr<GrMeshDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
+ int spriteCount, const SkRSXform* xforms,
+ const SkRect* rects, const SkColor* colors) {
+ return std::unique_ptr<GrMeshDrawOp>(
new GrDrawAtlasOp(color, viewMatrix, spriteCount, xforms, rects, colors));
}
diff --git a/src/gpu/ops/GrDrawVerticesOp.cpp b/src/gpu/ops/GrDrawVerticesOp.cpp
index 5b59b13..c79d9ac 100644
--- a/src/gpu/ops/GrDrawVerticesOp.cpp
+++ b/src/gpu/ops/GrDrawVerticesOp.cpp
@@ -10,7 +10,7 @@
#include "GrOpFlushState.h"
#include "SkGr.h"
-std::unique_ptr<GrDrawOp> GrDrawVerticesOp::Make(
+std::unique_ptr<GrMeshDrawOp> GrDrawVerticesOp::Make(
GrColor color, GrPrimitiveType primitiveType, const SkMatrix& viewMatrix,
const SkPoint* positions, int vertexCount, const uint16_t* indices, int indexCount,
const uint32_t* colors, const SkPoint* localCoords, const SkRect& bounds,
@@ -58,15 +58,15 @@
if (!vertices) {
return nullptr;
}
- return std::unique_ptr<GrDrawOp>(new GrDrawVerticesOp(std::move(vertices), primitiveType, color,
- colorArrayType, viewMatrix));
+ return std::unique_ptr<GrMeshDrawOp>(new GrDrawVerticesOp(std::move(vertices), primitiveType,
+ color, colorArrayType, viewMatrix));
}
-std::unique_ptr<GrDrawOp> GrDrawVerticesOp::Make(GrColor color, sk_sp<SkVertices> vertices,
- const SkMatrix& viewMatrix, uint32_t flags) {
+std::unique_ptr<GrMeshDrawOp> GrDrawVerticesOp::Make(GrColor color, sk_sp<SkVertices> vertices,
+ const SkMatrix& viewMatrix, uint32_t flags) {
SkASSERT(vertices);
GrPrimitiveType primType = SkVertexModeToGrPrimitiveType(vertices->mode());
- return std::unique_ptr<GrDrawOp>(new GrDrawVerticesOp(
+ return std::unique_ptr<GrMeshDrawOp>(new GrDrawVerticesOp(
std::move(vertices), primType, color, GrRenderTargetContext::ColorArrayType::kSkColor,
viewMatrix, flags));
}
diff --git a/src/gpu/ops/GrDrawVerticesOp.h b/src/gpu/ops/GrDrawVerticesOp.h
index 2ce9bdc..c837734 100644
--- a/src/gpu/ops/GrDrawVerticesOp.h
+++ b/src/gpu/ops/GrDrawVerticesOp.h
@@ -33,12 +33,12 @@
* as local coords. 'colorArrayType' specifies whether the colors are premul GrColors or
* unpremul SkColors.
*/
- static std::unique_ptr<GrDrawOp> Make(GrColor color, GrPrimitiveType primitiveType,
- const SkMatrix& viewMatrix, const SkPoint* positions,
- int vertexCount, const uint16_t* indices, int indexCount,
- const uint32_t* colors, const SkPoint* localCoords,
- const SkRect& bounds,
- GrRenderTargetContext::ColorArrayType colorArrayType);
+ static std::unique_ptr<GrMeshDrawOp> Make(GrColor color, GrPrimitiveType primitiveType,
+ const SkMatrix& viewMatrix, const SkPoint* positions,
+ int vertexCount, const uint16_t* indices,
+ int indexCount, const uint32_t* colors,
+ const SkPoint* localCoords, const SkRect& bounds,
+ GrRenderTargetContext::ColorArrayType colorArrayType);
/**
* Draw a SkVertices. The GrColor param is used if the vertices lack per-vertex color or 'flags'
@@ -46,8 +46,8 @@
* specified by SkCanvas::VerticesFlags. If the vertices lack local coords or 'flags' indicates
* that they should be ignored then the vertex positions are used as local coords.
*/
- static std::unique_ptr<GrDrawOp> Make(GrColor color, sk_sp<SkVertices>,
- const SkMatrix& viewMatrix, uint32_t flags);
+ static std::unique_ptr<GrMeshDrawOp> Make(GrColor color, sk_sp<SkVertices>,
+ const SkMatrix& viewMatrix, uint32_t flags);
const char* name() const override { return "DrawVerticesOp"; }
diff --git a/src/gpu/ops/GrLatticeOp.cpp b/src/gpu/ops/GrLatticeOp.cpp
index 531a646..a1b7584 100644
--- a/src/gpu/ops/GrLatticeOp.cpp
+++ b/src/gpu/ops/GrLatticeOp.cpp
@@ -165,10 +165,10 @@
};
namespace GrLatticeOp {
-std::unique_ptr<GrDrawOp> MakeNonAA(GrColor color, const SkMatrix& viewMatrix, int imageWidth,
- int imageHeight, std::unique_ptr<SkLatticeIter> iter,
- const SkRect& dst) {
- return std::unique_ptr<GrDrawOp>(
+std::unique_ptr<GrMeshDrawOp> MakeNonAA(GrColor color, const SkMatrix& viewMatrix, int imageWidth,
+ int imageHeight, std::unique_ptr<SkLatticeIter> iter,
+ const SkRect& dst) {
+ return std::unique_ptr<GrMeshDrawOp>(
new NonAALatticeOp(color, viewMatrix, imageWidth, imageHeight, std::move(iter), dst));
}
};
diff --git a/src/gpu/ops/GrLatticeOp.h b/src/gpu/ops/GrLatticeOp.h
index 2ed3b9c..ef0f58a 100644
--- a/src/gpu/ops/GrLatticeOp.h
+++ b/src/gpu/ops/GrLatticeOp.h
@@ -11,15 +11,15 @@
#include "GrColor.h"
#include "SkRefCnt.h"
-class GrDrawOp;
+class GrMeshDrawOp;
class SkLatticeIter;
class SkMatrix;
struct SkRect;
namespace GrLatticeOp {
-std::unique_ptr<GrDrawOp> MakeNonAA(GrColor color, const SkMatrix& viewMatrix, int imageWidth,
- int imageHeight, std::unique_ptr<SkLatticeIter> iter,
- const SkRect& dst);
+std::unique_ptr<GrMeshDrawOp> MakeNonAA(GrColor color, const SkMatrix& viewMatrix, int imageWidth,
+ int imageHeight, std::unique_ptr<SkLatticeIter> iter,
+ const SkRect& dst);
};
#endif
diff --git a/src/gpu/ops/GrMSAAPathRenderer.cpp b/src/gpu/ops/GrMSAAPathRenderer.cpp
index b149b4c..04b0b14 100644
--- a/src/gpu/ops/GrMSAAPathRenderer.cpp
+++ b/src/gpu/ops/GrMSAAPathRenderer.cpp
@@ -218,8 +218,8 @@
class MSAAPathOp final : public GrMeshDrawOp {
public:
DEFINE_OP_CLASS_ID
- static std::unique_ptr<GrDrawOp> Make(GrColor color, const SkPath& path,
- const SkMatrix& viewMatrix, const SkRect& devBounds) {
+ static std::unique_ptr<GrMeshDrawOp> Make(GrColor color, const SkPath& path,
+ const SkMatrix& viewMatrix, const SkRect& devBounds) {
int contourCount;
int maxLineVertices;
int maxQuadVertices;
@@ -230,7 +230,7 @@
return nullptr;
}
- return std::unique_ptr<GrDrawOp>(new MSAAPathOp(
+ return std::unique_ptr<GrMeshDrawOp>(new MSAAPathOp(
color, path, viewMatrix, devBounds, maxLineVertices, maxQuadVertices, isIndexed));
}
@@ -620,7 +620,7 @@
SkASSERT(passes[0]);
{ // First pass
- std::unique_ptr<GrDrawOp> op =
+ std::unique_ptr<GrMeshDrawOp> op =
MSAAPathOp::Make(paint.getColor(), path, viewMatrix, devBounds);
if (!op) {
return false;
@@ -634,7 +634,7 @@
}
GrPipelineBuilder pipelineBuilder(std::move(firstPassPaint), aaType);
pipelineBuilder.setUserStencil(passes[0]);
- renderTargetContext->addDrawOp(pipelineBuilder, clip, std::move(op));
+ renderTargetContext->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
}
if (passes[1]) {
@@ -657,13 +657,13 @@
}
const SkMatrix& viewM =
(reverse && viewMatrix.hasPerspective()) ? SkMatrix::I() : viewMatrix;
- std::unique_ptr<GrDrawOp> op(GrRectOpFactory::MakeNonAAFill(paint.getColor(), viewM, bounds,
- nullptr, &localMatrix));
+ std::unique_ptr<GrMeshDrawOp> op(GrRectOpFactory::MakeNonAAFill(
+ paint.getColor(), viewM, bounds, nullptr, &localMatrix));
GrPipelineBuilder pipelineBuilder(std::move(paint), aaType);
pipelineBuilder.setUserStencil(passes[1]);
- renderTargetContext->addDrawOp(pipelineBuilder, clip, std::move(op));
+ renderTargetContext->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
}
return true;
}
diff --git a/src/gpu/ops/GrNonAAFillRectOp.cpp b/src/gpu/ops/GrNonAAFillRectOp.cpp
index 871eece..a83da15 100644
--- a/src/gpu/ops/GrNonAAFillRectOp.cpp
+++ b/src/gpu/ops/GrNonAAFillRectOp.cpp
@@ -176,12 +176,12 @@
namespace GrNonAAFillRectOp {
-std::unique_ptr<GrDrawOp> Make(GrColor color,
- const SkMatrix& viewMatrix,
- const SkRect& rect,
- const SkRect* localRect,
- const SkMatrix* localMatrix) {
- return std::unique_ptr<GrDrawOp>(
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkRect& rect,
+ const SkRect* localRect,
+ const SkMatrix* localMatrix) {
+ return std::unique_ptr<GrMeshDrawOp>(
new NonAAFillRectOp(color, viewMatrix, rect, localRect, localMatrix));
}
};
diff --git a/src/gpu/ops/GrNonAAFillRectOp.h b/src/gpu/ops/GrNonAAFillRectOp.h
index e699221..046a955 100644
--- a/src/gpu/ops/GrNonAAFillRectOp.h
+++ b/src/gpu/ops/GrNonAAFillRectOp.h
@@ -11,23 +11,23 @@
#include "GrColor.h"
#include "SkRefCnt.h"
-class GrDrawOp;
+class GrMeshDrawOp;
class SkMatrix;
struct SkRect;
namespace GrNonAAFillRectOp {
-std::unique_ptr<GrDrawOp> Make(GrColor color,
- const SkMatrix& viewMatrix,
- const SkRect& rect,
- const SkRect* localRect,
- const SkMatrix* localMatrix);
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkRect& rect,
+ const SkRect* localRect,
+ const SkMatrix* localMatrix);
-std::unique_ptr<GrDrawOp> MakeWithPerspective(GrColor color,
- const SkMatrix& viewMatrix,
- const SkRect& rect,
- const SkRect* localRect,
- const SkMatrix* localMatrix);
+std::unique_ptr<GrMeshDrawOp> MakeWithPerspective(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkRect& rect,
+ const SkRect* localRect,
+ const SkMatrix* localMatrix);
};
#endif
diff --git a/src/gpu/ops/GrNonAAFillRectPerspectiveOp.cpp b/src/gpu/ops/GrNonAAFillRectPerspectiveOp.cpp
index 5a0f81f..26a6469 100644
--- a/src/gpu/ops/GrNonAAFillRectPerspectiveOp.cpp
+++ b/src/gpu/ops/GrNonAAFillRectPerspectiveOp.cpp
@@ -220,12 +220,12 @@
namespace GrNonAAFillRectOp {
-std::unique_ptr<GrDrawOp> MakeWithPerspective(GrColor color,
- const SkMatrix& viewMatrix,
- const SkRect& rect,
- const SkRect* localRect,
- const SkMatrix* localMatrix) {
- return std::unique_ptr<GrDrawOp>(
+std::unique_ptr<GrMeshDrawOp> MakeWithPerspective(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkRect& rect,
+ const SkRect* localRect,
+ const SkMatrix* localMatrix) {
+ return std::unique_ptr<GrMeshDrawOp>(
new NonAAFillRectPerspectiveOp(color, viewMatrix, rect, localRect, localMatrix));
}
};
diff --git a/src/gpu/ops/GrNonAAStrokeRectOp.cpp b/src/gpu/ops/GrNonAAStrokeRectOp.cpp
index bcab4e0..a4de594 100644
--- a/src/gpu/ops/GrNonAAStrokeRectOp.cpp
+++ b/src/gpu/ops/GrNonAAStrokeRectOp.cpp
@@ -63,9 +63,9 @@
return string;
}
- static std::unique_ptr<GrDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
- const SkRect& rect, const SkStrokeRec& stroke,
- bool snapToPixelCenters) {
+ static std::unique_ptr<GrMeshDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
+ const SkRect& rect, const SkStrokeRec& stroke,
+ bool snapToPixelCenters) {
if (!allowed_stroke(stroke)) {
return nullptr;
}
@@ -96,7 +96,7 @@
} else {
op->setTransformedBounds(bounds, op->fViewMatrix, HasAABloat::kNo, IsZeroArea::kNo);
}
- return std::unique_ptr<GrDrawOp>(op);
+ return std::unique_ptr<GrMeshDrawOp>(op);
}
private:
@@ -185,11 +185,11 @@
namespace GrNonAAStrokeRectOp {
-std::unique_ptr<GrDrawOp> Make(GrColor color,
- const SkMatrix& viewMatrix,
- const SkRect& rect,
- const SkStrokeRec& stroke,
- bool snapToPixelCenters) {
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkRect& rect,
+ const SkStrokeRec& stroke,
+ bool snapToPixelCenters) {
return NonAAStrokeRectOp::Make(color, viewMatrix, rect, stroke, snapToPixelCenters);
}
}
diff --git a/src/gpu/ops/GrNonAAStrokeRectOp.h b/src/gpu/ops/GrNonAAStrokeRectOp.h
index 9c46f40..5c9c98e 100644
--- a/src/gpu/ops/GrNonAAStrokeRectOp.h
+++ b/src/gpu/ops/GrNonAAStrokeRectOp.h
@@ -11,18 +11,18 @@
#include "GrColor.h"
#include "SkRefCnt.h"
-class GrDrawOp;
+class GrMeshDrawOp;
struct SkRect;
class SkStrokeRec;
class SkMatrix;
namespace GrNonAAStrokeRectOp {
-std::unique_ptr<GrDrawOp> Make(GrColor color,
- const SkMatrix& viewMatrix,
- const SkRect& rect,
- const SkStrokeRec&,
- bool snapToPixelCenters);
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkRect& rect,
+ const SkStrokeRec&,
+ bool snapToPixelCenters);
}
#endif
diff --git a/src/gpu/ops/GrOvalOpFactory.cpp b/src/gpu/ops/GrOvalOpFactory.cpp
index bf27f5a..8ab33f5 100644
--- a/src/gpu/ops/GrOvalOpFactory.cpp
+++ b/src/gpu/ops/GrOvalOpFactory.cpp
@@ -618,9 +618,9 @@
SkScalar fSweepAngleRadians;
bool fUseCenter;
};
- static std::unique_ptr<GrDrawOp> Make(GrColor color, const SkMatrix& viewMatrix, SkPoint center,
- SkScalar radius, const GrStyle& style,
- const ArcParams* arcParams = nullptr) {
+ static std::unique_ptr<GrMeshDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
+ SkPoint center, SkScalar radius, const GrStyle& style,
+ const ArcParams* arcParams = nullptr) {
SkASSERT(circle_stays_circle(viewMatrix));
const SkStrokeRec& stroke = style.strokeRec();
if (style.hasPathEffect()) {
@@ -1159,8 +1159,8 @@
class EllipseOp : public GrMeshDrawOp {
public:
DEFINE_OP_CLASS_ID
- static std::unique_ptr<GrDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
- const SkRect& ellipse, const SkStrokeRec& stroke) {
+ static std::unique_ptr<GrMeshDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
+ const SkRect& ellipse, const SkStrokeRec& stroke) {
SkASSERT(viewMatrix.rectStaysRect());
// do any matrix crunching before we reset the draw state for device coords
@@ -1378,10 +1378,10 @@
public:
DEFINE_OP_CLASS_ID
- static std::unique_ptr<GrDrawOp> Make(GrColor color,
- const SkMatrix& viewMatrix,
- const SkRect& ellipse,
- const SkStrokeRec& stroke) {
+ static std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkRect& ellipse,
+ const SkStrokeRec& stroke) {
SkPoint center = SkPoint::Make(ellipse.centerX(), ellipse.centerY());
SkScalar xRadius = SkScalarHalf(ellipse.width());
SkScalar yRadius = SkScalarHalf(ellipse.height());
@@ -2068,9 +2068,10 @@
// If devStrokeWidths values are <= 0 indicates then fill only. Otherwise, strokeOnly indicates
// whether the rrect is only stroked or stroked and filled.
- static std::unique_ptr<GrDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
- const SkRect& devRect, float devXRadius, float devYRadius,
- SkVector devStrokeWidths, bool strokeOnly) {
+ static std::unique_ptr<GrMeshDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
+ const SkRect& devRect, float devXRadius,
+ float devYRadius, SkVector devStrokeWidths,
+ bool strokeOnly) {
SkASSERT(devXRadius > 0.5);
SkASSERT(devYRadius > 0.5);
SkASSERT((devStrokeWidths.fX > 0) == (devStrokeWidths.fY > 0));
@@ -2280,11 +2281,11 @@
typedef GrMeshDrawOp INHERITED;
};
-static std::unique_ptr<GrDrawOp> make_rrect_op(GrColor color,
- bool needsDistance,
- const SkMatrix& viewMatrix,
- const SkRRect& rrect,
- const SkStrokeRec& stroke) {
+static std::unique_ptr<GrMeshDrawOp> make_rrect_op(GrColor color,
+ bool needsDistance,
+ const SkMatrix& viewMatrix,
+ const SkRRect& rrect,
+ const SkStrokeRec& stroke) {
SkASSERT(viewMatrix.rectStaysRect());
SkASSERT(rrect.isSimple());
SkASSERT(!rrect.isOval());
@@ -2342,7 +2343,7 @@
// if the corners are circles, use the circle renderer
if (isCircular) {
- return std::unique_ptr<GrDrawOp>(new CircularRRectOp(
+ return std::unique_ptr<GrMeshDrawOp>(new CircularRRectOp(
color, needsDistance, viewMatrix, bounds, xRadius, scaledStroke.fX, isStrokeOnly));
// otherwise we use the ellipse renderer
} else {
@@ -2351,12 +2352,12 @@
}
}
-std::unique_ptr<GrDrawOp> GrOvalOpFactory::MakeRRectOp(GrColor color,
- bool needsDistance,
- const SkMatrix& viewMatrix,
- const SkRRect& rrect,
- const SkStrokeRec& stroke,
- const GrShaderCaps* shaderCaps) {
+std::unique_ptr<GrMeshDrawOp> GrOvalOpFactory::MakeRRectOp(GrColor color,
+ bool needsDistance,
+ const SkMatrix& viewMatrix,
+ const SkRRect& rrect,
+ const SkStrokeRec& stroke,
+ const GrShaderCaps* shaderCaps) {
if (rrect.isOval()) {
return MakeOvalOp(color, viewMatrix, rrect.getBounds(), stroke, shaderCaps);
}
@@ -2370,11 +2371,11 @@
///////////////////////////////////////////////////////////////////////////////
-std::unique_ptr<GrDrawOp> GrOvalOpFactory::MakeOvalOp(GrColor color,
- const SkMatrix& viewMatrix,
- const SkRect& oval,
- const SkStrokeRec& stroke,
- const GrShaderCaps* shaderCaps) {
+std::unique_ptr<GrMeshDrawOp> GrOvalOpFactory::MakeOvalOp(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkRect& oval,
+ const SkStrokeRec& stroke,
+ const GrShaderCaps* shaderCaps) {
// we can draw circles
SkScalar width = oval.width();
if (SkScalarNearlyEqual(width, oval.height()) && circle_stays_circle(viewMatrix)) {
@@ -2397,11 +2398,11 @@
///////////////////////////////////////////////////////////////////////////////
-std::unique_ptr<GrDrawOp> GrOvalOpFactory::MakeArcOp(GrColor color, const SkMatrix& viewMatrix,
- const SkRect& oval, SkScalar startAngle,
- SkScalar sweepAngle, bool useCenter,
- const GrStyle& style,
- const GrShaderCaps* shaderCaps) {
+std::unique_ptr<GrMeshDrawOp> GrOvalOpFactory::MakeArcOp(GrColor color, const SkMatrix& viewMatrix,
+ const SkRect& oval, SkScalar startAngle,
+ SkScalar sweepAngle, bool useCenter,
+ const GrStyle& style,
+ const GrShaderCaps* shaderCaps) {
SkASSERT(!oval.isEmpty());
SkASSERT(sweepAngle);
SkScalar width = oval.width();
@@ -2444,8 +2445,8 @@
arcParamsTmp.fUseCenter = random->nextBool();
arcParams = &arcParamsTmp;
}
- std::unique_ptr<GrDrawOp> op = CircleOp::Make(color, viewMatrix, center, radius,
- GrStyle(stroke, nullptr), arcParams);
+ std::unique_ptr<GrMeshDrawOp> op = CircleOp::Make(color, viewMatrix, center, radius,
+ GrStyle(stroke, nullptr), arcParams);
if (op) {
return op;
}
diff --git a/src/gpu/ops/GrOvalOpFactory.h b/src/gpu/ops/GrOvalOpFactory.h
index 0ddcc9b..e6a160d 100644
--- a/src/gpu/ops/GrOvalOpFactory.h
+++ b/src/gpu/ops/GrOvalOpFactory.h
@@ -11,7 +11,7 @@
#include "GrColor.h"
#include "SkRefCnt.h"
-class GrDrawOp;
+class GrMeshDrawOp;
class GrShaderCaps;
class GrStyle;
class SkMatrix;
@@ -24,26 +24,26 @@
*/
class GrOvalOpFactory {
public:
- static std::unique_ptr<GrDrawOp> MakeOvalOp(GrColor,
- const SkMatrix& viewMatrix,
- const SkRect& oval,
- const SkStrokeRec& stroke,
- const GrShaderCaps* shaderCaps);
- static std::unique_ptr<GrDrawOp> MakeRRectOp(GrColor,
- bool needsDistance,
- const SkMatrix& viewMatrix,
- const SkRRect& rrect,
- const SkStrokeRec& stroke,
- const GrShaderCaps* shaderCaps);
+ static std::unique_ptr<GrMeshDrawOp> MakeOvalOp(GrColor,
+ const SkMatrix& viewMatrix,
+ const SkRect& oval,
+ const SkStrokeRec& stroke,
+ const GrShaderCaps* shaderCaps);
+ static std::unique_ptr<GrMeshDrawOp> MakeRRectOp(GrColor,
+ bool needsDistance,
+ const SkMatrix& viewMatrix,
+ const SkRRect& rrect,
+ const SkStrokeRec& stroke,
+ const GrShaderCaps* shaderCaps);
- static std::unique_ptr<GrDrawOp> MakeArcOp(GrColor,
- const SkMatrix& viewMatrix,
- const SkRect& oval,
- SkScalar startAngle,
- SkScalar sweepAngle,
- bool useCenter,
- const GrStyle&,
- const GrShaderCaps* shaderCaps);
+ static std::unique_ptr<GrMeshDrawOp> MakeArcOp(GrColor,
+ const SkMatrix& viewMatrix,
+ const SkRect& oval,
+ SkScalar startAngle,
+ SkScalar sweepAngle,
+ bool useCenter,
+ const GrStyle&,
+ const GrShaderCaps* shaderCaps);
};
#endif // GrOvalOpFactory_DEFINED
diff --git a/src/gpu/ops/GrRectOpFactory.cpp b/src/gpu/ops/GrRectOpFactory.cpp
index 5c8d344..e6d0c1f 100644
--- a/src/gpu/ops/GrRectOpFactory.cpp
+++ b/src/gpu/ops/GrRectOpFactory.cpp
@@ -8,14 +8,14 @@
#include "GrRectOpFactory.h"
#include "GrAAStrokeRectOp.h"
-
+#include "GrMeshDrawOp.h"
#include "SkStrokeRec.h"
namespace GrRectOpFactory {
-std::unique_ptr<GrDrawOp> MakeAAFillNestedRects(GrColor color,
- const SkMatrix& viewMatrix,
- const SkRect rects[2]) {
+std::unique_ptr<GrMeshDrawOp> MakeAAFillNestedRects(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkRect rects[2]) {
SkASSERT(viewMatrix.rectStaysRect());
SkASSERT(!rects[0].isEmpty() && !rects[1].isEmpty());
diff --git a/src/gpu/ops/GrRectOpFactory.h b/src/gpu/ops/GrRectOpFactory.h
index 3f42008..19bce7f 100644
--- a/src/gpu/ops/GrRectOpFactory.h
+++ b/src/gpu/ops/GrRectOpFactory.h
@@ -12,12 +12,12 @@
#include "GrAAStrokeRectOp.h"
#include "GrAnalyticRectOp.h"
#include "GrColor.h"
+#include "GrMeshDrawOp.h"
#include "GrNonAAFillRectOp.h"
#include "GrNonAAStrokeRectOp.h"
#include "GrPaint.h"
#include "SkMatrix.h"
#include "SkRefCnt.h"
-#include "ops/GrDrawOp.h"
struct SkRect;
class SkStrokeRec;
@@ -27,11 +27,11 @@
*/
namespace GrRectOpFactory {
-inline std::unique_ptr<GrDrawOp> MakeNonAAFill(GrColor color,
- const SkMatrix& viewMatrix,
- const SkRect& rect,
- const SkRect* localRect,
- const SkMatrix* localMatrix) {
+inline std::unique_ptr<GrMeshDrawOp> MakeNonAAFill(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkRect& rect,
+ const SkRect* localRect,
+ const SkMatrix* localMatrix) {
if (viewMatrix.hasPerspective() || (localMatrix && localMatrix->hasPerspective())) {
return GrNonAAFillRectOp::MakeWithPerspective(color, viewMatrix, rect, localRect,
localMatrix);
@@ -40,11 +40,11 @@
}
}
-inline std::unique_ptr<GrDrawOp> MakeAAFill(const GrPaint& paint,
- const SkMatrix& viewMatrix,
- const SkRect& rect,
- const SkRect& croppedRect,
- const SkRect& devRect) {
+inline std::unique_ptr<GrMeshDrawOp> MakeAAFill(const GrPaint& paint,
+ const SkMatrix& viewMatrix,
+ const SkRect& rect,
+ const SkRect& croppedRect,
+ const SkRect& devRect) {
if (!paint.usesDistanceVectorField()) {
return GrAAFillRectOp::Make(paint.getColor(), viewMatrix, croppedRect, devRect);
} else {
@@ -52,32 +52,32 @@
}
}
-inline std::unique_ptr<GrDrawOp> MakeAAFill(GrColor color,
- const SkMatrix& viewMatrix,
- const SkMatrix& localMatrix,
- const SkRect& rect,
- const SkRect& devRect) {
+inline std::unique_ptr<GrMeshDrawOp> MakeAAFill(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkMatrix& localMatrix,
+ const SkRect& rect,
+ const SkRect& devRect) {
return GrAAFillRectOp::Make(color, viewMatrix, localMatrix, rect, devRect);
}
-inline std::unique_ptr<GrDrawOp> MakeNonAAStroke(GrColor color,
- const SkMatrix& viewMatrix,
- const SkRect& rect,
- const SkStrokeRec& strokeRec,
- bool snapToPixelCenters) {
+inline std::unique_ptr<GrMeshDrawOp> MakeNonAAStroke(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkRect& rect,
+ const SkStrokeRec& strokeRec,
+ bool snapToPixelCenters) {
return GrNonAAStrokeRectOp::Make(color, viewMatrix, rect, strokeRec, snapToPixelCenters);
}
-inline std::unique_ptr<GrDrawOp> MakeAAStroke(GrColor color,
- const SkMatrix& viewMatrix,
- const SkRect& rect,
- const SkStrokeRec& stroke) {
+inline std::unique_ptr<GrMeshDrawOp> MakeAAStroke(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkRect& rect,
+ const SkStrokeRec& stroke) {
return GrAAStrokeRectOp::Make(color, viewMatrix, rect, stroke);
}
// First rect is outer; second rect is inner
-std::unique_ptr<GrDrawOp> MakeAAFillNestedRects(GrColor, const SkMatrix& viewMatrix,
- const SkRect rects[2]);
+std::unique_ptr<GrMeshDrawOp> MakeAAFillNestedRects(GrColor, const SkMatrix& viewMatrix,
+ const SkRect rects[2]);
};
#endif
diff --git a/src/gpu/ops/GrRegionOp.cpp b/src/gpu/ops/GrRegionOp.cpp
index e80a687..32cb8e4 100644
--- a/src/gpu/ops/GrRegionOp.cpp
+++ b/src/gpu/ops/GrRegionOp.cpp
@@ -149,7 +149,8 @@
namespace GrRegionOp {
-std::unique_ptr<GrDrawOp> Make(GrColor color, const SkMatrix& viewMatrix, const SkRegion& region) {
- return std::unique_ptr<GrDrawOp>(new RegionOp(color, viewMatrix, region));
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
+ const SkRegion& region) {
+ return std::unique_ptr<GrMeshDrawOp>(new RegionOp(color, viewMatrix, region));
}
}
diff --git a/src/gpu/ops/GrRegionOp.h b/src/gpu/ops/GrRegionOp.h
index e4b8f3e..5ee6f35 100644
--- a/src/gpu/ops/GrRegionOp.h
+++ b/src/gpu/ops/GrRegionOp.h
@@ -11,12 +11,13 @@
#include "GrColor.h"
#include "SkRefCnt.h"
-class GrDrawOp;
+class GrMeshDrawOp;
class SkMatrix;
class SkRegion;
namespace GrRegionOp {
-std::unique_ptr<GrDrawOp> Make(GrColor color, const SkMatrix& viewMatrix, const SkRegion& region);
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
+ const SkRegion& region);
}
#endif
diff --git a/src/gpu/ops/GrShadowRRectOp.cpp b/src/gpu/ops/GrShadowRRectOp.cpp
index 637c38a..1381bc9 100644
--- a/src/gpu/ops/GrShadowRRectOp.cpp
+++ b/src/gpu/ops/GrShadowRRectOp.cpp
@@ -67,9 +67,9 @@
public:
DEFINE_OP_CLASS_ID
- static std::unique_ptr<GrDrawOp> Make(GrColor color, const SkMatrix& viewMatrix, SkPoint center,
- SkScalar radius, SkScalar blurRadius,
- const GrStyle& style) {
+ static std::unique_ptr<GrMeshDrawOp> Make(GrColor color, const SkMatrix& viewMatrix,
+ SkPoint center, SkScalar radius, SkScalar blurRadius,
+ const GrStyle& style) {
SkASSERT(viewMatrix.isSimilarity());
const SkStrokeRec& stroke = style.strokeRec();
if (style.hasPathEffect()) {
@@ -806,12 +806,12 @@
///////////////////////////////////////////////////////////////////////////////
-std::unique_ptr<GrDrawOp> make_shadow_circle_op(GrColor color,
- const SkMatrix& viewMatrix,
- const SkRect& oval,
- SkScalar blurRadius,
- const SkStrokeRec& stroke,
- const GrShaderCaps* shaderCaps) {
+std::unique_ptr<GrMeshDrawOp> make_shadow_circle_op(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkRect& oval,
+ SkScalar blurRadius,
+ const SkStrokeRec& stroke,
+ const GrShaderCaps* shaderCaps) {
// we can only draw circles
SkScalar width = oval.width();
SkASSERT(SkScalarNearlyEqual(width, oval.height()) && viewMatrix.isSimilarity());
@@ -820,11 +820,11 @@
GrStyle(stroke, nullptr));
}
-static std::unique_ptr<GrDrawOp> make_shadow_rrect_op(GrColor color,
- const SkMatrix& viewMatrix,
- const SkRRect& rrect,
- SkScalar blurRadius,
- const SkStrokeRec& stroke) {
+static std::unique_ptr<GrMeshDrawOp> make_shadow_rrect_op(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkRRect& rrect,
+ SkScalar blurRadius,
+ const SkStrokeRec& stroke) {
SkASSERT(viewMatrix.rectStaysRect());
SkASSERT(rrect.isSimple());
SkASSERT(!rrect.isOval());
@@ -877,17 +877,17 @@
return nullptr;
}
- return std::unique_ptr<GrDrawOp>(new ShadowCircularRRectOp(
+ return std::unique_ptr<GrMeshDrawOp>(new ShadowCircularRRectOp(
color, viewMatrix, bounds, xRadius, blurRadius, scaledStroke.fX, isStrokeOnly));
}
namespace GrShadowRRectOp {
-std::unique_ptr<GrDrawOp> Make(GrColor color,
- const SkMatrix& viewMatrix,
- const SkRRect& rrect,
- const SkScalar blurRadius,
- const SkStrokeRec& stroke,
- const GrShaderCaps* shaderCaps) {
+std::unique_ptr<GrMeshDrawOp> Make(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkRRect& rrect,
+ const SkScalar blurRadius,
+ const SkStrokeRec& stroke,
+ const GrShaderCaps* shaderCaps) {
if (rrect.isOval()) {
return make_shadow_circle_op(color, viewMatrix, rrect.getBounds(), blurRadius, stroke,
shaderCaps);
@@ -920,8 +920,8 @@
SkScalar radius = circle.width() / 2.f;
SkStrokeRec stroke = GrTest::TestStrokeRec(random);
SkScalar blurRadius = random->nextSScalar1() * 72.f;
- std::unique_ptr<GrDrawOp> op = ShadowCircleOp::Make(color, viewMatrix, center, radius,
- blurRadius, GrStyle(stroke, nullptr));
+ std::unique_ptr<GrMeshDrawOp> op = ShadowCircleOp::Make(
+ color, viewMatrix, center, radius, blurRadius, GrStyle(stroke, nullptr));
if (op) {
return op;
}
diff --git a/src/gpu/ops/GrShadowRRectOp.h b/src/gpu/ops/GrShadowRRectOp.h
index 50e0102..081b217 100644
--- a/src/gpu/ops/GrShadowRRectOp.h
+++ b/src/gpu/ops/GrShadowRRectOp.h
@@ -11,7 +11,7 @@
#include "GrColor.h"
#include "SkRefCnt.h"
-class GrDrawOp;
+class GrMeshDrawOp;
class GrShaderCaps;
class SkMatrix;
class SkRRect;
@@ -19,9 +19,9 @@
namespace GrShadowRRectOp {
-std::unique_ptr<GrDrawOp> Make(GrColor, const SkMatrix& viewMatrix, const SkRRect& rrect,
- const SkScalar blurRadius, const SkStrokeRec& stroke,
- const GrShaderCaps* shaderCaps);
+std::unique_ptr<GrMeshDrawOp> Make(GrColor, const SkMatrix& viewMatrix, const SkRRect& rrect,
+ const SkScalar blurRadius, const SkStrokeRec& stroke,
+ const GrShaderCaps* shaderCaps);
}
#endif
diff --git a/src/gpu/ops/GrStencilAndCoverPathRenderer.cpp b/src/gpu/ops/GrStencilAndCoverPathRenderer.cpp
index 77d8d23..3b38163 100644
--- a/src/gpu/ops/GrStencilAndCoverPathRenderer.cpp
+++ b/src/gpu/ops/GrStencilAndCoverPathRenderer.cpp
@@ -112,7 +112,7 @@
}
const SkMatrix& viewM = viewMatrix.hasPerspective() ? SkMatrix::I() : viewMatrix;
- std::unique_ptr<GrDrawOp> coverOp(GrRectOpFactory::MakeNonAAFill(
+ std::unique_ptr<GrMeshDrawOp> coverOp(GrRectOpFactory::MakeNonAAFill(
args.fPaint.getColor(), viewM, bounds, nullptr, &invert));
// fake inverse with a stencil and cover
@@ -141,7 +141,8 @@
GrPipelineBuilder pipelineBuilder(std::move(args.fPaint), coverAAType);
pipelineBuilder.setUserStencil(&kInvertedCoverPass);
- args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, std::move(coverOp));
+ args.fRenderTargetContext->addMeshDrawOp(pipelineBuilder, *args.fClip,
+ std::move(coverOp));
}
} else {
static constexpr GrUserStencilSettings kCoverPass(
diff --git a/src/gpu/ops/GrTessellatingPathRenderer.cpp b/src/gpu/ops/GrTessellatingPathRenderer.cpp
index 7ecaf28..d1fd28a 100644
--- a/src/gpu/ops/GrTessellatingPathRenderer.cpp
+++ b/src/gpu/ops/GrTessellatingPathRenderer.cpp
@@ -160,12 +160,12 @@
public:
DEFINE_OP_CLASS_ID
- static std::unique_ptr<GrDrawOp> Make(const GrColor& color,
- const GrShape& shape,
- const SkMatrix& viewMatrix,
- SkIRect devClipBounds,
- bool antiAlias) {
- return std::unique_ptr<GrDrawOp>(
+ static std::unique_ptr<GrMeshDrawOp> Make(const GrColor& color,
+ const GrShape& shape,
+ const SkMatrix& viewMatrix,
+ SkIRect devClipBounds,
+ bool antiAlias) {
+ return std::unique_ptr<GrMeshDrawOp>(
new TessellatingPathOp(color, shape, viewMatrix, devClipBounds, antiAlias));
}
@@ -357,14 +357,15 @@
args.fClip->getConservativeBounds(args.fRenderTargetContext->width(),
args.fRenderTargetContext->height(),
&clipBoundsI);
- std::unique_ptr<GrDrawOp> op = TessellatingPathOp::Make(args.fPaint.getColor(),
- *args.fShape,
- *args.fViewMatrix,
- clipBoundsI,
- GrAAType::kCoverage == args.fAAType);
+ std::unique_ptr<GrMeshDrawOp> op =
+ TessellatingPathOp::Make(args.fPaint.getColor(),
+ *args.fShape,
+ *args.fViewMatrix,
+ clipBoundsI,
+ GrAAType::kCoverage == args.fAAType);
GrPipelineBuilder pipelineBuilder(std::move(args.fPaint), args.fAAType);
pipelineBuilder.setUserStencil(args.fUserStencilSettings);
- args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, std::move(op));
+ args.fRenderTargetContext->addMeshDrawOp(pipelineBuilder, *args.fClip, std::move(op));
return true;
}
diff --git a/src/gpu/text/GrAtlasTextBlob.cpp b/src/gpu/text/GrAtlasTextBlob.cpp
index 601eb37..accdf6b 100644
--- a/src/gpu/text/GrAtlasTextBlob.cpp
+++ b/src/gpu/text/GrAtlasTextBlob.cpp
@@ -256,7 +256,7 @@
return false;
}
-inline std::unique_ptr<GrDrawOp> GrAtlasTextBlob::makeOp(
+inline std::unique_ptr<GrMeshDrawOp> GrAtlasTextBlob::makeOp(
const Run::SubRunInfo& info, int glyphCount, int run, int subRun,
const SkMatrix& viewMatrix, SkScalar x, SkScalar y, const GrTextUtils::Paint& paint,
const SkSurfaceProps& props, const GrDistanceFieldAdjustTable* distanceAdjustTable,
@@ -304,12 +304,12 @@
continue;
}
- std::unique_ptr<GrDrawOp> op(this->makeOp(info, glyphCount, run, subRun, viewMatrix, x, y,
- paint, props, distanceAdjustTable,
- rtc->isGammaCorrect(), cache));
+ std::unique_ptr<GrMeshDrawOp> op(this->makeOp(info, glyphCount, run, subRun, viewMatrix, x,
+ y, paint, props, distanceAdjustTable,
+ rtc->isGammaCorrect(), cache));
GrPipelineBuilder pipelineBuilder(std::move(grPaint), GrAAType::kNone);
- rtc->addDrawOp(pipelineBuilder, clip, std::move(op));
+ rtc->addMeshDrawOp(pipelineBuilder, clip, std::move(op));
}
}
@@ -424,7 +424,7 @@
this->flushBigGlyphs(context, rtc, clip, paint, viewMatrix, x, y, clipBounds);
}
-std::unique_ptr<GrDrawOp> GrAtlasTextBlob::test_makeOp(
+std::unique_ptr<GrMeshDrawOp> GrAtlasTextBlob::test_makeOp(
int glyphCount, int run, int subRun, const SkMatrix& viewMatrix, SkScalar x, SkScalar y,
const GrTextUtils::Paint& paint, const SkSurfaceProps& props,
const GrDistanceFieldAdjustTable* distanceAdjustTable, GrAtlasGlyphCache* cache) {
diff --git a/src/gpu/text/GrAtlasTextBlob.h b/src/gpu/text/GrAtlasTextBlob.h
index 787518d..7d686a9 100644
--- a/src/gpu/text/GrAtlasTextBlob.h
+++ b/src/gpu/text/GrAtlasTextBlob.h
@@ -24,6 +24,7 @@
class GrBlobRegenHelper;
struct GrDistanceFieldAdjustTable;
class GrMemoryPool;
+class GrMeshDrawOp;
class SkDrawFilter;
class SkTextBlob;
class SkTextBlobRunIterator;
@@ -269,12 +270,12 @@
////////////////////////////////////////////////////////////////////////////////////////////////
// Internal test methods
- std::unique_ptr<GrDrawOp> test_makeOp(int glyphCount, int run, int subRun,
- const SkMatrix& viewMatrix, SkScalar x, SkScalar y,
- const GrTextUtils::Paint& paint,
- const SkSurfaceProps& props,
- const GrDistanceFieldAdjustTable* distanceAdjustTable,
- GrAtlasGlyphCache* cache);
+ std::unique_ptr<GrMeshDrawOp> test_makeOp(int glyphCount, int run, int subRun,
+ const SkMatrix& viewMatrix, SkScalar x, SkScalar y,
+ const GrTextUtils::Paint& paint,
+ const SkSurfaceProps& props,
+ const GrDistanceFieldAdjustTable* distanceAdjustTable,
+ GrAtlasGlyphCache* cache);
private:
GrAtlasTextBlob()
@@ -488,13 +489,11 @@
Run* run, Run::SubRunInfo* info, SkAutoGlyphCache*, int glyphCount,
size_t vertexStride, GrColor color, SkScalar transX, SkScalar transY) const;
- inline std::unique_ptr<GrDrawOp> makeOp(const Run::SubRunInfo& info, int glyphCount, int run,
- int subRun, const SkMatrix& viewMatrix, SkScalar x,
- SkScalar y, const GrTextUtils::Paint& paint,
- const SkSurfaceProps& props,
- const GrDistanceFieldAdjustTable* distanceAdjustTable,
- bool useGammaCorrectDistanceTable,
- GrAtlasGlyphCache* cache);
+ inline std::unique_ptr<GrMeshDrawOp> makeOp(
+ const Run::SubRunInfo& info, int glyphCount, int run, int subRun,
+ const SkMatrix& viewMatrix, SkScalar x, SkScalar y, const GrTextUtils::Paint& paint,
+ const SkSurfaceProps& props, const GrDistanceFieldAdjustTable* distanceAdjustTable,
+ bool useGammaCorrectDistanceTable, GrAtlasGlyphCache* cache);
struct BigGlyph {
BigGlyph(const SkPath& path, SkScalar vx, SkScalar vy, SkScalar scale, bool treatAsBMP)
diff --git a/src/gpu/text/GrAtlasTextContext.cpp b/src/gpu/text/GrAtlasTextContext.cpp
index 512df0a..e15281e 100644
--- a/src/gpu/text/GrAtlasTextContext.cpp
+++ b/src/gpu/text/GrAtlasTextContext.cpp
@@ -5,13 +5,13 @@
* found in the LICENSE file.
*/
#include "GrAtlasTextContext.h"
-
#include "GrContext.h"
#include "GrRenderTargetContext.h"
#include "GrTextBlobCache.h"
#include "SkDraw.h"
#include "SkDrawFilter.h"
#include "SkGr.h"
+#include "ops/GrMeshDrawOp.h"
GrAtlasTextContext::GrAtlasTextContext()
: fDistanceAdjustTable(new GrDistanceFieldAdjustTable) {
diff --git a/tests/GLProgramsTest.cpp b/tests/GLProgramsTest.cpp
index 7628847..688c592 100644
--- a/tests/GLProgramsTest.cpp
+++ b/tests/GLProgramsTest.cpp
@@ -323,7 +323,7 @@
GrPaint grPaint;
- std::unique_ptr<GrDrawOp> op(GrRandomDrawOp(&random, context));
+ std::unique_ptr<GrMeshDrawOp> op(GrRandomDrawOp(&random, context));
SkASSERT(op);
GrProcessorTestData ptd(&random, context, renderTargetContext.get(), dummyTextures);
@@ -336,8 +336,8 @@
static constexpr GrAAType kAATypes[] = {GrAAType::kNone, GrAAType::kCoverage};
GrAAType aaType = kAATypes[random.nextULessThan(SK_ARRAY_COUNT(kAATypes))];
- renderTargetContext->priv().testingOnly_addDrawOp(std::move(grPaint), aaType, std::move(op),
- uss, snapToCenters);
+ renderTargetContext->priv().testingOnly_addMeshDrawOp(std::move(grPaint), aaType,
+ std::move(op), uss, snapToCenters);
}
// Flush everything, test passes if flush is successful(ie, no asserts are hit, no crashes)
drawingManager->flush();
@@ -358,7 +358,7 @@
for (int i = 0; i < fpFactoryCnt; ++i) {
// Since FP factories internally randomize, call each 10 times.
for (int j = 0; j < 10; ++j) {
- std::unique_ptr<GrDrawOp> op(GrRandomDrawOp(&random, context));
+ std::unique_ptr<GrMeshDrawOp> op(GrRandomDrawOp(&random, context));
SkASSERT(op);
GrProcessorTestData ptd(&random, context, renderTargetContext.get(), dummyTextures);
GrPaint grPaint;
@@ -370,8 +370,8 @@
BlockInputFragmentProcessor::Make(std::move(fp)));
grPaint.addColorFragmentProcessor(std::move(blockFP));
- renderTargetContext->priv().testingOnly_addDrawOp(std::move(grPaint), GrAAType::kNone,
- std::move(op));
+ renderTargetContext->priv().testingOnly_addMeshDrawOp(
+ std::move(grPaint), GrAAType::kNone, std::move(op));
drawingManager->flush();
}
}
diff --git a/tests/PrimitiveProcessorTest.cpp b/tests/PrimitiveProcessorTest.cpp
index 25f1413..30bfed9 100644
--- a/tests/PrimitiveProcessorTest.cpp
+++ b/tests/PrimitiveProcessorTest.cpp
@@ -31,8 +31,8 @@
const char* name() const override { return "Dummy Op"; }
- static std::unique_ptr<GrDrawOp> Make(int numAttribs) {
- return std::unique_ptr<GrDrawOp>(new Op(numAttribs));
+ static std::unique_ptr<GrMeshDrawOp> Make(int numAttribs) {
+ return std::unique_ptr<GrMeshDrawOp>(new Op(numAttribs));
}
private:
@@ -125,16 +125,16 @@
#endif
GrPaint grPaint;
// This one should succeed.
- renderTargetContext->priv().testingOnly_addDrawOp(GrPaint(grPaint), GrAAType::kNone,
- Op::Make(attribCnt));
+ renderTargetContext->priv().testingOnly_addMeshDrawOp(GrPaint(grPaint), GrAAType::kNone,
+ Op::Make(attribCnt));
context->flush();
#if GR_GPU_STATS
REPORTER_ASSERT(reporter, context->getGpu()->stats()->numDraws() == 1);
REPORTER_ASSERT(reporter, context->getGpu()->stats()->numFailedDraws() == 0);
#endif
context->resetGpuStats();
- renderTargetContext->priv().testingOnly_addDrawOp(std::move(grPaint), GrAAType::kNone,
- Op::Make(attribCnt + 1));
+ renderTargetContext->priv().testingOnly_addMeshDrawOp(std::move(grPaint), GrAAType::kNone,
+ Op::Make(attribCnt + 1));
context->flush();
#if GR_GPU_STATS
REPORTER_ASSERT(reporter, context->getGpu()->stats()->numDraws() == 0);
diff --git a/tests/ProcessorTest.cpp b/tests/ProcessorTest.cpp
index 03646e1..7d9349b 100644
--- a/tests/ProcessorTest.cpp
+++ b/tests/ProcessorTest.cpp
@@ -27,7 +27,9 @@
DEFINE_OP_CLASS_ID
const char* name() const override { return "TestOp"; }
- static std::unique_ptr<GrDrawOp> Make() { return std::unique_ptr<GrDrawOp>(new TestOp); }
+ static std::unique_ptr<GrMeshDrawOp> Make() {
+ return std::unique_ptr<GrMeshDrawOp>(new TestOp);
+ }
private:
TestOp() : INHERITED(ClassID(), SkRect::MakeWH(100, 100), 0xFFFFFFFF) {}
@@ -167,7 +169,7 @@
images.emplace_back(texture3, GrIOType::kWrite_GrIOType);
images.emplace_back(texture4, GrIOType::kRW_GrIOType);
}
- std::unique_ptr<GrDrawOp> op(TestOp::Make());
+ std::unique_ptr<GrMeshDrawOp> op(TestOp::Make());
GrPaint paint;
auto fp = TestFP::Make(context,
std::move(proxies), std::move(buffers), std::move(images));
@@ -175,8 +177,8 @@
fp = TestFP::Make(std::move(fp));
}
paint.addColorFragmentProcessor(std::move(fp));
- renderTargetContext->priv().testingOnly_addDrawOp(std::move(paint), GrAAType::kNone,
- std::move(op));
+ renderTargetContext->priv().testingOnly_addMeshDrawOp(
+ std::move(paint), GrAAType::kNone, std::move(op));
}
int refCnt, readCnt, writeCnt;
@@ -264,7 +266,7 @@
auto op =
GrNonAAFillRectOp::Make(GrColor_WHITE, SkMatrix::I(),
SkRect::MakeWH(rtc->width(), rtc->height()), nullptr, nullptr);
- rtc->addDrawOp(pb, GrNoClip(), std::move(op));
+ rtc->addMeshDrawOp(pb, GrNoClip(), std::move(op));
}
#if GR_TEST_UTILS
diff --git a/tools/gpu/GrTest.cpp b/tools/gpu/GrTest.cpp
index f70aa26..fa0556d 100644
--- a/tools/gpu/GrTest.cpp
+++ b/tools/gpu/GrTest.cpp
@@ -234,18 +234,18 @@
#define ASSERT_SINGLE_OWNER \
SkDEBUGCODE(GrSingleOwner::AutoEnforce debug_SingleOwner(fRenderTargetContext->fSingleOwner);)
-uint32_t GrRenderTargetContextPriv::testingOnly_addDrawOp(GrPaint&& paint,
- GrAAType aaType,
- std::unique_ptr<GrDrawOp> op,
- const GrUserStencilSettings* uss,
- bool snapToCenters) {
+uint32_t GrRenderTargetContextPriv::testingOnly_addMeshDrawOp(GrPaint&& paint,
+ GrAAType aaType,
+ std::unique_ptr<GrMeshDrawOp> op,
+ const GrUserStencilSettings* uss,
+ bool snapToCenters) {
ASSERT_SINGLE_OWNER
if (fRenderTargetContext->drawingManager()->wasAbandoned()) {
return SK_InvalidUniqueID;
}
SkDEBUGCODE(fRenderTargetContext->validate();)
GR_AUDIT_TRAIL_AUTO_FRAME(fRenderTargetContext->fAuditTrail,
- "GrRenderTargetContext::testingOnly_addDrawOp");
+ "GrRenderTargetContext::testingOnly_addMeshDrawOp");
GrPipelineBuilder pipelineBuilder(std::move(paint), aaType);
if (uss) {
@@ -253,7 +253,7 @@
}
pipelineBuilder.setSnapVerticesToPixelCenters(snapToCenters);
- return fRenderTargetContext->addDrawOp(pipelineBuilder, GrNoClip(), std::move(op));
+ return fRenderTargetContext->addMeshDrawOp(pipelineBuilder, GrNoClip(), std::move(op));
}
#undef ASSERT_SINGLE_OWNER