aboutsummaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/gpu/GrDrawContext.cpp137
-rw-r--r--src/gpu/GrOvalRenderer.cpp218
-rw-r--r--src/gpu/GrOvalRenderer.h71
3 files changed, 188 insertions, 238 deletions
diff --git a/src/gpu/GrDrawContext.cpp b/src/gpu/GrDrawContext.cpp
index 67013ff4f1..e8761e95e7 100644
--- a/src/gpu/GrDrawContext.cpp
+++ b/src/gpu/GrDrawContext.cpp
@@ -23,6 +23,8 @@
#include "batches/GrRectBatchFactory.h"
#include "batches/GrNinePatch.h" // TODO Factory
+#include "effects/GrRRectEffect.h"
+
#include "text/GrAtlasTextContext.h"
#include "text/GrStencilAndCoverTextContext.h"
@@ -494,13 +496,17 @@ void GrDrawContext::drawRRect(const GrClip& clip,
GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
GrColor color = paint.getColor();
- if (!GrOvalRenderer::DrawRRect(this->getDrawTarget(),
- pipelineBuilder,
- color,
- viewMatrix,
- paint.isAntiAlias(),
- rrect,
- strokeInfo)) {
+ GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
+ SkAutoTUnref<GrDrawBatch> batch(GrOvalRenderer::CreateRRectBatch(pipelineBuilder,
+ color,
+ viewMatrix,
+ paint.isAntiAlias(),
+ rrect,
+ strokeInfo,
+ shaderCaps));
+ if (batch) {
+ this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
+ } else {
SkPath path;
path.setIsVolatile(true);
path.addRRect(rrect);
@@ -511,6 +517,77 @@ void GrDrawContext::drawRRect(const GrClip& clip,
///////////////////////////////////////////////////////////////////////////////
+static bool draw_drrect(GrDrawTarget* drawTarget,
+ const GrPipelineBuilder& pipelineBuilder,
+ GrColor color,
+ const SkMatrix& viewMatrix,
+ bool useAA,
+ const SkRRect& origOuter,
+ const SkRRect& origInner,
+ GrShaderCaps* shaderCaps) {
+ bool applyAA = useAA && !pipelineBuilder.getRenderTarget()->isUnifiedMultisampled();
+ GrPipelineBuilder::AutoRestoreFragmentProcessorState arfps;
+ if (!origInner.isEmpty()) {
+ SkTCopyOnFirstWrite<SkRRect> inner(origInner);
+ if (!viewMatrix.isIdentity()) {
+ if (!origInner.transform(viewMatrix, inner.writable())) {
+ return false;
+ }
+ }
+ GrPrimitiveEdgeType edgeType = applyAA ?
+ kInverseFillAA_GrProcessorEdgeType :
+ kInverseFillBW_GrProcessorEdgeType;
+ // TODO this needs to be a geometry processor
+ GrFragmentProcessor* fp = GrRRectEffect::Create(edgeType, *inner);
+ if (nullptr == fp) {
+ return false;
+ }
+ arfps.set(&pipelineBuilder);
+ arfps.addCoverageFragmentProcessor(fp)->unref();
+ }
+
+ SkStrokeRec fillRec(SkStrokeRec::kFill_InitStyle);
+ SkAutoTUnref<GrDrawBatch> batch(GrOvalRenderer::CreateRRectBatch(pipelineBuilder, color,
+ viewMatrix, useAA, origOuter,
+ fillRec, shaderCaps));
+ if (batch) {
+ drawTarget->drawBatch(pipelineBuilder, batch);
+ return true;
+ }
+
+ SkASSERT(!origOuter.isEmpty());
+ SkTCopyOnFirstWrite<SkRRect> outer(origOuter);
+ if (!viewMatrix.isIdentity()) {
+ if (!origOuter.transform(viewMatrix, outer.writable())) {
+ return false;
+ }
+ }
+ GrPrimitiveEdgeType edgeType = applyAA ? kFillAA_GrProcessorEdgeType :
+ kFillBW_GrProcessorEdgeType;
+ SkAutoTUnref<GrFragmentProcessor> effect(GrRRectEffect::Create(edgeType, *outer));
+ if (!effect) {
+ return false;
+ }
+ if (!arfps.isSet()) {
+ arfps.set(&pipelineBuilder);
+ }
+
+ SkMatrix invert;
+ if (!viewMatrix.invert(&invert)) {
+ return false;
+ }
+
+ arfps.addCoverageFragmentProcessor(effect);
+ SkRect bounds = outer->getBounds();
+ if (applyAA) {
+ bounds.outset(SK_ScalarHalf, SK_ScalarHalf);
+ }
+ batch.reset(GrRectBatchFactory::CreateNonAAFill(color, SkMatrix::I(), bounds,
+ nullptr, &invert));
+ drawTarget->drawBatch(pipelineBuilder, batch);
+ return true;
+}
+
void GrDrawContext::drawDRRect(const GrClip& clip,
const GrPaint& paint,
const SkMatrix& viewMatrix,
@@ -529,13 +606,10 @@ void GrDrawContext::drawDRRect(const GrClip& clip,
GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
GrColor color = paint.getColor();
- if (!GrOvalRenderer::DrawDRRect(this->getDrawTarget(),
- pipelineBuilder,
- color,
- viewMatrix,
- paint.isAntiAlias(),
- outer,
- inner)) {
+
+ if (!draw_drrect(this->getDrawTarget(), pipelineBuilder,
+ color, viewMatrix, paint.isAntiAlias(),
+ outer, inner, fContext->caps()->shaderCaps())) {
SkPath path;
path.setIsVolatile(true);
path.addRRect(inner);
@@ -571,13 +645,17 @@ void GrDrawContext::drawOval(const GrClip& clip,
GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
GrColor color = paint.getColor();
- if (!GrOvalRenderer::DrawOval(this->getDrawTarget(),
- pipelineBuilder,
- color,
- viewMatrix,
- paint.isAntiAlias(),
- oval,
- strokeInfo)) {
+ GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
+ SkAutoTUnref<GrDrawBatch> batch(GrOvalRenderer::CreateOvalBatch(pipelineBuilder,
+ color,
+ viewMatrix,
+ paint.isAntiAlias(),
+ oval,
+ strokeInfo,
+ shaderCaps));
+ if (batch) {
+ this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
+ } else {
SkPath path;
path.setIsVolatile(true);
path.addOval(oval);
@@ -729,13 +807,16 @@ void GrDrawContext::drawPath(const GrClip& clip,
bool isOval = path.isOval(&ovalRect);
if (isOval && !path.isInverseFillType()) {
- if (GrOvalRenderer::DrawOval(this->getDrawTarget(),
- pipelineBuilder,
- color,
- viewMatrix,
- paint.isAntiAlias(),
- ovalRect,
- strokeInfo)) {
+ GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
+ SkAutoTUnref<GrDrawBatch> batch(GrOvalRenderer::CreateOvalBatch(pipelineBuilder,
+ color,
+ viewMatrix,
+ paint.isAntiAlias(),
+ ovalRect,
+ strokeInfo,
+ shaderCaps));
+ if (batch) {
+ this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
return;
}
}
diff --git a/src/gpu/GrOvalRenderer.cpp b/src/gpu/GrOvalRenderer.cpp
index 02019c1d1e..1c41f27b07 100644
--- a/src/gpu/GrOvalRenderer.cpp
+++ b/src/gpu/GrOvalRenderer.cpp
@@ -9,19 +9,14 @@
#include "GrBatchFlushState.h"
#include "GrBatchTest.h"
-#include "GrDrawTarget.h"
#include "GrGeometryProcessor.h"
#include "GrInvariantOutput.h"
#include "GrPipelineBuilder.h"
#include "GrProcessor.h"
#include "GrResourceProvider.h"
-#include "GrVertexBuffer.h"
#include "SkRRect.h"
#include "SkStrokeRec.h"
-#include "SkTLazy.h"
-#include "batches/GrRectBatchFactory.h"
#include "batches/GrVertexBatch.h"
-#include "effects/GrRRectEffect.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLGeometryProcessor.h"
#include "glsl/GrGLSLProgramDataManager.h"
@@ -585,35 +580,34 @@ const GrGeometryProcessor* DIEllipseEdgeEffect::TestCreate(GrProcessorTestData*
///////////////////////////////////////////////////////////////////////////////
-bool GrOvalRenderer::DrawOval(GrDrawTarget* target,
- const GrPipelineBuilder& pipelineBuilder,
- GrColor color,
- const SkMatrix& viewMatrix,
- bool useAA,
- const SkRect& oval,
- const SkStrokeRec& stroke) {
+GrDrawBatch* GrOvalRenderer::CreateOvalBatch(const GrPipelineBuilder& pipelineBuilder,
+ GrColor color,
+ const SkMatrix& viewMatrix,
+ bool useAA,
+ const SkRect& oval,
+ const SkStrokeRec& stroke,
+ GrShaderCaps* shaderCaps) {
bool useCoverageAA = useAA && !pipelineBuilder.getRenderTarget()->isUnifiedMultisampled();
-
if (!useCoverageAA) {
- return false;
+ return nullptr;
}
// we can draw circles
if (SkScalarNearlyEqual(oval.width(), oval.height()) && circle_stays_circle(viewMatrix)) {
- DrawCircle(target, pipelineBuilder, color, viewMatrix, useCoverageAA, oval, stroke);
+ return CreateCircleBatch(color, viewMatrix, oval, stroke);
+ }
+
// if we have shader derivative support, render as device-independent
- } else if (target->caps()->shaderCaps()->shaderDerivativeSupport()) {
- return DrawDIEllipse(target, pipelineBuilder, color, viewMatrix, useCoverageAA, oval,
- stroke);
+ if (shaderCaps->shaderDerivativeSupport()) {
+ return CreateDIEllipseBatch(color, viewMatrix, oval, stroke);
+ }
+
// otherwise axis-aligned ellipses only
- } else if (viewMatrix.rectStaysRect()) {
- return DrawEllipse(target, pipelineBuilder, color, viewMatrix, useCoverageAA, oval,
- stroke);
- } else {
- return false;
+ if (viewMatrix.rectStaysRect()) {
+ return CreateEllipseBatch(color, viewMatrix, oval, stroke);
}
- return true;
+ return nullptr;
}
///////////////////////////////////////////////////////////////////////////////
@@ -788,7 +782,6 @@ private:
static GrDrawBatch* create_circle_batch(GrColor color,
const SkMatrix& viewMatrix,
- bool useCoverageAA,
const SkRect& circle,
const SkStrokeRec& stroke) {
SkPoint center = SkPoint::Make(circle.centerX(), circle.centerY());
@@ -836,16 +829,11 @@ static GrDrawBatch* create_circle_batch(GrColor color,
return CircleBatch::Create(geometry);
}
-void GrOvalRenderer::DrawCircle(GrDrawTarget* target,
- const GrPipelineBuilder& pipelineBuilder,
- GrColor color,
- const SkMatrix& viewMatrix,
- bool useCoverageAA,
- const SkRect& circle,
- const SkStrokeRec& stroke) {
- SkAutoTUnref<GrDrawBatch> batch(create_circle_batch(color, viewMatrix, useCoverageAA, circle,
- stroke));
- target->drawBatch(pipelineBuilder, batch);
+GrDrawBatch* GrOvalRenderer::CreateCircleBatch(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkRect& circle,
+ const SkStrokeRec& stroke) {
+ return create_circle_batch(color, viewMatrix, circle, stroke);
}
///////////////////////////////////////////////////////////////////////////////
@@ -1013,16 +1001,9 @@ private:
static GrDrawBatch* create_ellipse_batch(GrColor color,
const SkMatrix& viewMatrix,
- bool useCoverageAA,
const SkRect& ellipse,
const SkStrokeRec& stroke) {
-#ifdef SK_DEBUG
- {
- // we should have checked for this previously
- bool isAxisAlignedEllipse = viewMatrix.rectStaysRect();
- SkASSERT(useCoverageAA && isAxisAlignedEllipse);
- }
-#endif
+ SkASSERT(viewMatrix.rectStaysRect());
// do any matrix crunching before we reset the draw state for device coords
SkPoint center = SkPoint::Make(ellipse.centerX(), ellipse.centerY());
@@ -1098,21 +1079,11 @@ static GrDrawBatch* create_ellipse_batch(GrColor color,
return EllipseBatch::Create(geometry);
}
-bool GrOvalRenderer::DrawEllipse(GrDrawTarget* target,
- const GrPipelineBuilder& pipelineBuilder,
- GrColor color,
- const SkMatrix& viewMatrix,
- bool useCoverageAA,
- const SkRect& ellipse,
- const SkStrokeRec& stroke) {
- SkAutoTUnref<GrDrawBatch> batch(create_ellipse_batch(color, viewMatrix, useCoverageAA, ellipse,
- stroke));
- if (!batch) {
- return false;
- }
-
- target->drawBatch(pipelineBuilder, batch);
- return true;
+GrDrawBatch* GrOvalRenderer::CreateEllipseBatch(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkRect& ellipse,
+ const SkStrokeRec& stroke) {
+ return create_ellipse_batch(color, viewMatrix, ellipse, stroke);
}
/////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1275,7 +1246,6 @@ private:
static GrDrawBatch* create_diellipse_batch(GrColor color,
const SkMatrix& viewMatrix,
- bool useCoverageAA,
const SkRect& ellipse,
const SkStrokeRec& stroke) {
SkPoint center = SkPoint::Make(ellipse.centerX(), ellipse.centerY());
@@ -1351,20 +1321,11 @@ static GrDrawBatch* create_diellipse_batch(GrColor color,
return DIEllipseBatch::Create(geometry, devBounds);
}
-bool GrOvalRenderer::DrawDIEllipse(GrDrawTarget* target,
- const GrPipelineBuilder& pipelineBuilder,
- GrColor color,
- const SkMatrix& viewMatrix,
- bool useCoverageAA,
- const SkRect& ellipse,
- const SkStrokeRec& stroke) {
- SkAutoTUnref<GrDrawBatch> batch(create_diellipse_batch(color, viewMatrix, useCoverageAA,
- ellipse, stroke));
- if (!batch) {
- return false;
- }
- target->drawBatch(pipelineBuilder, batch);
- return true;
+GrDrawBatch* GrOvalRenderer::CreateDIEllipseBatch(GrColor color,
+ const SkMatrix& viewMatrix,
+ const SkRect& ellipse,
+ const SkStrokeRec& stroke) {
+ return create_diellipse_batch(color, viewMatrix, ellipse, stroke);
}
///////////////////////////////////////////////////////////////////////////////
@@ -1410,72 +1371,6 @@ static const GrIndexBuffer* ref_rrect_index_buffer(bool strokeOnly,
}
}
-bool GrOvalRenderer::DrawDRRect(GrDrawTarget* target,
- const GrPipelineBuilder& pipelineBuilder,
- GrColor color,
- const SkMatrix& viewMatrix,
- bool useAA,
- const SkRRect& origOuter,
- const SkRRect& origInner) {
- bool applyAA = useAA && !pipelineBuilder.getRenderTarget()->isUnifiedMultisampled();
- GrPipelineBuilder::AutoRestoreFragmentProcessorState arfps;
- if (!origInner.isEmpty()) {
- SkTCopyOnFirstWrite<SkRRect> inner(origInner);
- if (!viewMatrix.isIdentity()) {
- if (!origInner.transform(viewMatrix, inner.writable())) {
- return false;
- }
- }
- GrPrimitiveEdgeType edgeType = applyAA ?
- kInverseFillAA_GrProcessorEdgeType :
- kInverseFillBW_GrProcessorEdgeType;
- // TODO this needs to be a geometry processor
- GrFragmentProcessor* fp = GrRRectEffect::Create(edgeType, *inner);
- if (nullptr == fp) {
- return false;
- }
- arfps.set(&pipelineBuilder);
- arfps.addCoverageFragmentProcessor(fp)->unref();
- }
-
- SkStrokeRec fillRec(SkStrokeRec::kFill_InitStyle);
- if (DrawRRect(target, pipelineBuilder, color, viewMatrix, useAA, origOuter, fillRec)) {
- return true;
- }
-
- SkASSERT(!origOuter.isEmpty());
- SkTCopyOnFirstWrite<SkRRect> outer(origOuter);
- if (!viewMatrix.isIdentity()) {
- if (!origOuter.transform(viewMatrix, outer.writable())) {
- return false;
- }
- }
- GrPrimitiveEdgeType edgeType = applyAA ? kFillAA_GrProcessorEdgeType :
- kFillBW_GrProcessorEdgeType;
- GrFragmentProcessor* effect = GrRRectEffect::Create(edgeType, *outer);
- if (nullptr == effect) {
- return false;
- }
- if (!arfps.isSet()) {
- arfps.set(&pipelineBuilder);
- }
-
- SkMatrix invert;
- if (!viewMatrix.invert(&invert)) {
- return false;
- }
-
- arfps.addCoverageFragmentProcessor(effect)->unref();
- SkRect bounds = outer->getBounds();
- if (applyAA) {
- bounds.outset(SK_ScalarHalf, SK_ScalarHalf);
- }
- SkAutoTUnref<GrDrawBatch> batch(GrRectBatchFactory::CreateNonAAFill(color, SkMatrix::I(),
- bounds, nullptr, &invert));
- target->drawBatch(pipelineBuilder, batch);
- return true;
-}
-
///////////////////////////////////////////////////////////////////////////////////////////////////
class RRectCircleRendererBatch : public GrVertexBatch {
@@ -1995,36 +1890,30 @@ static GrDrawBatch* create_rrect_batch(GrColor color,
}
}
-bool GrOvalRenderer::DrawRRect(GrDrawTarget* target,
- const GrPipelineBuilder& pipelineBuilder,
- GrColor color,
- const SkMatrix& viewMatrix,
- bool useAA,
- const SkRRect& rrect,
- const SkStrokeRec& stroke) {
- if (rrect.isOval()) {
- return DrawOval(target, pipelineBuilder, color, viewMatrix, useAA, rrect.getBounds(),
- stroke);
- }
-
+GrDrawBatch* GrOvalRenderer::CreateRRectBatch(const GrPipelineBuilder& pipelineBuilder,
+ GrColor color,
+ const SkMatrix& viewMatrix,
+ bool useAA,
+ const SkRRect& rrect,
+ const SkStrokeRec& stroke,
+ GrShaderCaps* shaderCaps) {
bool useCoverageAA = useAA && !pipelineBuilder.getRenderTarget()->isUnifiedMultisampled();
// only anti-aliased rrects for now
if (!useCoverageAA) {
- return false;
+ return nullptr;
}
- if (!viewMatrix.rectStaysRect() || !rrect.isSimple()) {
- return false;
+ if (rrect.isOval()) {
+ return CreateOvalBatch(pipelineBuilder, color, viewMatrix, useAA,
+ rrect.getBounds(), stroke, shaderCaps);
}
- SkAutoTUnref<GrDrawBatch> batch(create_rrect_batch(color, viewMatrix, rrect, stroke));
- if (!batch) {
- return false;
+ if (!viewMatrix.rectStaysRect() || !rrect.isSimple()) {
+ return nullptr;
}
- target->drawBatch(pipelineBuilder, batch);
- return true;
+ return create_rrect_batch(color, viewMatrix, rrect, stroke);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -2034,27 +1923,22 @@ bool GrOvalRenderer::DrawRRect(GrDrawTarget* target,
DRAW_BATCH_TEST_DEFINE(CircleBatch) {
SkMatrix viewMatrix = GrTest::TestMatrix(random);
GrColor color = GrRandomColor(random);
- bool useCoverageAA = random->nextBool();
SkRect circle = GrTest::TestSquare(random);
- return create_circle_batch(color, viewMatrix, useCoverageAA, circle,
- GrTest::TestStrokeRec(random));
+ return create_circle_batch(color, viewMatrix, circle, GrTest::TestStrokeRec(random));
}
DRAW_BATCH_TEST_DEFINE(EllipseBatch) {
SkMatrix viewMatrix = GrTest::TestMatrixRectStaysRect(random);
GrColor color = GrRandomColor(random);
SkRect ellipse = GrTest::TestSquare(random);
- return create_ellipse_batch(color, viewMatrix, true, ellipse,
- GrTest::TestStrokeRec(random));
+ return create_ellipse_batch(color, viewMatrix, ellipse, GrTest::TestStrokeRec(random));
}
DRAW_BATCH_TEST_DEFINE(DIEllipseBatch) {
SkMatrix viewMatrix = GrTest::TestMatrix(random);
GrColor color = GrRandomColor(random);
- bool useCoverageAA = random->nextBool();
SkRect ellipse = GrTest::TestSquare(random);
- return create_diellipse_batch(color, viewMatrix, useCoverageAA, ellipse,
- GrTest::TestStrokeRec(random));
+ return create_diellipse_batch(color, viewMatrix, ellipse, GrTest::TestStrokeRec(random));
}
DRAW_BATCH_TEST_DEFINE(RRectBatch) {
diff --git a/src/gpu/GrOvalRenderer.h b/src/gpu/GrOvalRenderer.h
index d591ffeed3..d34398006f 100644
--- a/src/gpu/GrOvalRenderer.h
+++ b/src/gpu/GrOvalRenderer.h
@@ -10,8 +10,9 @@
#include "GrPaint.h"
-class GrDrawTarget;
+class GrDrawBatch;
class GrPipelineBuilder;
+class GrShaderCaps;
struct SkRect;
class SkStrokeRec;
@@ -20,52 +21,36 @@ class SkStrokeRec;
*/
class GrOvalRenderer {
public:
- static bool DrawOval(GrDrawTarget*,
- const GrPipelineBuilder&,
- GrColor,
- const SkMatrix& viewMatrix,
- bool useAA,
- const SkRect& oval,
- const SkStrokeRec& stroke);
- static bool DrawRRect(GrDrawTarget*,
- const GrPipelineBuilder&,
- GrColor,
- const SkMatrix& viewMatrix,
- bool useAA,
- const SkRRect& rrect,
- const SkStrokeRec& stroke);
- static bool DrawDRRect(GrDrawTarget* target,
- const GrPipelineBuilder&,
- GrColor,
- const SkMatrix& viewMatrix,
- bool useAA,
- const SkRRect& outer,
- const SkRRect& inner);
+ static GrDrawBatch* CreateOvalBatch(const GrPipelineBuilder&,
+ GrColor,
+ const SkMatrix& viewMatrix,
+ bool useAA,
+ const SkRect& oval,
+ const SkStrokeRec& stroke,
+ GrShaderCaps* shaderCaps);
+ static GrDrawBatch* CreateRRectBatch(const GrPipelineBuilder&,
+ GrColor,
+ const SkMatrix& viewMatrix,
+ bool useAA,
+ const SkRRect& rrect,
+ const SkStrokeRec& stroke,
+ GrShaderCaps* shaderCaps);
private:
GrOvalRenderer();
- static bool DrawEllipse(GrDrawTarget* target,
- const GrPipelineBuilder&,
- GrColor,
- const SkMatrix& viewMatrix,
- bool useCoverageAA,
- const SkRect& ellipse,
- const SkStrokeRec& stroke);
- static bool DrawDIEllipse(GrDrawTarget* target,
- const GrPipelineBuilder&,
- GrColor,
- const SkMatrix& viewMatrix,
- bool useCoverageAA,
- const SkRect& ellipse,
- const SkStrokeRec& stroke);
- static void DrawCircle(GrDrawTarget* target,
- const GrPipelineBuilder&,
- GrColor,
- const SkMatrix& viewMatrix,
- bool useCoverageAA,
- const SkRect& circle,
- const SkStrokeRec& stroke);
+ static GrDrawBatch* CreateEllipseBatch(GrColor,
+ const SkMatrix& viewMatrix,
+ const SkRect& ellipse,
+ const SkStrokeRec& stroke);
+ static GrDrawBatch* CreateDIEllipseBatch(GrColor,
+ const SkMatrix& viewMatrix,
+ const SkRect& ellipse,
+ const SkStrokeRec& stroke);
+ static GrDrawBatch* CreateCircleBatch(GrColor,
+ const SkMatrix& viewMatrix,
+ const SkRect& circle,
+ const SkStrokeRec& stroke);
};
#endif // GrOvalRenderer_DEFINED
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-03 03:17:31 +0000