skgpu::ganesh::StencilMaskHelper Class Reference

#include <StencilMaskHelper.h>

Inheritance diagram for skgpu::ganesh::StencilMaskHelper:

Public Member Functions
	StencilMaskHelper (GrRecordingContext *, SurfaceDrawContext *)
bool	init (const SkIRect &maskBounds, uint32_t genID, const GrWindowRectangles &windowRects, int numFPs)
void	drawRect (const SkRect &rect, const SkMatrix &matrix, SkRegion::Op, GrAA)
bool	drawPath (const SkPath &path, const SkMatrix &matrix, SkRegion::Op, GrAA)
bool	drawShape (const GrShape &shape, const SkMatrix &matrix, SkRegion::Op, GrAA)
void	clear (bool insideStencil)
void	finish ()

Detailed Description

The StencilMaskHelper helps generate clip masks using the stencil buffer. It is intended to be used as:

StencilMaskHelper helper; helper.init(...);

draw one or more paths/rects specifying the required boolean ops

helper.finish();

The result of this process will be the mask stored in the clip bits of the stencil buffer.

Definition at line 37 of file StencilMaskHelper.h.

Constructor & Destructor Documentation

StencilMaskHelper()

skgpu::ganesh::StencilMaskHelper::StencilMaskHelper	(	GrRecordingContext *	rContext,
		SurfaceDrawContext *	sdc
	)

Definition at line 346 of file StencilMaskHelper.cpp.

        : fContext(rContext)
        , fSDC(sdc)
        , fClip(sdc->dimensions()) {
}

Member Function Documentation

clear()

void skgpu::ganesh::StencilMaskHelper::clear

(

bool

insideStencil

)

Definition at line 488 of file StencilMaskHelper.cpp.

                                                {
    if (fClip.fixedClip().hasWindowRectangles()) {
        // Use a draw to benefit from window rectangles when resetting the stencil buffer; for
        // large buffers with MSAA this can be significant.
        draw_stencil_rect(fSDC, fClip.fixedClip(),
                          GrStencilSettings::SetClipBitSettings(insideStencil), SkMatrix::I(),
                          SkRect::Make(fClip.fixedClip().scissorRect()), GrAA::kNo);
    } else {
        fSDC->clearStencilClip(fClip.fixedClip().scissorRect(), insideStencil);
    }
}

drawPath()

bool skgpu::ganesh::StencilMaskHelper::drawPath	(	const SkPath &	path,
		const SkMatrix &	matrix,
		SkRegion::Op	op,
		GrAA	aa
	)

Definition at line 400 of file StencilMaskHelper.cpp.

                                          {
    if (path.isEmpty()) {
        return true;
    }
 
    // drawPath follows a similar approach to drawRect(), where we either draw directly to the clip
    // bit or first draw to client bits and then apply a cover pass. The complicating factor is that
    // we rely on path rendering and how the chosen path renderer uses the stencil buffer.
    aa = supported_aa(fSDC, aa);
 
    GrAAType pathAAType = aa == GrAA::kYes ? GrAAType::kMSAA : GrAAType::kNone;
 
    // This will be used to determine whether the clip shape can be rendered into the
    // stencil with arbitrary stencil settings.
    PathRenderer::StencilSupport stencilSupport;
 
    // Make path canonical with regards to fill type (inverse handled by stencil settings).
    bool fillInverted = path.isInverseFillType();
    SkTCopyOnFirstWrite<SkPath> clipPath(path);
    if (fillInverted) {
        clipPath.writable()->toggleInverseFillType();
    }
 
    GrStyledShape shape(*clipPath, GrStyle::SimpleFill());
    SkASSERT(!shape.inverseFilled());
 
    PathRenderer::CanDrawPathArgs canDrawArgs;
    canDrawArgs.fCaps = fContext->priv().caps();
    canDrawArgs.fProxy = fSDC->asRenderTargetProxy();
    canDrawArgs.fClipConservativeBounds = &fClip.fixedClip().scissorRect();
    canDrawArgs.fViewMatrix = &matrix;
    canDrawArgs.fShape = &shape;
    canDrawArgs.fPaint = nullptr;
    canDrawArgs.fSurfaceProps = &fSDC->surfaceProps();
    canDrawArgs.fAAType = pathAAType;
    canDrawArgs.fHasUserStencilSettings = false;
 
    auto pr =  fContext->priv().drawingManager()->getPathRenderer(
            canDrawArgs, false, PathRendererChain::DrawType::kStencil, &stencilSupport);
    if (!pr) {
        return false;
    }
 
    bool drawDirectToClip;
    auto passes = get_stencil_passes(op, stencilSupport, fillInverted, &drawDirectToClip);
 
    // Write to client bits if necessary
    if (!drawDirectToClip) {
        if (stencilSupport == PathRenderer::kNoRestriction_StencilSupport) {
            draw_path(fContext, fSDC, pr, fClip.fixedClip(), fClip.fixedClip().scissorRect(),
                      &gDrawToStencil, matrix, shape, aa);
        } else {
            stencil_path(fContext, fSDC, pr, fClip.fixedClip(), matrix, shape, aa);
        }
    }
 
    // Now modify the clip bit (either by rendering directly), or by covering the bounding box
    // of the clip
    for (GrUserStencilSettings const* const* pass = passes; *pass; ++pass) {
        if (drawDirectToClip) {
            draw_path(fContext, fSDC, pr, fClip, fClip.fixedClip().scissorRect(),
                      *pass, matrix, shape, aa);
        } else {
            draw_stencil_rect(fSDC, fClip, *pass, SkMatrix::I(),
                              SkRect::Make(fClip.fixedClip().scissorRect()), aa);
        }
    }
 
    return true;
}

drawRect()

void skgpu::ganesh::StencilMaskHelper::drawRect	(	const SkRect &	rect,
		const SkMatrix &	matrix,
		SkRegion::Op	op,
		GrAA	aa
	)

Definition at line 370 of file StencilMaskHelper.cpp.

                                          {
    if (rect.isEmpty()) {
        return;
    }
 
    bool drawDirectToClip;
    auto passes = get_stencil_passes(op, PathRenderer::kNoRestriction_StencilSupport,
                                     false, &drawDirectToClip);
    aa = supported_aa(fSDC, aa);
 
    if (!drawDirectToClip) {
        // Draw to client stencil bits first
        draw_stencil_rect(fSDC, fClip.fixedClip(), &gDrawToStencil, matrix, rect, aa);
    }
 
    // Now modify the clip bit (either by rendering directly), or by covering the bounding box
    // of the clip
    for (GrUserStencilSettings const* const* pass = passes; *pass; ++pass) {
        if (drawDirectToClip) {
            draw_stencil_rect(fSDC, fClip, *pass, matrix, rect, aa);
        } else {
            draw_stencil_rect(fSDC, fClip, *pass, SkMatrix::I(),
                              SkRect::Make(fClip.fixedClip().scissorRect()), aa);
        }
    }
}

drawShape()

bool skgpu::ganesh::StencilMaskHelper::drawShape	(	const GrShape &	shape,
		const SkMatrix &	matrix,
		SkRegion::Op	op,
		GrAA	aa
	)

Definition at line 474 of file StencilMaskHelper.cpp.

                                           {
    if (shape.isRect() && !shape.inverted()) {
        this->drawRect(shape.rect(), matrix, op, aa);
        return true;
    } else {
        SkPath p;
        shape.asPath(&p);
        return this->drawPath(p, matrix, op, aa);
    }
}

finish()

void skgpu::ganesh::StencilMaskHelper::finish

(

)

Definition at line 500 of file StencilMaskHelper.cpp.

                               {
    fSDC->setLastClip(fClip.stencilStackID(), fClip.fixedClip().scissorRect(), fNumFPs);
}

init()

bool skgpu::ganesh::StencilMaskHelper::init	(	const SkIRect &	maskBounds,
		uint32_t	genID,
		const GrWindowRectangles &	windowRects,
		int	numFPs
	)

Definition at line 353 of file StencilMaskHelper.cpp.

                                                                                {
    if (!fSDC->mustRenderClip(genID, bounds, numFPs)) {
        return false;
    }
 
    fClip.setStencilClip(genID);
    // Should have caught bounds not intersecting the render target much earlier in clip application
    SkAssertResult(fClip.fixedClip().setScissor(bounds));
    if (!windowRects.empty()) {
        fClip.fixedClip().setWindowRectangles(
                windowRects, GrWindowRectsState::Mode::kExclusive);
    }
    fNumFPs = numFPs;
    return true;
}

---

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

• third_party/skia/src/gpu/ganesh/StencilMaskHelper.h
• third_party/skia/src/gpu/ganesh/StencilMaskHelper.cpp