skgpu::ganesh::DashOp Namespace Reference

Enumerations
enum class	AAMode { kNone , kCoverage , kCoverageWithMSAA }

Functions
GrOp::Owner	MakeDashLineOp (GrRecordingContext *context, GrPaint &&paint, const SkMatrix &viewMatrix, const SkPoint pts[2], AAMode aaMode, const GrStyle &style, const GrUserStencilSettings *stencilSettings)
bool	CanDrawDashLine (const SkPoint pts[2], const GrStyle &style, const SkMatrix &viewMatrix)

Enumeration Type Documentation

AAMode

enum class skgpu::ganesh::DashOp::AAMode

strong

Enumerator
kNone
kCoverage
kCoverageWithMSAA

Definition at line 21 of file DashOp.h.

                  {
    kNone,
    kCoverage,
    kCoverageWithMSAA,
};

Function Documentation

CanDrawDashLine()

bool skgpu::ganesh::DashOp::CanDrawDashLine	(	const SkPoint	pts[2],
		const GrStyle &	style,
		const SkMatrix &	viewMatrix
	)

Definition at line 1190 of file DashOp.cpp.

                                                                                             {
    // Pts must be either horizontal or vertical in src space
    if (pts[0].fX != pts[1].fX && pts[0].fY != pts[1].fY) {
        return false;
    }
 
    // May be able to relax this to include skew. As of now cannot do perspective
    // because of the non uniform scaling of bloating a rect
    if (!viewMatrix.preservesRightAngles()) {
        return false;
    }
 
    if (!style.isDashed() || 2 != style.dashIntervalCnt()) {
        return false;
    }
 
    const SkScalar* intervals = style.dashIntervals();
    if (0 == intervals[0] && 0 == intervals[1]) {
        return false;
    }
 
    SkPaint::Cap cap = style.strokeRec().getCap();
    if (SkPaint::kRound_Cap == cap) {
        // Current we don't support round caps unless the on interval is zero
        if (intervals[0] != 0.f) {
            return false;
        }
        // If the width of the circle caps in greater than the off interval we will pick up unwanted
        // segments of circles at the start and end of the dash line.
        if (style.strokeRec().getWidth() > intervals[1]) {
            return false;
        }
    }
 
    return true;
}

MakeDashLineOp()

GrOp::Owner skgpu::ganesh::DashOp::MakeDashLineOp	(	GrRecordingContext *	context,
		GrPaint &&	paint,
		const SkMatrix &	viewMatrix,
		const SkPoint	pts[2],
		AAMode	aaMode,
		const GrStyle &	style,
		const GrUserStencilSettings *	stencilSettings
	)

Definition at line 1130 of file DashOp.cpp.

                                                                         {
    SkASSERT(CanDrawDashLine(pts, style, viewMatrix));
    const SkScalar* intervals = style.dashIntervals();
    SkScalar phase = style.dashPhase();
 
    SkPaint::Cap cap = style.strokeRec().getCap();
 
    DashOpImpl::LineData lineData;
    lineData.fSrcStrokeWidth = style.strokeRec().getWidth();
 
    // the phase should be normalized to be [0, sum of all intervals)
    SkASSERT(phase >= 0 && phase < intervals[0] + intervals[1]);
 
    // Rotate the src pts so they are aligned horizontally with pts[0].fX < pts[1].fX
    if (pts[0].fY != pts[1].fY || pts[0].fX > pts[1].fX) {
        SkMatrix rotMatrix;
        align_to_x_axis(pts, &rotMatrix, lineData.fPtsRot);
        if (!rotMatrix.invert(&lineData.fSrcRotInv)) {
            SkDebugf("Failed to create invertible rotation matrix!\n");
            return nullptr;
        }
    } else {
        lineData.fSrcRotInv.reset();
        memcpy(lineData.fPtsRot, pts, 2 * sizeof(SkPoint));
    }
 
    // Scale corrections of intervals and stroke from view matrix
    calc_dash_scaling(&lineData.fParallelScale, &lineData.fPerpendicularScale, viewMatrix, pts);
    if (SkScalarNearlyZero(lineData.fParallelScale) ||
        SkScalarNearlyZero(lineData.fPerpendicularScale)) {
        return nullptr;
    }
 
    SkScalar offInterval = intervals[1] * lineData.fParallelScale;
    SkScalar strokeWidth = lineData.fSrcStrokeWidth * lineData.fPerpendicularScale;
 
    if (SkPaint::kSquare_Cap == cap && 0 != lineData.fSrcStrokeWidth) {
        // add cap to on interval and remove from off interval
        offInterval -= strokeWidth;
    }
 
    // TODO we can do a real rect call if not using fulldash(ie no off interval, not using AA)
    bool fullDash = offInterval > 0.f || aaMode != AAMode::kNone;
 
    lineData.fViewMatrix = viewMatrix;
    lineData.fPhase = phase;
    lineData.fIntervals[0] = intervals[0];
    lineData.fIntervals[1] = intervals[1];
 
    return DashOpImpl::Make(context, std::move(paint), lineData, cap, aaMode, fullDash,
                            stencilSettings);
}