GrOvalOpFactory Class Reference

#include <GrOvalOpFactory.h>

Static Public Member Functions
static GrOp::Owner	MakeCircleOp (GrRecordingContext *, GrPaint &&, const SkMatrix &, const SkRect &oval, const GrStyle &style, const GrShaderCaps *)
static GrOp::Owner	MakeOvalOp (GrRecordingContext *, GrPaint &&, const SkMatrix &, const SkRect &oval, const GrStyle &style, const GrShaderCaps *)
static GrOp::Owner	MakeCircularRRectOp (GrRecordingContext *, GrPaint &&, const SkMatrix &, const SkRRect &, const SkStrokeRec &, const GrShaderCaps *)
static GrOp::Owner	MakeRRectOp (GrRecordingContext *, GrPaint &&, const SkMatrix &, const SkRRect &, const SkStrokeRec &, const GrShaderCaps *)
static GrOp::Owner	MakeArcOp (GrRecordingContext *, GrPaint &&, const SkMatrix &, const SkRect &oval, SkScalar startAngle, SkScalar sweepAngle, bool useCenter, const GrStyle &, const GrShaderCaps *)

Detailed Description

Definition at line 30 of file GrOvalOpFactory.h.

Member Function Documentation

MakeArcOp()

GrOp::Owner GrOvalOpFactory::MakeArcOp ( GrRecordingContext *  context, GrPaint &&  paint, const SkMatrix &  viewMatrix, const SkRect &  oval, SkScalar  startAngle, SkScalar  sweepAngle, bool  useCenter, const GrStyle &  style, const GrShaderCaps *  shaderCaps  )

static

Definition at line 3389 of file GrOvalOpFactory.cpp.

                                                                       {
    SkASSERT(!oval.isEmpty());
    SkASSERT(sweepAngle);
    SkScalar width = oval.width();
    if (SkScalarAbs(sweepAngle) >= 360.f) {
        return nullptr;
    }
    if (!SkScalarNearlyEqual(width, oval.height()) || !circle_stays_circle(viewMatrix)) {
        return nullptr;
    }
    SkPoint center = {oval.centerX(), oval.centerY()};
    CircleOp::ArcParams arcParams = {SkDegreesToRadians(startAngle), SkDegreesToRadians(sweepAngle),
                                     useCenter};
    return CircleOp::Make(context, std::move(paint), viewMatrix,
                          center, width / 2.f, style, &arcParams);
}

MakeCircleOp()

GrOp::Owner GrOvalOpFactory::MakeCircleOp ( GrRecordingContext *  context, GrPaint &&  paint, const SkMatrix &  viewMatrix, const SkRect &  oval, const GrStyle &  style, const GrShaderCaps *  shaderCaps  )

static

Definition at line 3314 of file GrOvalOpFactory.cpp.

                                                                          {
    SkScalar width = oval.width();
    SkASSERT(width > SK_ScalarNearlyZero && SkScalarNearlyEqual(width, oval.height()) &&
             circle_stays_circle(viewMatrix));
 
    auto r = width / 2.f;
    SkPoint center = { oval.centerX(), oval.centerY() };
    if (style.hasNonDashPathEffect()) {
        return nullptr;
    } else if (style.isDashed()) {
        if (style.strokeRec().getCap() != SkPaint::kButt_Cap ||
            style.dashIntervalCnt() != 2 || style.strokeRec().getWidth() >= width) {
            return nullptr;
        }
        auto onInterval = style.dashIntervals()[0];
        auto offInterval = style.dashIntervals()[1];
        if (offInterval == 0) {
            GrStyle strokeStyle(style.strokeRec(), nullptr);
            return MakeOvalOp(context, std::move(paint), viewMatrix, oval,
                              strokeStyle, shaderCaps);
        } else if (onInterval == 0) {
            // There is nothing to draw but we have no way to indicate that here.
            return nullptr;
        }
        auto angularOnInterval = onInterval / r;
        auto angularOffInterval = offInterval / r;
        auto phaseAngle = style.dashPhase() / r;
        // Currently this function doesn't accept ovals with different start angles, though
        // it could.
        static const SkScalar kStartAngle = 0.f;
        return ButtCapDashedCircleOp::Make(context, std::move(paint), viewMatrix, center, r,
                                           style.strokeRec().getWidth(), kStartAngle,
                                           angularOnInterval, angularOffInterval, phaseAngle);
    }
    return CircleOp::Make(context, std::move(paint), viewMatrix, center, r, style);
}

MakeCircularRRectOp()

GrOp::Owner GrOvalOpFactory::MakeCircularRRectOp ( GrRecordingContext *  context, GrPaint &&  paint, const SkMatrix &  viewMatrix, const SkRRect &  rrect, const SkStrokeRec &  stroke, const GrShaderCaps *  shaderCaps  )

static

Definition at line 3173 of file GrOvalOpFactory.cpp.

                                                                                 {
    SkASSERT(viewMatrix.rectStaysRect());
    SkASSERT(viewMatrix.isSimilarity());
    SkASSERT(rrect.isSimple());
    SkASSERT(!rrect.isOval());
    SkASSERT(SkRRectPriv::GetSimpleRadii(rrect).fX == SkRRectPriv::GetSimpleRadii(rrect).fY);
 
    // RRect ops only handle simple, but not too simple, rrects.
    // Do any matrix crunching before we reset the draw state for device coords.
    const SkRect& rrectBounds = rrect.getBounds();
    SkRect bounds;
    viewMatrix.mapRect(&bounds, rrectBounds);
 
    SkScalar radius = SkRRectPriv::GetSimpleRadii(rrect).fX;
    SkScalar scaledRadius = SkScalarAbs(radius * (viewMatrix[SkMatrix::kMScaleX] +
                                                  viewMatrix[SkMatrix::kMSkewY]));
 
    // Do mapping of stroke. Use -1 to indicate fill-only draws.
    SkScalar scaledStroke = -1;
    SkScalar strokeWidth = stroke.getWidth();
    SkStrokeRec::Style style = stroke.getStyle();
 
    bool isStrokeOnly =
        SkStrokeRec::kStroke_Style == style || SkStrokeRec::kHairline_Style == style;
    bool hasStroke = isStrokeOnly || SkStrokeRec::kStrokeAndFill_Style == style;
 
    if (hasStroke) {
        if (SkStrokeRec::kHairline_Style == style) {
            scaledStroke = SK_Scalar1;
        } else {
            scaledStroke = SkScalarAbs(strokeWidth * (viewMatrix[SkMatrix::kMScaleX] +
                                                      viewMatrix[SkMatrix::kMSkewY]));
        }
    }
 
    // The way the effect interpolates the offset-to-ellipse/circle-center attribute only works on
    // the interior of the rrect if the radii are >= 0.5. Otherwise, the inner rect of the nine-
    // patch will have fractional coverage. This only matters when the interior is actually filled.
    // We could consider falling back to rect rendering here, since a tiny radius is
    // indistinguishable from a square corner.
    if (!isStrokeOnly && SK_ScalarHalf > scaledRadius) {
        return nullptr;
    }
 
    return CircularRRectOp::Make(context, std::move(paint), viewMatrix, bounds, scaledRadius,
                                 scaledStroke, isStrokeOnly);
}

MakeOvalOp()

GrOp::Owner GrOvalOpFactory::MakeOvalOp ( GrRecordingContext *  context, GrPaint &&  paint, const SkMatrix &  viewMatrix, const SkRect &  oval, const GrStyle &  style, const GrShaderCaps *  shaderCaps  )

static

Definition at line 3356 of file GrOvalOpFactory.cpp.

                                                                        {
    if (style.pathEffect()) {
        return nullptr;
    }
 
    // prefer the device space ellipse op for batchability
    if (viewMatrix.rectStaysRect()) {
        return EllipseOp::Make(context, std::move(paint), viewMatrix, oval, style.strokeRec());
    }
 
    // Otherwise, if we have shader derivative support, render as device-independent
    if (shaderCaps->fShaderDerivativeSupport) {
        SkScalar a = viewMatrix[SkMatrix::kMScaleX];
        SkScalar b = viewMatrix[SkMatrix::kMSkewX];
        SkScalar c = viewMatrix[SkMatrix::kMSkewY];
        SkScalar d = viewMatrix[SkMatrix::kMScaleY];
        // Check for near-degenerate matrix
        if (a*a + c*c > SK_ScalarNearlyZero && b*b + d*d > SK_ScalarNearlyZero) {
            return DIEllipseOp::Make(context, std::move(paint), viewMatrix, oval,
                                     style.strokeRec());
        }
    }
 
    return nullptr;
}

MakeRRectOp()

GrOp::Owner GrOvalOpFactory::MakeRRectOp ( GrRecordingContext *  context, GrPaint &&  paint, const SkMatrix &  viewMatrix, const SkRRect &  rrect, const SkStrokeRec &  stroke, const GrShaderCaps *  shaderCaps  )

static

Definition at line 3294 of file GrOvalOpFactory.cpp.

                                                                         {
    if (rrect.isOval()) {
        return MakeOvalOp(context, std::move(paint), viewMatrix, rrect.getBounds(),
                          GrStyle(stroke, nullptr), shaderCaps);
    }
 
    if (!viewMatrix.rectStaysRect() || !rrect.isSimple()) {
        return nullptr;
    }
 
    return make_rrect_op(context, std::move(paint), viewMatrix, rrect, stroke);
}

---

The documentation for this class was generated from the following files:

• third_party/skia/src/gpu/ganesh/ops/GrOvalOpFactory.h
• third_party/skia/src/gpu/ganesh/ops/GrOvalOpFactory.cpp