#include <SurfaceDrawContext.h>

Inheritance diagram for skgpu::ganesh::SurfaceDrawContext:

Public Types
enum class	QuadOptimization { kDiscarded , kSubmitted , kClipApplied , kCropped }

using	WillAddOpFn = void(GrOp *, uint32_t opsTaskID)

Public Types inherited from skgpu::ganesh::SurfaceContext
using	ReadPixelsCallback = SkImage::ReadPixelsCallback

using	ReadPixelsContext = SkImage::ReadPixelsContext

using	RescaleGamma = SkImage::RescaleGamma

using	RescaleMode = SkImage::RescaleMode

Public Member Functions
	SurfaceDrawContext (GrRecordingContext *, GrSurfaceProxyView readView, GrSurfaceProxyView writeView, GrColorType, sk_sp< SkColorSpace >, const SkSurfaceProps &)

	~SurfaceDrawContext () override

void	drawPaint (const GrClip *, GrPaint &&, const SkMatrix &viewMatrix)

void	drawRect (const GrClip , GrPaint &&paint, GrAA, const SkMatrix &viewMatrix, const SkRect &, const GrStyle style=nullptr)

void	fillRectToRect (const GrClip *, GrPaint &&, GrAA, const SkMatrix &, const SkRect &rectToDraw, const SkRect &localRect)

void	fillPixelsWithLocalMatrix (const GrClip *clip, GrPaint &&paint, const SkIRect &bounds, const SkMatrix &localMatrix)

void	fillRectWithEdgeAA (const GrClip clip, GrPaint &&paint, GrQuadAAFlags edgeAA, const SkMatrix &viewMatrix, const SkRect &rect, const SkRect optionalLocalRect=nullptr)

void	fillQuadWithEdgeAA (const GrClip *clip, GrPaint &&paint, GrQuadAAFlags edgeAA, const SkMatrix &viewMatrix, const SkPoint points[4], const SkPoint optionalLocalPoints[4])

void	drawQuadSet (const GrClip *clip, GrPaint &&paint, const SkMatrix &viewMatrix, const GrQuadSetEntry[], int cnt)

void	drawTexture (const GrClip *, GrSurfaceProxyView, SkAlphaType, GrSamplerState::Filter, GrSamplerState::MipmapMode, SkBlendMode, const SkPMColor4f &, const SkRect &srcRect, const SkRect &dstRect, GrQuadAAFlags, SkCanvas::SrcRectConstraint, const SkMatrix &, sk_sp< GrColorSpaceXform >)

void	drawTextureQuad (const GrClip clip, GrSurfaceProxyView view, GrColorType srcColorType, SkAlphaType srcAlphaType, GrSamplerState::Filter filter, GrSamplerState::MipmapMode mm, SkBlendMode mode, const SkPMColor4f &color, const SkPoint srcQuad[4], const SkPoint dstQuad[4], GrQuadAAFlags edgeAA, const SkRect subset, const SkMatrix &viewMatrix, sk_sp< GrColorSpaceXform > texXform)

void	drawTextureSet (const GrClip *, GrTextureSetEntry[], int cnt, int proxyRunCnt, GrSamplerState::Filter, GrSamplerState::MipmapMode, SkBlendMode mode, SkCanvas::SrcRectConstraint, const SkMatrix &viewMatrix, sk_sp< GrColorSpaceXform > texXform)

void	drawRRect (const GrClip *, GrPaint &&, GrAA, const SkMatrix &viewMatrix, const SkRRect &rrect, const GrStyle &style)

bool	drawFastShadow (const GrClip *, const SkMatrix &viewMatrix, const SkPath &path, const SkDrawShadowRec &rec)

void	drawPath (const GrClip *, GrPaint &&, GrAA, const SkMatrix &viewMatrix, const SkPath &, const GrStyle &)

void	drawShape (const GrClip *, GrPaint &&, GrAA, const SkMatrix &viewMatrix, GrStyledShape &&)

void	drawVertices (const GrClip , GrPaint &&paint, const SkMatrix &viewMatrix, sk_sp< SkVertices > vertices, GrPrimitiveType overridePrimType=nullptr, bool skipColorXform=false)

void	drawMesh (const GrClip *, GrPaint &&paint, const SkMatrix &viewMatrix, const SkMesh &mesh, skia_private::TArray< std::unique_ptr< GrFragmentProcessor > > children)

void	drawAtlas (const GrClip *, GrPaint &&paint, const SkMatrix &viewMatrix, int spriteCount, const SkRSXform xform[], const SkRect texRect[], const SkColor colors[])

void	drawRegion (const GrClip , GrPaint &&paint, GrAA aa, const SkMatrix &viewMatrix, const SkRegion &region, const GrStyle &style, const GrUserStencilSettings ss=nullptr)

void	drawOval (const GrClip *, GrPaint &&paint, GrAA, const SkMatrix &viewMatrix, const SkRect &oval, const GrStyle &style)

void	drawArc (const GrClip *, GrPaint &&paint, GrAA, const SkMatrix &viewMatrix, const SkRect &oval, SkScalar startAngle, SkScalar sweepAngle, bool useCenter, const GrStyle &style)

void	drawImageLattice (const GrClip *, GrPaint &&, const SkMatrix &viewMatrix, GrSurfaceProxyView, SkAlphaType alphaType, sk_sp< GrColorSpaceXform >, GrSamplerState::Filter, std::unique_ptr< SkLatticeIter >, const SkRect &dst)

void	drawGlyphRunList (SkCanvas , const GrClip , const SkMatrix &viewMatrix, const sktext::GlyphRunList &glyphRunList, SkStrikeDeviceInfo strikeDeviceInfo, const SkPaint &paint)

void	drawDrawable (std::unique_ptr< SkDrawable::GpuDrawHandler >, const SkRect &bounds)

void	setLastClip (uint32_t clipStackGenID, const SkIRect &devClipBounds, int numClipAnalyticElements)

bool	mustRenderClip (uint32_t clipStackGenID, const SkIRect &devClipBounds, int numClipAnalyticElements)

void	clearStencilClip (const SkIRect &scissor, bool insideStencilMask)

void	stencilRect (const GrClip clip, const GrUserStencilSettings ss, GrPaint &&paint, GrAA doStencilMSAA, const SkMatrix &viewMatrix, const SkRect &rect, const SkMatrix *localMatrix=nullptr)

bool	stencilPath (const GrHardClip *, GrAA doStencilMSAA, const SkMatrix &viewMatrix, const SkPath &)

bool	drawAndStencilPath (const GrHardClip , const GrUserStencilSettings , SkRegion::Op op, bool invert, GrAA doStencilMSAA, const SkMatrix &viewMatrix, const SkPath &)

skgpu::Budgeted	isBudgeted () const

int	maxWindowRectangles () const

GrSurfaceProxy::UniqueID	uniqueID () const

void	addDrawOp (const GrClip *, GrOp::Owner, const std::function< WillAddOpFn > &=std::function< WillAddOpFn >())

void	addDrawOp (GrOp::Owner op)

bool	refsWrappedObjects () const

bool	waitOnSemaphores (int numSemaphores, const GrBackendSemaphore waitSemaphores[], bool deleteSemaphoresAfterWait)

int	numSamples () const

const SkSurfaceProps &	surfaceProps () const

bool	canUseDynamicMSAA () const

bool	wrapsVkSecondaryCB () const

bool	alwaysAntialias () const

GrAA	chooseAA (const SkPaint &paint)

GrAAType	chooseAAType (GrAA aa)

GrRenderTarget *	accessRenderTarget ()

void	drawStrokedLine (const GrClip *, GrPaint &&, GrAA, const SkMatrix &, const SkPoint[2], const SkStrokeRec &)

Public Member Functions inherited from skgpu::ganesh::SurfaceFillContext
	SurfaceFillContext (GrRecordingContext *rContext, GrSurfaceProxyView readView, GrSurfaceProxyView writeView, const GrColorInfo &colorInfo)

SurfaceFillContext *	asFillContext () override

OpsTask *	getOpsTask ()

void	discard ()

void	resolveMSAA ()

template<SkAlphaType AlphaType>
void	clear (const SkIRect &rect, const SkRGBA4f< AlphaType > &color)

template<SkAlphaType AlphaType>
void	clear (const SkRGBA4f< AlphaType > &color)

template<SkAlphaType AlphaType>
void	clearAtLeast (const SkIRect &scissor, const SkRGBA4f< AlphaType > &color)

void	fillRectWithFP (const SkIRect &dstRect, std::unique_ptr< GrFragmentProcessor >)

void	fillRectWithFP (const SkIRect &dstRect, const SkMatrix &localMatrix, std::unique_ptr< GrFragmentProcessor >)

void	fillRectToRectWithFP (const SkRect &srcRect, const SkIRect &dstRect, std::unique_ptr< GrFragmentProcessor > fp)

void	fillRectToRectWithFP (const SkIRect &srcRect, const SkIRect &dstRect, std::unique_ptr< GrFragmentProcessor > fp)

void	fillWithFP (std::unique_ptr< GrFragmentProcessor > fp)

bool	blitTexture (GrSurfaceProxyView, const SkIRect &srcRect, const SkIPoint &dstPoint)

sk_sp< GrRenderTask >	refRenderTask ()

int	numSamples () const

bool	wrapsVkSecondaryCB () const

SkArenaAlloc *	arenaAlloc ()

sktext::gpu::SubRunAllocator *	subRunAlloc ()

const GrSurfaceProxyView &	writeSurfaceView () const

Public Member Functions inherited from skgpu::ganesh::SurfaceContext
	SurfaceContext (GrRecordingContext *, GrSurfaceProxyView readView, const GrColorInfo &)

virtual	~SurfaceContext ()=default

GrRecordingContext *	recordingContext () const

const GrColorInfo &	colorInfo () const

GrImageInfo	imageInfo () const

GrSurfaceOrigin	origin () const

skgpu::Swizzle	readSwizzle () const

GrSurfaceProxyView	readSurfaceView ()

SkISize	dimensions () const

int	width () const

int	height () const

skgpu::Mipmapped	mipmapped () const

const GrCaps *	caps () const

bool	readPixels (GrDirectContext *dContext, GrPixmap dst, SkIPoint srcPt)

void	asyncRescaleAndReadPixels (GrDirectContext *, const SkImageInfo &info, const SkIRect &srcRect, RescaleGamma rescaleGamma, RescaleMode, ReadPixelsCallback callback, ReadPixelsContext callbackContext)

void	asyncRescaleAndReadPixelsYUV420 (GrDirectContext *, SkYUVColorSpace yuvColorSpace, bool readAlpha, sk_sp< SkColorSpace > dstColorSpace, const SkIRect &srcRect, SkISize dstSize, RescaleGamma rescaleGamma, RescaleMode, ReadPixelsCallback callback, ReadPixelsContext context)

bool	writePixels (GrDirectContext *dContext, GrCPixmap src, SkIPoint dstPt)

bool	writePixels (GrDirectContext *dContext, const GrCPixmap src[], int numLevels)

GrSurfaceProxy *	asSurfaceProxy ()

const GrSurfaceProxy *	asSurfaceProxy () const

sk_sp< GrSurfaceProxy >	asSurfaceProxyRef ()

GrTextureProxy *	asTextureProxy ()

const GrTextureProxy *	asTextureProxy () const

sk_sp< GrTextureProxy >	asTextureProxyRef ()

GrRenderTargetProxy *	asRenderTargetProxy ()

const GrRenderTargetProxy *	asRenderTargetProxy () const

sk_sp< GrRenderTargetProxy >	asRenderTargetProxyRef ()

std::unique_ptr< SurfaceFillContext >	rescale (const GrImageInfo &info, GrSurfaceOrigin, SkIRect srcRect, SkImage::RescaleGamma, SkImage::RescaleMode)

bool	rescaleInto (SurfaceFillContext *dst, SkIRect dstRect, SkIRect srcRect, SkImage::RescaleGamma, SkImage::RescaleMode)

Static Public Member Functions
static std::unique_ptr< SurfaceDrawContext >	Make (GrRecordingContext *, GrColorType, sk_sp< GrSurfaceProxy >, sk_sp< SkColorSpace >, GrSurfaceOrigin, const SkSurfaceProps &)

static std::unique_ptr< SurfaceDrawContext >	Make (GrRecordingContext *, GrColorType, sk_sp< SkColorSpace >, SkBackingFit, SkISize dimensions, const SkSurfaceProps &, std::string_view label, int sampleCnt=1, skgpu::Mipmapped=skgpu::Mipmapped::kNo, skgpu::Protected=skgpu::Protected::kNo, GrSurfaceOrigin=kBottomLeft_GrSurfaceOrigin, skgpu::Budgeted=skgpu::Budgeted::kYes)

static std::unique_ptr< SurfaceDrawContext >	Make (GrRecordingContext *, sk_sp< SkColorSpace >, SkBackingFit, SkISize dimensions, const GrBackendFormat &, int sampleCnt, skgpu::Mipmapped, skgpu::Protected, skgpu::Swizzle readSwizzle, skgpu::Swizzle writeSwizzle, GrSurfaceOrigin, skgpu::Budgeted, const SkSurfaceProps &, std::string_view label)

static std::unique_ptr< SurfaceDrawContext >	MakeWithFallback (GrRecordingContext *, GrColorType, sk_sp< SkColorSpace >, SkBackingFit, SkISize dimensions, const SkSurfaceProps &, int sampleCnt, skgpu::Mipmapped, skgpu::Protected, GrSurfaceOrigin=kBottomLeft_GrSurfaceOrigin, skgpu::Budgeted=skgpu::Budgeted::kYes)

static std::unique_ptr< SurfaceDrawContext >	MakeFromBackendTexture (GrRecordingContext *, GrColorType, sk_sp< SkColorSpace >, const GrBackendTexture &, int sampleCnt, GrSurfaceOrigin, const SkSurfaceProps &, sk_sp< skgpu::RefCntedCallback > releaseHelper)

Private Member Functions
void	willReplaceOpsTask (OpsTask prevTask, OpsTask nextTask) override

OpsTask::CanDiscardPreviousOps	canDiscardPreviousOpsOnFullClear () const override

Additional Inherited Members
Protected Member Functions inherited from skgpu::ganesh::SurfaceFillContext
OpsTask *	replaceOpsTask ()

void	addOp (GrOp::Owner)

template<SkAlphaType AlphaType>
std::array< float, 4 >	adjustColorAlphaType (SkRGBA4f< AlphaType > color) const

Protected Member Functions inherited from skgpu::ganesh::SurfaceContext
GrDrawingManager *	drawingManager ()

const GrDrawingManager *	drawingManager () const

PixelTransferResult	transferPixels (GrColorType colorType, const SkIRect &rect)

void	asyncReadPixels (GrDirectContext *, const SkIRect &srcRect, SkColorType, ReadPixelsCallback, ReadPixelsContext)

Static Protected Member Functions inherited from skgpu::ganesh::SurfaceFillContext
static void	ClearToGrPaint (std::array< float, 4 > color, GrPaint *paint)

template<SkAlphaType AlphaType>
static std::array< float, 4 >	ConvertColor (SkRGBA4f< AlphaType > color)

template<>
std::array< float, 4 >	ConvertColor (SkPMColor4f color)

template<>
std::array< float, 4 >	ConvertColor (SkColor4f color)

Protected Attributes inherited from skgpu::ganesh::SurfaceFillContext
GrSurfaceProxyView	fWriteView

Protected Attributes inherited from skgpu::ganesh::SurfaceContext
SkDEBUGCODE(void validate() const ;) SkDEBUGCODE(skgpu GrRecordingContext *	fContext

GrSurfaceProxyView	fReadView

Detailed Description

A helper object to orchestrate commands (draws, etc...) for GrSurfaces that are GrRenderTargets.

Definition at line 65 of file SurfaceDrawContext.h.

Member Typedef Documentation

◆ WillAddOpFn

using skgpu::ganesh::SurfaceDrawContext::WillAddOpFn = void(GrOp*, uint32_t opsTaskID)

Definition at line 570 of file SurfaceDrawContext.h.

Member Enumeration Documentation

◆ QuadOptimization

enum class skgpu::ganesh::SurfaceDrawContext::QuadOptimization

strong

Enumerator
kDiscarded
kSubmitted
kClipApplied
kCropped

Definition at line 388 of file SurfaceDrawContext.cpp.

                                              {
    // The rect to draw doesn't intersect clip or render target, so no draw op should be added
    kDiscarded,
    // The rect to draw was converted to some other op and appended to the oplist, so no additional
    // op is necessary. Currently this can convert it to a clear op or a rrect op. Only valid if
    // a constColor is provided.
    kSubmitted,
    // The clip was folded into the device quad, with updated edge flags and local coords, and
    // caller is responsible for adding an appropriate op.
    kClipApplied,
    // No change to clip, but quad updated to better fit clip/render target, and caller is
    // responsible for adding an appropriate op.
    kCropped
};

Constructor & Destructor Documentation

◆ SurfaceDrawContext()

skgpu::ganesh::SurfaceDrawContext::SurfaceDrawContext	(	GrRecordingContext *	rContext,
		GrSurfaceProxyView	readView,
		GrSurfaceProxyView	writeView,
		GrColorType	colorType,
		sk_sp< SkColorSpace >	colorSpace,
		const SkSurfaceProps &	surfaceProps
	)

Definition at line 294 of file SurfaceDrawContext.cpp.

        : SurfaceFillContext(rContext,
                             std::move(readView),
                             std::move(writeView),
                             {colorType, kPremul_SkAlphaType, std::move(colorSpace)})
        , fSurfaceProps(surfaceProps)
        , fCanUseDynamicMSAA(
                (fSurfaceProps.flags() & SkSurfaceProps::kDynamicMSAA_Flag) &&
                rContext->priv().caps()->supportsDynamicMSAA(this->asRenderTargetProxy())) {
    SkDEBUGCODE(this->validate();)
}

◆ ~SurfaceDrawContext()

skgpu::ganesh::SurfaceDrawContext::~SurfaceDrawContext ( )

override

Definition at line 311 of file SurfaceDrawContext.cpp.

                                        {
    ASSERT_SINGLE_OWNER
}

Member Function Documentation

◆ accessRenderTarget()

GrRenderTarget * skgpu::ganesh::SurfaceDrawContext::accessRenderTarget ( )

inline

Definition at line 616 of file SurfaceDrawContext.h.

616{ return this->asSurfaceProxy()->peekRenderTarget(); }

GrSurfaceProxy::peekRenderTarget

GrRenderTarget * peekRenderTarget() const

Definition GrSurfaceProxy.h:277

skgpu::ganesh::SurfaceContext::asSurfaceProxy

GrSurfaceProxy * asSurfaceProxy()

Definition SurfaceContext.h:125

◆ addDrawOp() [1/2]

void skgpu::ganesh::SurfaceDrawContext::addDrawOp	(	const GrClip *	clip,
		GrOp::Owner	op,
		const std::function< WillAddOpFn > &	willAddFn = `std::function<WillAddOpFn>()`
	)

Definition at line 1922 of file SurfaceDrawContext.cpp.

                                                                              {
    ASSERT_SINGLE_OWNER
    if (fContext->abandoned()) {
        return;
    }
    GrDrawOp* drawOp = (GrDrawOp*)op.get();
    SkDEBUGCODE(this->validate();)
    SkDEBUGCODE(drawOp->fAddDrawOpCalled = true;)
    GR_CREATE_TRACE_MARKER_CONTEXT("SurfaceDrawContext", "addDrawOp", fContext);
 
    // Setup clip
    SkRect bounds;
    op_bounds(&bounds, op.get());
    GrAppliedClip appliedClip(this->dimensions(), this->asSurfaceProxy()->backingStoreDimensions());
    const bool opUsesMSAA = drawOp->usesMSAA();
    bool skipDraw = false;
    if (clip) {
        // Have a complex clip, so defer to its early clip culling
        GrAAType aaType;
        if (opUsesMSAA) {
            aaType = GrAAType::kMSAA;
        } else {
            aaType = op->hasAABloat() ? GrAAType::kCoverage : GrAAType::kNone;
        }
        skipDraw = clip->apply(fContext, this, drawOp, aaType,
                               &appliedClip, &bounds) == GrClip::Effect::kClippedOut;
    } else {
        // No clipping, so just clip the bounds against the logical render target dimensions
        skipDraw = !bounds.intersect(this->asSurfaceProxy()->getBoundsRect());
    }
 
    if (skipDraw) {
        return;
    }
 
    GrClampType clampType = GrColorTypeClampType(this->colorInfo().colorType());
    GrProcessorSet::Analysis analysis = drawOp->finalize(*this->caps(), &appliedClip, clampType);
 
    const bool opUsesStencil = drawOp->usesStencil();
 
    // Always trigger DMSAA when there is stencil. This ensures stencil contents get properly
    // preserved between render passes, if needed.
    const bool drawNeedsMSAA = opUsesMSAA || (fCanUseDynamicMSAA && opUsesStencil);
 
    // Must be called before setDstProxyView so that it sees the final bounds of the op.
    op->setClippedBounds(bounds);
 
    // Determine if the Op will trigger the use of a separate DMSAA attachment that requires manual
    // resolves.
    // TODO: Currently usesAttachmentIfDMSAA checks if this is a textureProxy or not. This check is
    // really only for GL which uses a normal texture sampling when using barriers. For Vulkan it
    // is possible to use the msaa buffer as an input attachment even if this is not a texture.
    // However, support for that is not fully implemented yet in Vulkan. Once it is, this check
    // should change to a virtual caps check that returns whether we need to break up an OpsTask
    // if it has barriers and we are about to promote to MSAA.
    bool usesAttachmentIfDMSAA =
            fCanUseDynamicMSAA &&
            (!this->caps()->msaaResolvesAutomatically() || !this->asTextureProxy());
    bool opRequiresDMSAAAttachment = usesAttachmentIfDMSAA && drawNeedsMSAA;
    bool opTriggersDMSAAAttachment =
            opRequiresDMSAAAttachment && !this->getOpsTask()->usesMSAASurface();
    if (opTriggersDMSAAAttachment) {
        // This will be the op that actually triggers use of a DMSAA attachment. Texture barriers
        // can't be moved to a DMSAA attachment, so if there already are any on the current opsTask
        // then we need to split.
        if (this->getOpsTask()->renderPassXferBarriers() & GrXferBarrierFlags::kTexture) {
            SkASSERT(!this->getOpsTask()->isColorNoOp());
            this->replaceOpsTask()->setCannotMergeBackward();
        }
    }
 
    GrDstProxyView dstProxyView;
    if (analysis.requiresDstTexture()) {
        if (!this->setupDstProxyView(drawOp->bounds(), drawNeedsMSAA, &dstProxyView)) {
            return;
        }
#ifdef SK_DEBUG
        if (fCanUseDynamicMSAA && drawNeedsMSAA && !this->caps()->msaaResolvesAutomatically()) {
            // Since we aren't literally writing to the render target texture while using a DMSAA
            // attachment, we need to resolve that texture before sampling it. Ensure the current
            // opsTask got closed off in order to initiate an implicit resolve.
            SkASSERT(this->getOpsTask()->isEmpty());
        }
#endif
    }
 
    auto opsTask = this->getOpsTask();
    if (willAddFn) {
        willAddFn(op.get(), opsTask->uniqueID());
    }
 
    // Note if the op needs stencil. Stencil clipping already called setNeedsStencil for itself, if
    // needed.
    if (opUsesStencil) {
        this->setNeedsStencil();
    }
 
#if GR_GPU_STATS && defined(GR_TEST_UTILS)
    if (fCanUseDynamicMSAA && drawNeedsMSAA) {
        if (!opsTask->usesMSAASurface()) {
            fContext->priv().dmsaaStats().fNumMultisampleRenderPasses++;
        }
        fContext->priv().dmsaaStats().fTriggerCounts[op->name()]++;
    }
#endif
 
    opsTask->addDrawOp(this->drawingManager(), std::move(op), drawNeedsMSAA, analysis,
                       std::move(appliedClip), dstProxyView,
                       GrTextureResolveManager(this->drawingManager()), *this->caps());
 
#ifdef SK_DEBUG
    if (fCanUseDynamicMSAA && drawNeedsMSAA) {
        SkASSERT(opsTask->usesMSAASurface());
    }
#endif
}

◆ addDrawOp() [2/2]

void skgpu::ganesh::SurfaceDrawContext::addDrawOp ( GrOp::Owner op )

inline

Definition at line 580 of file SurfaceDrawContext.h.

580{ this->addDrawOp(nullptr, std::move(op)); }

skgpu::ganesh::SurfaceDrawContext::addDrawOp

void addDrawOp(const GrClip *, GrOp::Owner, const std::function< WillAddOpFn > &=std::function< WillAddOpFn >())

Definition SurfaceDrawContext.cpp:1922

◆ alwaysAntialias()

bool skgpu::ganesh::SurfaceDrawContext::alwaysAntialias ( ) const

inline

Definition at line 596 of file SurfaceDrawContext.h.

                                 {
        return fSurfaceProps.flags() & SkSurfaceProps::kDynamicMSAA_Flag;
    }

◆ canDiscardPreviousOpsOnFullClear()

OpsTask::CanDiscardPreviousOps skgpu::ganesh::SurfaceDrawContext::canDiscardPreviousOpsOnFullClear ( ) const

overrideprivatevirtual

Override to be called to participate in the decision to discard all previous ops if a fullscreen clear occurs.

Reimplemented from skgpu::ganesh::SurfaceFillContext.

Definition at line 803 of file SurfaceDrawContext.cpp.

                                                                                        {
#if defined(GR_TEST_UTILS)
    if (fPreserveOpsOnFullClear_TestingOnly) {
        return OpsTask::CanDiscardPreviousOps::kNo;
    }
#endif
    // Regardless of how the clear is implemented (native clear or a fullscreen quad), all prior ops
    // would normally be overwritten. The one exception is if the render target context is marked as
    // needing a stencil buffer then there may be a prior op that writes to the stencil buffer.
    // Although the clear will ignore the stencil buffer, following draw ops may not so we can't get
    // rid of all the preceding ops. Beware! If we ever add any ops that have a side effect beyond
    // modifying the stencil buffer we will need a more elaborate tracking system (skbug.com/7002).
    return OpsTask::CanDiscardPreviousOps(!fNeedsStencil);
}

◆ canUseDynamicMSAA()

bool skgpu::ganesh::SurfaceDrawContext::canUseDynamicMSAA ( ) const

inline

Definition at line 593 of file SurfaceDrawContext.h.

593{ return fCanUseDynamicMSAA; }

◆ chooseAA()

GrAA skgpu::ganesh::SurfaceDrawContext::chooseAA ( const SkPaint & paint )

inline

Definition at line 600 of file SurfaceDrawContext.h.

                                        {
        return GrAA(paint.isAntiAlias() || this->alwaysAntialias());
    }

◆ chooseAAType()

GrAAType skgpu::ganesh::SurfaceDrawContext::chooseAAType ( GrAA aa )

inline

Definition at line 604 of file SurfaceDrawContext.h.

                                   {
        if (this->numSamples() > 1 || fCanUseDynamicMSAA) {
            // Always trigger DMSAA when it's available. The coverage ops that know how to handle
            // both single and multisample targets without popping will do so without calling
            // chooseAAType.
            return GrAAType::kMSAA;
        }
        return (aa == GrAA::kYes) ? GrAAType::kCoverage : GrAAType::kNone;
    }

◆ clearStencilClip()

void skgpu::ganesh::SurfaceDrawContext::clearStencilClip	(	const SkIRect &	scissor,
		bool	insideStencilMask
	)

inline

Definition at line 517 of file SurfaceDrawContext.h.

                                                                          {
        this->internalStencilClear(&scissor, insideStencilMask);
    }

◆ drawAndStencilPath()

bool skgpu::ganesh::SurfaceDrawContext::drawAndStencilPath	(	const GrHardClip *	clip,
		const GrUserStencilSettings *	ss,
		SkRegion::Op	op,
		bool	invert,
		GrAA	doStencilMSAA,
		const SkMatrix &	viewMatrix,
		const SkPath &	path
	)

Draws a path, either AA or not, and touches the stencil buffer with the user stencil settings for each color sample written.

Definition at line 1589 of file SurfaceDrawContext.cpp.

                                                                {
    ASSERT_SINGLE_OWNER
    RETURN_FALSE_IF_ABANDONED
    SkDEBUGCODE(this->validate();)
    GR_CREATE_TRACE_MARKER_CONTEXT("SurfaceDrawContext", "drawAndStencilPath", fContext);
 
    if (path.isEmpty() && path.isInverseFillType()) {
        GrPaint paint;
        paint.setCoverageSetOpXPFactory(op, invert);
        this->stencilRect(clip, ss, std::move(paint), GrAA::kNo, SkMatrix::I(),
                          SkRect::Make(this->dimensions()));
        return true;
    }
 
    AutoCheckFlush acf(this->drawingManager());
 
    // An Assumption here is that path renderer would use some form of tweaking
    // the src color (either the input alpha or in the frag shader) to implement
    // aa. If we have some future driver-mojo path AA that can do the right
    // thing WRT to the blend then we'll need some query on the PR.
    GrAAType aaType = this->chooseAAType(aa);
    bool hasUserStencilSettings = !ss->isUnused();
 
    SkIRect clipConservativeBounds = get_clip_bounds(this, clip);
 
    GrPaint paint;
    paint.setCoverageSetOpXPFactory(op, invert);
 
    GrStyledShape shape(path, GrStyle::SimpleFill());
    PathRenderer::CanDrawPathArgs canDrawArgs;
    canDrawArgs.fCaps = this->caps();
    canDrawArgs.fProxy = this->asRenderTargetProxy();
    canDrawArgs.fViewMatrix = &viewMatrix;
    canDrawArgs.fShape = &shape;
    canDrawArgs.fPaint = &paint;
    canDrawArgs.fSurfaceProps = &fSurfaceProps;
    canDrawArgs.fClipConservativeBounds = &clipConservativeBounds;
    canDrawArgs.fAAType = aaType;
    canDrawArgs.fHasUserStencilSettings = hasUserStencilSettings;
 
    using DrawType = PathRendererChain::DrawType;
 
    // Don't allow the SW renderer
    auto pr = this->drawingManager()->getPathRenderer(canDrawArgs,
                                                      false,
                                                      DrawType::kStencilAndColor);
    if (!pr) {
        return false;
    }
 
    PathRenderer::DrawPathArgs args{this->drawingManager()->getContext(),
                                    std::move(paint),
                                    ss,
                                    this,
                                    clip,
                                    &clipConservativeBounds,
                                    &viewMatrix,
                                    &shape,
                                    aaType,
                                    this->colorInfo().isLinearlyBlended()};
    pr->drawPath(args);
    return true;
}

◆ drawArc()

void skgpu::ganesh::SurfaceDrawContext::drawArc	(	const GrClip *	clip,
		GrPaint &&	paint,
		GrAA	aa,
		const SkMatrix &	viewMatrix,
		const SkRect &	oval,
		SkScalar	startAngle,
		SkScalar	sweepAngle,
		bool	useCenter,
		const GrStyle &	style
	)

Draws a partial arc of an oval.

Parameters

paint	describes how to color pixels.
GrGrAA	Controls whether the arc is antialiased.
viewMatrix	transformation matrix.
oval	the bounding rect of the oval.
startAngle	starting angle in degrees.
sweepAngle	angle to sweep in degrees. Must be in (-360, 360)
useCenter	true means that the implied path begins at the oval center, connects as a line to the point indicated by the start contains the arc indicated by the sweep angle. If false the line beginning at the center point is omitted.
style	style to apply to the oval.

Definition at line 1418 of file SurfaceDrawContext.cpp.

                                                       {
    ASSERT_SINGLE_OWNER
    RETURN_IF_ABANDONED
    SkDEBUGCODE(this->validate();)
            GR_CREATE_TRACE_MARKER_CONTEXT("SurfaceDrawContext", "drawArc", fContext);
 
    AutoCheckFlush acf(this->drawingManager());
 
#ifndef SK_ENABLE_OPTIMIZE_SIZE
    GrAAType aaType = this->chooseAAType(aa);
    if (aaType == GrAAType::kCoverage) {
        const GrShaderCaps* shaderCaps = this->caps()->shaderCaps();
        GrOp::Owner op = GrOvalOpFactory::MakeArcOp(fContext,
                                                    std::move(paint),
                                                    viewMatrix,
                                                    oval,
                                                    startAngle,
                                                    sweepAngle,
                                                    useCenter,
                                                    style,
                                                    shaderCaps);
        if (op) {
            this->addDrawOp(clip, std::move(op));
            return;
        }
        assert_alive(paint);
    }
#endif
    this->drawShapeUsingPathRenderer(clip, std::move(paint), aa, viewMatrix,
                                     GrStyledShape::MakeArc(oval, startAngle, sweepAngle, useCenter,
                                                            style, DoSimplify::kNo));
}

◆ drawAtlas()

void skgpu::ganesh::SurfaceDrawContext::drawAtlas	(	const GrClip *	clip,
		GrPaint &&	paint,
		const SkMatrix &	viewMatrix,
		int	spriteCount,
		const SkRSXform	xform[],
		const SkRect	texRect[],
		const SkColor	colors[]
	)

Draws textured sprites from an atlas with a paint. This currently does not support AA for the sprite rectangle edges.

Parameters

paint	describes how to color pixels.
viewMatrix	transformation matrix
spriteCount	number of sprites.
xform	array of compressed transformation data, required.
texRect	array of texture rectangles used to access the paint.
colors	optional array of per-sprite colors, supercedes the paint's color field.

Definition at line 983 of file SurfaceDrawContext.cpp.

                                                           {
    ASSERT_SINGLE_OWNER
    RETURN_IF_ABANDONED
    SkDEBUGCODE(this->validate();)
    GR_CREATE_TRACE_MARKER_CONTEXT("SurfaceDrawContext", "drawAtlas", fContext);
 
    AutoCheckFlush acf(this->drawingManager());
 
    GrAAType aaType = this->chooseAAType(GrAA::kNo);
    GrOp::Owner op = DrawAtlasOp::Make(fContext, std::move(paint), viewMatrix,
                                       aaType, spriteCount, xform, texRect, colors);
    this->addDrawOp(clip, std::move(op));
}

◆ drawDrawable()

void skgpu::ganesh::SurfaceDrawContext::drawDrawable	(	std::unique_ptr< SkDrawable::GpuDrawHandler >	drawable,
		const SkRect &	bounds
	)

Adds the necessary signal and wait semaphores and adds the passed in SkDrawable to the command stream.

Definition at line 1481 of file SurfaceDrawContext.cpp.

                                                            {
    ASSERT_SINGLE_OWNER
    RETURN_IF_ABANDONED
    SkDEBUGCODE(this->validate();)
    GR_CREATE_TRACE_MARKER_CONTEXT("SurfaceDrawContext", "drawDrawable", fContext);
    GrOp::Owner op(DrawableOp::Make(fContext, std::move(drawable), bounds));
    SkASSERT(op);
    this->addOp(std::move(op));
}

◆ drawFastShadow()

bool skgpu::ganesh::SurfaceDrawContext::drawFastShadow	(	const GrClip *	clip,
		const SkMatrix &	viewMatrix,
		const SkPath &	path,
		const SkDrawShadowRec &	rec
	)

Use a fast method to render the ambient and spot shadows for a path. Will return false if not possible for the given path.

Parameters

viewMatrix	transformation matrix
path	the path to shadow
rec	parameters for shadow rendering

Definition at line 1104 of file SurfaceDrawContext.cpp.

                                                                    {
    ASSERT_SINGLE_OWNER
    if (fContext->abandoned()) {
        return true;
    }
    SkDEBUGCODE(this->validate();)
    GR_CREATE_TRACE_MARKER_CONTEXT("SurfaceDrawContext", "drawFastShadow", fContext);
 
    // check z plane
    bool tiltZPlane = SkToBool(!SkScalarNearlyZero(rec.fZPlaneParams.fX) ||
                               !SkScalarNearlyZero(rec.fZPlaneParams.fY));
    bool skipAnalytic = SkToBool(rec.fFlags & SkShadowFlags::kGeometricOnly_ShadowFlag);
    if (tiltZPlane || skipAnalytic || !viewMatrix.rectStaysRect() || !viewMatrix.isSimilarity()) {
        return false;
    }
 
    SkRRect rrect;
    SkRect rect;
    // we can only handle rects, circles, and simple rrects with circular corners
    bool isRRect = path.isRRect(&rrect) && SkRRectPriv::IsNearlySimpleCircular(rrect) &&
                   rrect.getSimpleRadii().fX > SK_ScalarNearlyZero;
    if (!isRRect &&
        path.isOval(&rect) && SkScalarNearlyEqual(rect.width(), rect.height()) &&
        rect.width() > SK_ScalarNearlyZero) {
        rrect.setOval(rect);
        isRRect = true;
    }
    if (!isRRect && path.isRect(&rect)) {
        rrect.setRect(rect);
        isRRect = true;
    }
 
    if (!isRRect) {
        return false;
    }
 
    if (rrect.isEmpty()) {
        return true;
    }
 
    AutoCheckFlush acf(this->drawingManager());
 
    SkPoint3 devLightPos = rec.fLightPos;
    bool directional = SkToBool(rec.fFlags & kDirectionalLight_ShadowFlag);
    if (!directional) {
        // transform light
        viewMatrix.mapPoints((SkPoint*)&devLightPos.fX, 1);
    }
 
    // 1/scale
    SkScalar devToSrcScale = viewMatrix.isScaleTranslate() ?
        SkScalarInvert(SkScalarAbs(viewMatrix[SkMatrix::kMScaleX])) :
        sk_float_rsqrt(viewMatrix[SkMatrix::kMScaleX] * viewMatrix[SkMatrix::kMScaleX] +
                       viewMatrix[SkMatrix::kMSkewX] * viewMatrix[SkMatrix::kMSkewX]);
 
    SkScalar occluderHeight = rec.fZPlaneParams.fZ;
    bool transparent = SkToBool(rec.fFlags & SkShadowFlags::kTransparentOccluder_ShadowFlag);
 
    if (SkColorGetA(rec.fAmbientColor) > 0) {
        SkScalar devSpaceInsetWidth = SkDrawShadowMetrics::AmbientBlurRadius(occluderHeight);
        const SkScalar umbraRecipAlpha = SkDrawShadowMetrics::AmbientRecipAlpha(occluderHeight);
        const SkScalar devSpaceAmbientBlur = devSpaceInsetWidth * umbraRecipAlpha;
 
        // Outset the shadow rrect to the border of the penumbra
        SkScalar ambientPathOutset = devSpaceInsetWidth * devToSrcScale;
        SkRRect ambientRRect;
        SkRect outsetRect = rrect.rect().makeOutset(ambientPathOutset, ambientPathOutset);
        // If the rrect was an oval then its outset will also be one.
        // We set it explicitly to avoid errors.
        if (rrect.isOval()) {
            ambientRRect = SkRRect::MakeOval(outsetRect);
        } else {
            SkScalar outsetRad = SkRRectPriv::GetSimpleRadii(rrect).fX + ambientPathOutset;
            ambientRRect = SkRRect::MakeRectXY(outsetRect, outsetRad, outsetRad);
        }
 
        // The ShadowRRectOp still uses 8888 colors, so it might get clamped if the shadow color
        // does not fit in bytes after being transformed to the destination color space. This can
        // happen if the destination color space is smaller than sRGB, which is highly unlikely.
        GrColor ambientColor = SkColorToPMColor4f(rec.fAmbientColor, colorInfo()).toBytes_RGBA();
        if (transparent) {
            // set a large inset to force a fill
            devSpaceInsetWidth = ambientRRect.width();
        }
 
        GrOp::Owner op = ShadowRRectOp::Make(fContext,
                                             ambientColor,
                                             viewMatrix,
                                             ambientRRect,
                                             devSpaceAmbientBlur,
                                             devSpaceInsetWidth);
        if (op) {
            this->addDrawOp(clip, std::move(op));
        }
    }
 
    if (SkColorGetA(rec.fSpotColor) > 0) {
        SkScalar devSpaceSpotBlur;
        SkScalar spotScale;
        SkVector spotOffset;
        if (directional) {
            SkDrawShadowMetrics::GetDirectionalParams(occluderHeight, devLightPos.fX,
                                                      devLightPos.fY, devLightPos.fZ,
                                                      rec.fLightRadius, &devSpaceSpotBlur,
                                                      &spotScale, &spotOffset);
        } else {
            SkDrawShadowMetrics::GetSpotParams(occluderHeight, devLightPos.fX, devLightPos.fY,
                                               devLightPos.fZ, rec.fLightRadius,
                                               &devSpaceSpotBlur, &spotScale, &spotOffset);
        }
        // handle scale of radius due to CTM
        const SkScalar srcSpaceSpotBlur = devSpaceSpotBlur * devToSrcScale;
 
        // Adjust translate for the effect of the scale.
        spotOffset.fX += spotScale*viewMatrix[SkMatrix::kMTransX];
        spotOffset.fY += spotScale*viewMatrix[SkMatrix::kMTransY];
        // This offset is in dev space, need to transform it into source space.
        SkMatrix ctmInverse;
        if (viewMatrix.invert(&ctmInverse)) {
            ctmInverse.mapPoints(&spotOffset, 1);
        } else {
            // Since the matrix is a similarity, this should never happen, but just in case...
            SkDebugf("Matrix is degenerate. Will not render spot shadow correctly!\n");
            SkASSERT(false);
        }
 
        // Compute the transformed shadow rrect
        SkRRect spotShadowRRect;
        SkMatrix shadowTransform;
        shadowTransform.setScaleTranslate(spotScale, spotScale, spotOffset.fX, spotOffset.fY);
        rrect.transform(shadowTransform, &spotShadowRRect);
        SkScalar spotRadius = spotShadowRRect.getSimpleRadii().fX;
 
        // Compute the insetWidth
        SkScalar blurOutset = srcSpaceSpotBlur;
        SkScalar insetWidth = blurOutset;
        if (transparent) {
            // If transparent, just do a fill
            insetWidth += spotShadowRRect.width();
        } else {
            // For shadows, instead of using a stroke we specify an inset from the penumbra
            // border. We want to extend this inset area so that it meets up with the caster
            // geometry. The inset geometry will by default already be inset by the blur width.
            //
            // We compare the min and max corners inset by the radius between the original
            // rrect and the shadow rrect. The distance between the two plus the difference
            // between the scaled radius and the original radius gives the distance from the
            // transformed shadow shape to the original shape in that corner. The max
            // of these gives the maximum distance we need to cover.
            //
            // Since we are outsetting by 1/2 the blur distance, we just add the maxOffset to
            // that to get the full insetWidth.
            SkScalar maxOffset;
            if (rrect.isRect()) {
                // Manhattan distance works better for rects
                maxOffset = std::max(std::max(SkTAbs(spotShadowRRect.rect().fLeft -
                                                 rrect.rect().fLeft),
                                          SkTAbs(spotShadowRRect.rect().fTop -
                                                 rrect.rect().fTop)),
                                   std::max(SkTAbs(spotShadowRRect.rect().fRight -
                                                 rrect.rect().fRight),
                                          SkTAbs(spotShadowRRect.rect().fBottom -
                                                 rrect.rect().fBottom)));
            } else {
                SkScalar dr = spotRadius - SkRRectPriv::GetSimpleRadii(rrect).fX;
                SkPoint upperLeftOffset = SkPoint::Make(spotShadowRRect.rect().fLeft -
                                                        rrect.rect().fLeft + dr,
                                                        spotShadowRRect.rect().fTop -
                                                        rrect.rect().fTop + dr);
                SkPoint lowerRightOffset = SkPoint::Make(spotShadowRRect.rect().fRight -
                                                         rrect.rect().fRight - dr,
                                                         spotShadowRRect.rect().fBottom -
                                                         rrect.rect().fBottom - dr);
                maxOffset = SkScalarSqrt(std::max(SkPointPriv::LengthSqd(upperLeftOffset),
                                                  SkPointPriv::LengthSqd(lowerRightOffset))) + dr;
            }
            insetWidth += std::max(blurOutset, maxOffset);
        }
 
        // Outset the shadow rrect to the border of the penumbra
        SkRect outsetRect = spotShadowRRect.rect().makeOutset(blurOutset, blurOutset);
        if (spotShadowRRect.isOval()) {
            spotShadowRRect = SkRRect::MakeOval(outsetRect);
        } else {
            SkScalar outsetRad = spotRadius + blurOutset;
            spotShadowRRect = SkRRect::MakeRectXY(outsetRect, outsetRad, outsetRad);
        }
 
        // The ShadowRRectOp still uses 8888 colors, so it might get clamped if the shadow color
        // does not fit in bytes after being transformed to the destination color space. This can
        // happen if the destination color space is smaller than sRGB, which is highly unlikely.
        GrColor spotColor = SkColorToPMColor4f(rec.fSpotColor, colorInfo()).toBytes_RGBA();
        GrOp::Owner op = ShadowRRectOp::Make(fContext,
                                             spotColor,
                                             viewMatrix,
                                             spotShadowRRect,
                                             2.0f * devSpaceSpotBlur,
                                             insetWidth);
        if (op) {
            this->addDrawOp(clip, std::move(op));
        }
    }
 
    return true;
}

◆ drawGlyphRunList()

void skgpu::ganesh::SurfaceDrawContext::drawGlyphRunList	(	SkCanvas *	canvas,
		const GrClip *	clip,
		const SkMatrix &	viewMatrix,
		const sktext::GlyphRunList &	glyphRunList,
		SkStrikeDeviceInfo	strikeDeviceInfo,
		const SkPaint &	paint
	)

Draw the text specified by the GlyphRunList.

Parameters

viewMatrix	transformation matrix
glyphRunList	text, text positions, and paint.

Definition at line 331 of file SurfaceDrawContext.cpp.

                                                                {
    ASSERT_SINGLE_OWNER
    RETURN_IF_ABANDONED
    SkDEBUGCODE(this->validate();)
    GR_CREATE_TRACE_MARKER_CONTEXT("SurfaceDrawContext", "drawGlyphRunList", fContext);
 
    // Drawing text can cause us to do inline uploads. This is not supported for wrapped vulkan
    // secondary command buffers because it would require stopping and starting a render pass which
    // we don't have access to.
    if (this->wrapsVkSecondaryCB()) {
        return;
    }
 
    sktext::gpu::TextBlobRedrawCoordinator* textBlobCache = fContext->priv().getTextBlobCache();
 
    auto atlasDelegate = [&](const sktext::gpu::AtlasSubRun* subRun,
                             SkPoint drawOrigin,
                             const SkPaint& paint,
                             sk_sp<SkRefCnt> subRunStorage,
                             sktext::gpu::RendererData) {
        auto [drawingClip, op] = subRun->makeAtlasTextOp(
                clip, viewMatrix, drawOrigin, paint, std::move(subRunStorage), this);
        if (op != nullptr) {
            this->addDrawOp(drawingClip, std::move(op));
        }
    };
 
    textBlobCache->drawGlyphRunList(
            canvas, viewMatrix, glyphRunList, paint, strikeDeviceInfo, atlasDelegate);
}

◆ drawImageLattice()

void skgpu::ganesh::SurfaceDrawContext::drawImageLattice	(	const GrClip *	clip,
		GrPaint &&	paint,
		const SkMatrix &	viewMatrix,
		GrSurfaceProxyView	view,
		SkAlphaType	alphaType,
		sk_sp< GrColorSpaceXform >	csxf,
		GrSamplerState::Filter	filter,
		std::unique_ptr< SkLatticeIter >	iter,
		const SkRect &	dst
	)

Draw the image as a set of rects, specified by |iter|.

Definition at line 1459 of file SurfaceDrawContext.cpp.

                                                             {
    ASSERT_SINGLE_OWNER
    RETURN_IF_ABANDONED
    SkDEBUGCODE(this->validate();)
    GR_CREATE_TRACE_MARKER_CONTEXT("SurfaceDrawContext", "drawImageLattice", fContext);
 
    AutoCheckFlush acf(this->drawingManager());
 
    GrOp::Owner op =
              LatticeOp::MakeNonAA(fContext, std::move(paint), viewMatrix, std::move(view),
                                   alphaType, std::move(csxf), filter, std::move(iter), dst);
    this->addDrawOp(clip, std::move(op));
}

◆ drawMesh()

void skgpu::ganesh::SurfaceDrawContext::drawMesh	(	const GrClip *	clip,
		GrPaint &&	paint,
		const SkMatrix &	viewMatrix,
		const SkMesh &	mesh,
		skia_private::TArray< std::unique_ptr< GrFragmentProcessor > >	children
	)

Draws a custom mesh with a paint.

Parameters

paint	describes how to color pixels.
viewMatrix	transformation matrix
mesh	the mesh to draw.
children	child effects referenced by SkMesh shaders

Definition at line 952 of file SurfaceDrawContext.cpp.

                                                                                       {
    ASSERT_SINGLE_OWNER
    RETURN_IF_ABANDONED
    SkDEBUGCODE(this->validate();)
    GR_CREATE_TRACE_MARKER_CONTEXT("SurfaceDrawContext", "drawMesh", fContext);
 
    AutoCheckFlush acf(this->drawingManager());
 
    SkASSERT(mesh.isValid());
 
    auto xform = GrColorSpaceXform::Make(SkMeshSpecificationPriv::ColorSpace(*mesh.spec()),
                                         SkMeshSpecificationPriv::AlphaType(*mesh.spec()),
                                         this->colorInfo().colorSpace(),
                                         this->colorInfo().alphaType());
    GrAAType aaType = fCanUseDynamicMSAA ? GrAAType::kMSAA : this->chooseAAType(GrAA::kNo);
    GrOp::Owner op = DrawMeshOp::Make(fContext,
                                      std::move(paint),
                                      mesh,
                                      std::move(children),
                                      viewMatrix,
                                      aaType,
                                      std::move(xform));
    this->addDrawOp(clip, std::move(op));
}

◆ drawOval()

void skgpu::ganesh::SurfaceDrawContext::drawOval	(	const GrClip *	clip,
		GrPaint &&	paint,
		GrAA	aa,
		const SkMatrix &	viewMatrix,
		const SkRect &	oval,
		const GrStyle &	style
	)

Draws an oval.

Parameters

paint	describes how to color pixels.
GrAA	Controls whether the oval is antialiased.
viewMatrix	transformation matrix
oval	the bounding rect of the oval.
style	style to apply to the oval. Currently path effects are not allowed.

Definition at line 1350 of file SurfaceDrawContext.cpp.

                                                        {
    ASSERT_SINGLE_OWNER
    RETURN_IF_ABANDONED
    SkDEBUGCODE(this->validate();)
    GR_CREATE_TRACE_MARKER_CONTEXT("SurfaceDrawContext", "drawOval", fContext);
 
    const SkStrokeRec& stroke = style.strokeRec();
 
    if (oval.isEmpty() && !style.pathEffect()) {
        if (stroke.getStyle() == SkStrokeRec::kFill_Style) {
            return;
        }
 
        this->drawRect(clip, std::move(paint), aa, viewMatrix, oval, &style);
        return;
    }
 
    AutoCheckFlush acf(this->drawingManager());
 
    GrAAType aaType = this->chooseAAType(aa);
 
    GrOp::Owner op;
#ifndef SK_ENABLE_OPTIMIZE_SIZE
    if (aaType == GrAAType::kCoverage      &&
        !fCanUseDynamicMSAA                &&
        !this->caps()->reducedShaderMode() &&
        oval.width() > SK_ScalarNearlyZero &&
        oval.width() == oval.height()      &&
        viewMatrix.isSimilarity()) {
        // In specific cases we use a dedicated circle op to try and get better perf.
        assert_alive(paint);
        op = GrOvalOpFactory::MakeCircleOp(fContext, std::move(paint), viewMatrix, oval, style,
                                           this->caps()->shaderCaps());
    }
#endif
    if (!op && style.isSimpleFill()) {
        // FillRRectOp has special geometry and a fragment-shader branch to conditionally evaluate
        // the arc equation. This same special geometry and fragment branch also turn out to be a
        // substantial optimization for drawing ovals (namely, by not evaluating the arc equation
        // inside the oval's inner diamond). Given these optimizations, it's a clear win to draw
        // ovals the exact same way we do round rects.
        assert_alive(paint);
        op = FillRRectOp::Make(fContext, this->arenaAlloc(), std::move(paint), viewMatrix,
                               SkRRect::MakeOval(oval), oval, GrAA(aaType != GrAAType::kNone));
    }
#ifndef SK_ENABLE_OPTIMIZE_SIZE
    if (!op && (aaType == GrAAType::kCoverage || fCanUseDynamicMSAA)) {
        assert_alive(paint);
        op = GrOvalOpFactory::MakeOvalOp(fContext, std::move(paint), viewMatrix, oval, style,
                                         this->caps()->shaderCaps());
    }
#endif
    if (op) {
        this->addDrawOp(clip, std::move(op));
        return;
    }
 
    assert_alive(paint);
    this->drawShapeUsingPathRenderer(clip, std::move(paint), aa, viewMatrix,
                                     GrStyledShape(SkRRect::MakeOval(oval), SkPathDirection::kCW, 2,
                                                   false, style, DoSimplify::kNo));
}

◆ drawPaint()

void skgpu::ganesh::SurfaceDrawContext::drawPaint	(	const GrClip *	clip,
		GrPaint &&	paint,
		const SkMatrix &	viewMatrix
	)

Draw everywhere (respecting the clip) with the paint.

Definition at line 367 of file SurfaceDrawContext.cpp.

                                                               {
    // Start with the render target, since that is the maximum content we could possibly fill.
    // drawFilledQuad() will automatically restrict it to clip bounds for us if possible.
    if (!paint.numTotalFragmentProcessors()) {
        // The paint is trivial so we won't need to use local coordinates, so skip calculating the
        // inverse view matrix.
        SkRect r = this->asSurfaceProxy()->getBoundsRect();
        this->fillRectToRect(clip, std::move(paint), GrAA::kNo, SkMatrix::I(), r, r);
    } else {
        // Use the inverse view matrix to arrive at appropriate local coordinates for the paint.
        SkMatrix localMatrix;
        if (!viewMatrix.invert(&localMatrix)) {
            return;
        }
        SkIRect bounds = SkIRect::MakeSize(this->asSurfaceProxy()->dimensions());
        this->fillPixelsWithLocalMatrix(clip, std::move(paint), bounds, localMatrix);
    }
}

◆ drawPath()

void skgpu::ganesh::SurfaceDrawContext::drawPath	(	const GrClip *	clip,
		GrPaint &&	paint,
		GrAA	aa,
		const SkMatrix &	viewMatrix,
		const SkPath &	path,
		const GrStyle &	style
	)

Draws a path.

Parameters

paint	describes how to color pixels.
GrAA	Controls whether the path is antialiased.
viewMatrix	transformation matrix
path	the path to draw
style	style to apply to the path.

Definition at line 1546 of file SurfaceDrawContext.cpp.

                                                        {
    ASSERT_SINGLE_OWNER
    RETURN_IF_ABANDONED
    SkDEBUGCODE(this->validate();)
    GR_CREATE_TRACE_MARKER_CONTEXT("SurfaceDrawContext", "drawPath", fContext);
 
    GrStyledShape shape(path, style, DoSimplify::kNo);
    this->drawShape(clip, std::move(paint), aa, viewMatrix, std::move(shape));
}

◆ drawQuadSet()

void skgpu::ganesh::SurfaceDrawContext::drawQuadSet	(	const GrClip *	clip,
		GrPaint &&	paint,
		const SkMatrix &	viewMatrix,
		const GrQuadSetEntry	quads[],
		int	cnt
	)

Definition at line 788 of file SurfaceDrawContext.cpp.

                                              {
    GrAAType aaType = this->chooseAAType(GrAA::kYes);
 
    FillRectOp::AddFillRectOps(this, clip, fContext, std::move(paint), aaType, viewMatrix,
                               quads, cnt);
}

◆ drawRect()

void skgpu::ganesh::SurfaceDrawContext::drawRect	(	const GrClip *	clip,
		GrPaint &&	paint,
		GrAA	aa,
		const SkMatrix &	viewMatrix,
		const SkRect &	rect,
		const GrStyle *	style = `nullptr`
	)

Draw the rect using a paint.

Parameters

paint	describes how to color pixels.
GrAA	Controls whether rect is antialiased
viewMatrix	transformation matrix
style	The style to apply. Null means fill. Currently path effects are not allowed. The rects coords are used to access the paint (through texture matrix)

Definition at line 679 of file SurfaceDrawContext.cpp.

                                                        {
    if (!style) {
        style = &GrStyle::SimpleFill();
    }
    ASSERT_SINGLE_OWNER
    RETURN_IF_ABANDONED
    SkDEBUGCODE(this->validate();)
    GR_CREATE_TRACE_MARKER_CONTEXT("SurfaceDrawContext", "drawRect", fContext);
 
    // Path effects should've been devolved to a path in SkGpuDevice
    SkASSERT(!style->pathEffect());
 
    AutoCheckFlush acf(this->drawingManager());
 
    const SkStrokeRec& stroke = style->strokeRec();
    if (stroke.getStyle() == SkStrokeRec::kFill_Style) {
        // Fills the rect, using rect as its own local coordinates
        this->fillRectToRect(clip, std::move(paint), aa, viewMatrix, rect, rect);
        return;
    } else if ((stroke.getStyle() == SkStrokeRec::kStroke_Style ||
                stroke.getStyle() == SkStrokeRec::kHairline_Style) &&
               rect.width()                                        &&
               rect.height()                                       &&
               !this->caps()->reducedShaderMode()) {
        // Only use the StrokeRectOp for non-empty rectangles. Empty rectangles will be processed by
        // GrStyledShape to handle stroke caps and dashing properly.
        //
        // http://skbug.com/12206 -- there is a double-blend issue with the bevel version of
        // AAStrokeRectOp, and if we increase the AA bloat for MSAA it becomes more pronounced.
        // Don't use the bevel version with DMSAA.
        GrAAType aaType = (fCanUseDynamicMSAA &&
                           stroke.getJoin() == SkPaint::kMiter_Join &&
                           stroke.getMiter() >= SK_ScalarSqrt2) ? GrAAType::kCoverage
                                                                : this->chooseAAType(aa);
        GrOp::Owner op = ganesh::StrokeRectOp::Make(fContext, std::move(paint), aaType, viewMatrix,
                                                    rect, stroke);
        // op may be null if the stroke is not supported or if using coverage aa and the view matrix
        // does not preserve rectangles.
        if (op) {
            this->addDrawOp(clip, std::move(op));
            return;
        }
    }
    assert_alive(paint);
    this->drawShapeUsingPathRenderer(clip, std::move(paint), aa, viewMatrix,
                                     GrStyledShape(rect, *style, DoSimplify::kNo));
}

◆ drawRegion()

void skgpu::ganesh::SurfaceDrawContext::drawRegion	(	const GrClip *	clip,
		GrPaint &&	paint,
		GrAA	aa,
		const SkMatrix &	viewMatrix,
		const SkRegion &	region,
		const GrStyle &	style,
		const GrUserStencilSettings *	ss = `nullptr`
	)

Draws a region.

Parameters

paint	describes how to color pixels
viewMatrix	transformation matrix
aa	should the rects of the region be antialiased.
region	the region to be drawn
style	style to apply to the region

Definition at line 1315 of file SurfaceDrawContext.cpp.

                                                                     {
    ASSERT_SINGLE_OWNER
    RETURN_IF_ABANDONED
    SkDEBUGCODE(this->validate();)
    GR_CREATE_TRACE_MARKER_CONTEXT("SurfaceDrawContext", "drawRegion", fContext);
 
    if (GrAA::kYes == aa) {
        // GrRegionOp performs no antialiasing but is much faster, so here we check the matrix
        // to see whether aa is really required.
        if (!SkToBool(viewMatrix.getType() & ~(SkMatrix::kTranslate_Mask)) &&
            SkScalarIsInt(viewMatrix.getTranslateX()) &&
            SkScalarIsInt(viewMatrix.getTranslateY())) {
            aa = GrAA::kNo;
        }
    }
    bool complexStyle = !style.isSimpleFill();
    if (complexStyle || GrAA::kYes == aa) {
        SkPath path;
        region.getBoundaryPath(&path);
        path.setIsVolatile(true);
 
        return this->drawPath(clip, std::move(paint), aa, viewMatrix, path, style);
    }
 
    GrAAType aaType = (this->numSamples() > 1) ? GrAAType::kMSAA : GrAAType::kNone;
    GrOp::Owner op = RegionOp::Make(fContext, std::move(paint), viewMatrix, region, aaType, ss);
    this->addDrawOp(clip, std::move(op));
}

◆ drawRRect()

void skgpu::ganesh::SurfaceDrawContext::drawRRect	(	const GrClip *	origClip,
		GrPaint &&	paint,
		GrAA	aa,
		const SkMatrix &	viewMatrix,
		const SkRRect &	rrect,
		const GrStyle &	style
	)

Draw a roundrect using a paint.

Parameters

paint	describes how to color pixels.
GrAA	Controls whether rrect is antialiased.
viewMatrix	transformation matrix
rrect	the roundrect to draw
style	style to apply to the rrect. Currently path effects are not allowed.

Definition at line 1005 of file SurfaceDrawContext.cpp.

                                                         {
    ASSERT_SINGLE_OWNER
    RETURN_IF_ABANDONED
    SkDEBUGCODE(this->validate();)
    GR_CREATE_TRACE_MARKER_CONTEXT("SurfaceDrawContext", "drawRRect", fContext);
 
    SkASSERT(!style.pathEffect()); // this should've been devolved to a path in SkGpuDevice
 
    const SkStrokeRec& stroke = style.strokeRec();
    if (stroke.getStyle() == SkStrokeRec::kFill_Style && rrect.isEmpty()) {
       return;
    }
 
    const GrClip* clip = origClip;
    // It is not uncommon to clip to a round rect and then draw that same round rect. Since our
    // lower level clip code works from op bounds, which are SkRects, it doesn't detect that the
    // clip can be ignored. The following test attempts to mitigate the stencil clip cost but only
    // works for axis-aligned round rects. This also only works for filled rrects since the stroke
    // width outsets beyond the rrect itself.
    // TODO: skbug.com/10462 - There was mixed performance wins and regressions when this
    // optimization was turned on outside of Android Framework. I (michaelludwig) believe this is
    // do to the overhead in determining if an SkClipStack is just a rrect. Once that is improved,
    // re-enable this and see if we avoid the regressions.
#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
    SkRRect devRRect;
    if (clip && stroke.getStyle() == SkStrokeRec::kFill_Style &&
        rrect.transform(viewMatrix, &devRRect)) {
        GrClip::PreClipResult result = clip->preApply(devRRect.getBounds(), aa);
        switch(result.fEffect) {
            case GrClip::Effect::kClippedOut:
                return;
            case GrClip::Effect::kUnclipped:
                clip = nullptr;
                break;
            case GrClip::Effect::kClipped:
                // Currently there's no general-purpose rrect-to-rrect contains function, and if we
                // got here, we know the devRRect's bounds aren't fully contained by the clip.
                // Testing for equality between the two is a reasonable stop-gap for now.
                if (result.fIsRRect && result.fRRect == devRRect) {
                    // NOTE: On the android framework, we allow this optimization even when the clip
                    // is non-AA and the draw is AA.
                    if (result.fAA == aa || (result.fAA == GrAA::kNo && aa == GrAA::kYes)) {
                        clip = nullptr;
                    }
                }
                break;
            default:
                SkUNREACHABLE;
        }
    }
#endif
 
    AutoCheckFlush acf(this->drawingManager());
 
    GrAAType aaType = this->chooseAAType(aa);
 
    GrOp::Owner op;
#ifndef SK_ENABLE_OPTIMIZE_SIZE
    if (aaType == GrAAType::kCoverage                          &&
        !fCanUseDynamicMSAA                                    &&
        !this->caps()->reducedShaderMode()                     &&
        rrect.isSimple()                                       &&
        rrect.getSimpleRadii().fX == rrect.getSimpleRadii().fY &&
        viewMatrix.rectStaysRect() && viewMatrix.isSimilarity()) {
        // In specific cases we use a dedicated circular round rect op to try and get better perf.
        assert_alive(paint);
        op = GrOvalOpFactory::MakeCircularRRectOp(fContext, std::move(paint), viewMatrix, rrect,
                                                  stroke, this->caps()->shaderCaps());
    }
#endif
    if (!op && style.isSimpleFill()) {
        assert_alive(paint);
        op = FillRRectOp::Make(fContext, this->arenaAlloc(), std::move(paint), viewMatrix, rrect,
                               rrect.rect(), GrAA(aaType != GrAAType::kNone));
    }
#ifndef SK_ENABLE_OPTIMIZE_SIZE
    if (!op && (aaType == GrAAType::kCoverage || fCanUseDynamicMSAA)) {
        assert_alive(paint);
        op = GrOvalOpFactory::MakeRRectOp(
                fContext, std::move(paint), viewMatrix, rrect, stroke, this->caps()->shaderCaps());
    }
#endif
    if (op) {
        this->addDrawOp(clip, std::move(op));
        return;
    }
 
    assert_alive(paint);
    this->drawShapeUsingPathRenderer(clip, std::move(paint), aa, viewMatrix,
                                     GrStyledShape(rrect, style, DoSimplify::kNo));
}

◆ drawShape()

void skgpu::ganesh::SurfaceDrawContext::drawShape	(	const GrClip *	clip,
		GrPaint &&	paint,
		GrAA	aa,
		const SkMatrix &	viewMatrix,
		GrStyledShape &&	shape
	)

Draws a shape.

Parameters

paint	describes how to color pixels.
GrAA	Controls whether the path is antialiased.
viewMatrix	transformation matrix
shape	the shape to draw

Definition at line 1561 of file SurfaceDrawContext.cpp.

                                                          {
    ASSERT_SINGLE_OWNER
    RETURN_IF_ABANDONED
    SkDEBUGCODE(this->validate();)
    GR_CREATE_TRACE_MARKER_CONTEXT("SurfaceDrawContext", "drawShape", fContext);
 
    if (shape.isEmpty()) {
        if (shape.inverseFilled()) {
            this->drawPaint(clip, std::move(paint), viewMatrix);
        }
        return;
    }
 
    AutoCheckFlush acf(this->drawingManager());
 
    // If we get here in drawShape(), we definitely need to use path rendering
    this->drawShapeUsingPathRenderer(clip, std::move(paint), aa, viewMatrix, std::move(shape),
                                     /* attemptDrawSimple */ true);
}

◆ drawStrokedLine()

void skgpu::ganesh::SurfaceDrawContext::drawStrokedLine	(	const GrClip *	clip,
		GrPaint &&	paint,
		GrAA	aa,
		const SkMatrix &	viewMatrix,
		const SkPoint	points[2],
		const SkStrokeRec &	stroke
	)

Definition at line 1671 of file SurfaceDrawContext.cpp.

                                                                    {
    ASSERT_SINGLE_OWNER
 
    SkASSERT(stroke.getStyle() == SkStrokeRec::kStroke_Style);
    SkASSERT(stroke.getWidth() > 0);
    // Adding support for round capping would require a
    // SurfaceDrawContext::fillRRectWithLocalMatrix entry point
    SkASSERT(SkPaint::kRound_Cap != stroke.getCap());
 
    const SkScalar halfWidth = 0.5f * stroke.getWidth();
    if (halfWidth <= 0.f) {
        // Prevents underflow when stroke width is epsilon > 0 (so technically not a hairline).
        // The CTM would need to have a scale near 1/epsilon in order for this to have meaningful
        // coverage (although that would likely overflow elsewhere and cause the draw to drop due
        // to non-finite bounds). At any other scale, this line is so thin, it's coverage is
        // negligible, so discarding the draw is visually equivalent.
        return;
    }
 
    SkVector parallel = points[1] - points[0];
 
    if (!SkPoint::Normalize(&parallel)) {
        parallel.fX = 1.0f;
        parallel.fY = 0.0f;
    }
    parallel *= halfWidth;
 
    SkVector ortho = { parallel.fY, -parallel.fX };
    SkPoint p0 = points[0], p1 = points[1];
    if (stroke.getCap() == SkPaint::kSquare_Cap) {
        // Extra extension for square caps
        p0 -= parallel;
        p1 += parallel;
    }
 
    // If we are using dmsaa or reduced shader mode then attempt to draw with FillRRectOp.
    if (this->caps()->drawInstancedSupport() &&
        (this->alwaysAntialias() ||
         (fContext->priv().caps()->reducedShaderMode() && aa == GrAA::kYes))) {
        SkMatrix localMatrix = SkMatrix::MakeAll(p1.fX - p0.fX, ortho.fX, p0.fX,
                                                 p1.fY - p0.fY, ortho.fY, p0.fY,
                                                 0, 0, 1);
        if (auto op = FillRRectOp::Make(fContext,
                                        this->arenaAlloc(),
                                        std::move(paint),
                                        SkMatrix::Concat(viewMatrix, localMatrix),
                                        SkRRect::MakeRect({0,-1,1,1}),
                                        localMatrix,
                                        GrAA::kYes)) {
            this->addDrawOp(clip, std::move(op));
            return;
        }
    }
 
    // Order is TL, TR, BR, BL where arbitrarily "down" is p0 to p1 and "right" is positive
    SkPoint corners[4] = { p0 - ortho,
                           p0 + ortho,
                           p1 + ortho,
                           p1 - ortho };
 
    GrQuadAAFlags edgeAA = (aa == GrAA::kYes) ? GrQuadAAFlags::kAll : GrQuadAAFlags::kNone;
 
    assert_alive(paint);
    this->fillQuadWithEdgeAA(clip, std::move(paint), edgeAA, viewMatrix, corners, nullptr);
}

◆ drawTexture()

void skgpu::ganesh::SurfaceDrawContext::drawTexture	(	const GrClip *	clip,
		GrSurfaceProxyView	view,
		SkAlphaType	srcAlphaType,
		GrSamplerState::Filter	filter,
		GrSamplerState::MipmapMode	mm,
		SkBlendMode	blendMode,
		const SkPMColor4f &	color,
		const SkRect &	srcRect,
		const SkRect &	dstRect,
		GrQuadAAFlags	edgeAA,
		SkCanvas::SrcRectConstraint	constraint,
		const SkMatrix &	viewMatrix,
		sk_sp< GrColorSpaceXform >	colorSpaceXform
	)

Creates an op that draws a subrectangle of a texture. The passed color is modulated by the texture's color. 'srcRect' specifies the rectangle of the texture to draw. 'dstRect' specifies the rectangle to draw in local coords which will be transformed by 'viewMatrix' to device space.

Definition at line 580 of file SurfaceDrawContext.cpp.

                                                                               {
    // If we are using dmsaa then go through FillRRectOp (via fillRectToRect).
    if ((this->alwaysAntialias() || this->caps()->reducedShaderMode()) &&
        edgeAA != GrQuadAAFlags::kNone) {
        auto [mustFilter, mustMM] = FilterAndMipmapHaveNoEffect(
                GrQuad::MakeFromRect(dstRect, viewMatrix), GrQuad(srcRect));
        if (!mustFilter) {
            // Chromeos-jacuzzi devices (ARM Mali-G72 MP3) have issues with blitting with linear
            // filtering. Likely some optimization or quantization causes fragments to be produced
            // with small offset/error. This will result in a slight blending of pixels when
            // sampling. Normally in most application this would be completely unnoticeable but when
            // trying to use the gpu as a per pixel blit we will end up with slightly blurry
            // results.
            // See https://crbug.com/326980863
            filter = GrSamplerState::Filter::kNearest;
        }
 
        GrPaint paint;
        paint.setColor4f(color);
        std::unique_ptr<GrFragmentProcessor> fp;
        if (constraint == SkCanvas::kStrict_SrcRectConstraint) {
            fp = GrTextureEffect::MakeSubset(view, srcAlphaType, SkMatrix::I(),
                                             GrSamplerState(filter, mm), srcRect,
                                             *this->caps());
        } else {
            fp = GrTextureEffect::Make(view, srcAlphaType, SkMatrix::I(), filter, mm);
        }
        if (colorSpaceXform) {
            fp = GrColorSpaceXformEffect::Make(std::move(fp), std::move(colorSpaceXform));
        }
        fp = GrBlendFragmentProcessor::Make<SkBlendMode::kModulate>(std::move(fp), nullptr);
        paint.setColorFragmentProcessor(std::move(fp));
        if (blendMode != SkBlendMode::kSrcOver) {
            paint.setXPFactory(GrXPFactory::FromBlendMode(blendMode));
        }
        this->fillRectToRect(clip, std::move(paint), GrAA::kYes, viewMatrix, dstRect, srcRect);
        return;
    }
 
    const SkRect* subset = constraint == SkCanvas::kStrict_SrcRectConstraint ?
            &srcRect : nullptr;
    DrawQuad quad{GrQuad::MakeFromRect(dstRect, viewMatrix), GrQuad(srcRect), edgeAA};
 
    this->drawTexturedQuad(clip, std::move(view), srcAlphaType, std::move(colorSpaceXform), filter,
                           mm, color, blendMode, &quad, subset);
}

◆ drawTextureQuad()

void skgpu::ganesh::SurfaceDrawContext::drawTextureQuad	(	const GrClip *	clip,
		GrSurfaceProxyView	view,
		GrColorType	srcColorType,
		SkAlphaType	srcAlphaType,
		GrSamplerState::Filter	filter,
		GrSamplerState::MipmapMode	mm,
		SkBlendMode	mode,
		const SkPMColor4f &	color,
		const SkPoint	srcQuad[4],
		const SkPoint	dstQuad[4],
		GrQuadAAFlags	edgeAA,
		const SkRect *	subset,
		const SkMatrix &	viewMatrix,
		sk_sp< GrColorSpaceXform >	texXform
	)

inline

Variant of drawTexture that instead draws the texture applied to 'dstQuad' transformed by 'viewMatrix', using the 'srcQuad' texture coordinates clamped to the optional 'subset'. If 'subset' is null, it's equivalent to using the fast src rect constraint. If 'subset' is provided, the strict src rect constraint is applied using 'subset'.

Definition at line 264 of file SurfaceDrawContext.h.

                                                            {
        DrawQuad quad{GrQuad::MakeFromSkQuad(dstQuad, viewMatrix),
                      GrQuad::MakeFromSkQuad(srcQuad, SkMatrix::I()), edgeAA};
        this->drawTexturedQuad(clip, std::move(view), srcAlphaType, std::move(texXform), filter, mm,
                               color, mode, &quad, subset);
    }

◆ drawTextureSet()

void skgpu::ganesh::SurfaceDrawContext::drawTextureSet	(	const GrClip *	clip,
		GrTextureSetEntry	set[],
		int	cnt,
		int	proxyRunCnt,
		GrSamplerState::Filter	filter,
		GrSamplerState::MipmapMode	mm,
		SkBlendMode	mode,
		SkCanvas::SrcRectConstraint	constraint,
		const SkMatrix &	viewMatrix,
		sk_sp< GrColorSpaceXform >	texXform
	)

Draws a set of textures with a shared filter, color, view matrix, color xform, and texture color xform. The textures must all have the same GrTextureType and GrConfig.

If any entries provide a non-null fDstClip array, it will be read from immediately based on fDstClipCount, so the pointer can become invalid after this returns.

'proxRunCnt' is the number of proxy changes encountered in the entry array. Technically this can be inferred from the array within this function, but the information is already known by SkGpuDevice, so no need to incur another iteration over the array.

Definition at line 899 of file SurfaceDrawContext.cpp.

                                                                           {
    ASSERT_SINGLE_OWNER
    RETURN_IF_ABANDONED
    SkDEBUGCODE(this->validate();)
    GR_CREATE_TRACE_MARKER_CONTEXT("SurfaceDrawContext", "drawTextureSet", fContext);
 
    // Create the minimum number of GrTextureOps needed to draw this set. Individual
    // GrTextureOps can rebind the texture between draws thus avoiding GrPaint (re)creation.
    AutoCheckFlush acf(this->drawingManager());
    GrAAType aaType = this->chooseAAType(GrAA::kYes);
    auto clampType = GrColorTypeClampType(this->colorInfo().colorType());
    auto saturate = clampType == GrClampType::kManual ? ganesh::TextureOp::Saturate::kYes
                                                      : ganesh::TextureOp::Saturate::kNo;
    ganesh::TextureOp::AddTextureSetOps(this, clip, fContext, set, cnt, proxyRunCnt, filter, mm,
                                        saturate, mode, aaType, constraint, viewMatrix,
                                        std::move(texXform));
}

◆ drawVertices()

void skgpu::ganesh::SurfaceDrawContext::drawVertices	(	const GrClip *	clip,
		GrPaint &&	paint,
		const SkMatrix &	viewMatrix,
		sk_sp< SkVertices >	vertices,
		GrPrimitiveType *	overridePrimType = `nullptr`,
		bool	skipColorXform = `false`
	)

Draws vertices with a paint.

Parameters

paint	describes how to color pixels.
viewMatrix	transformation matrix
vertices	specifies the mesh to draw.
overridePrimType	primitive type to draw. If NULL, derive prim type from vertices.
skipColorXform	if true, do not apply a color space transfer function

Definition at line 926 of file SurfaceDrawContext.cpp.

                                                           {
    ASSERT_SINGLE_OWNER
    RETURN_IF_ABANDONED
    SkDEBUGCODE(this->validate();)
    GR_CREATE_TRACE_MARKER_CONTEXT("SurfaceDrawContext", "drawVertices", fContext);
 
    AutoCheckFlush acf(this->drawingManager());
 
    SkASSERT(vertices);
    auto xform = skipColorXform ? nullptr : this->colorInfo().refColorSpaceXformFromSRGB();
    GrAAType aaType = fCanUseDynamicMSAA ? GrAAType::kMSAA : this->chooseAAType(GrAA::kNo);
    GrOp::Owner op = DrawMeshOp::Make(fContext,
                                      std::move(paint),
                                      std::move(vertices),
                                      overridePrimType,
                                      viewMatrix,
                                      aaType,
                                      std::move(xform));
    this->addDrawOp(clip, std::move(op));
}

◆ fillPixelsWithLocalMatrix()

void skgpu::ganesh::SurfaceDrawContext::fillPixelsWithLocalMatrix	(	const GrClip *	clip,
		GrPaint &&	paint,
		const SkIRect &	bounds,
		const SkMatrix &	localMatrix
	)

inline

Fills a block of pixels with a paint and a localMatrix, respecting the clip.

Definition at line 184 of file SurfaceDrawContext.h.

                                                                {
        SkRect rect = SkRect::Make(bounds);
        DrawQuad quad{GrQuad::MakeFromRect(rect, SkMatrix::I()),
                      GrQuad::MakeFromRect(rect, localMatrix), GrQuadAAFlags::kNone};
        this->drawFilledQuad(clip, std::move(paint), &quad);
    }

◆ fillQuadWithEdgeAA()

void skgpu::ganesh::SurfaceDrawContext::fillQuadWithEdgeAA	(	const GrClip *	clip,
		GrPaint &&	paint,
		GrQuadAAFlags	edgeAA,
		const SkMatrix &	viewMatrix,
		const SkPoint	points[4],
		const SkPoint	optionalLocalPoints[4]
	)

inline

Similar to fillRectWithEdgeAA but draws an arbitrary 2D convex quadrilateral transformed by 'viewMatrix', with per-edge control over anti-aliasing. The quad should follow the ordering used by SkRect::toQuad(), which determines how the edge AA is applied:

"top" = points [0] and [1]
"right" = points[1] and [2]
"bottom" = points[2] and [3]
"left" = points[3] and [0]

The last argument, 'optionalLocalQuad', can be null if no separate local coordinates are necessary.

Definition at line 225 of file SurfaceDrawContext.h.

                                                                  {
        const SkPoint* localPoints = optionalLocalPoints ? optionalLocalPoints : points;
        DrawQuad quad{GrQuad::MakeFromSkQuad(points, viewMatrix),
                      GrQuad::MakeFromSkQuad(localPoints, SkMatrix::I()), edgeAA};
        this->drawFilledQuad(clip, std::move(paint), &quad);
    }

◆ fillRectToRect()

void skgpu::ganesh::SurfaceDrawContext::fillRectToRect	(	const GrClip *	clip,
		GrPaint &&	paint,
		GrAA	aa,
		const SkMatrix &	viewMatrix,
		const SkRect &	rectToDraw,
		const SkRect &	localRect
	)

Maps a rectangle of shader coordinates to a rectangle and fills that rectangle.

Parameters

GrPaint	describes how to color pixels.
GrAA	Controls whether rect is antialiased
SkMatrix	transformation matrix which applies to rectToDraw
rectToDraw	the rectangle to draw
localRect	the rectangle of shader coordinates applied to rectToDraw

Definition at line 732 of file SurfaceDrawContext.cpp.

                                                                 {
    DrawQuad quad{GrQuad::MakeFromRect(rectToDraw, viewMatrix), GrQuad(localRect),
                  aa == GrAA::kYes ? GrQuadAAFlags::kAll : GrQuadAAFlags::kNone};
 
    // If we are using dmsaa then attempt to draw the rect with FillRRectOp.
    if ((fContext->priv().caps()->reducedShaderMode() || this->alwaysAntialias()) &&
        this->caps()->drawInstancedSupport()                                      &&
        aa == GrAA::kYes) {  // If aa is kNo when using dmsaa, the rect is axis aligned. Don't use
                             // FillRRectOp because it might require dual source blending.
                             // http://skbug.com/11756
        QuadOptimization opt = this->attemptQuadOptimization(clip, nullptr/*stencil*/, &quad,
                                                             &paint);
        if (opt < QuadOptimization::kClipApplied) {
            // The optimization was completely handled inside attempt().
            return;
        }
 
        SkRect croppedRect, croppedLocal{};
        const GrClip* optimizedClip = clip;
        if (clip && viewMatrix.isScaleTranslate() && quad.fDevice.asRect(&croppedRect) &&
            (!paint.usesLocalCoords() || quad.fLocal.asRect(&croppedLocal))) {
            // The cropped quad is still a rect, and our view matrix preserves rects. Map it back
            // to pre-matrix space.
            SkMatrix inverse;
            if (!viewMatrix.invert(&inverse)) {
                return;
            }
            SkASSERT(inverse.rectStaysRect());
            inverse.mapRect(&croppedRect);
            if (opt == QuadOptimization::kClipApplied) {
                optimizedClip = nullptr;
            }
        } else {
            // Even if attemptQuadOptimization gave us an optimized quad, FillRRectOp needs a rect
            // in pre-matrix space, so use the original rect. Also preserve the original clip.
            croppedRect = rectToDraw;
            croppedLocal = localRect;
        }
 
        if (auto op = FillRRectOp::Make(fContext, this->arenaAlloc(), std::move(paint),
                                        viewMatrix, SkRRect::MakeRect(croppedRect), croppedLocal,
                                        GrAA::kYes)) {
            this->addDrawOp(optimizedClip, std::move(op));
            return;
        }
    }
 
    assert_alive(paint);
    this->drawFilledQuad(clip, std::move(paint), &quad);
}

◆ fillRectWithEdgeAA()

void skgpu::ganesh::SurfaceDrawContext::fillRectWithEdgeAA	(	const GrClip *	clip,
		GrPaint &&	paint,
		GrQuadAAFlags	edgeAA,
		const SkMatrix &	viewMatrix,
		const SkRect &	rect,
		const SkRect *	optionalLocalRect = `nullptr`
	)

inline

Creates an op that draws a fill rect with per-edge control over anti-aliasing.

This is a specialized version of fillQuadWithEdgeAA, but is kept separate since knowing the geometry is a rectangle affords more optimizations.

Definition at line 200 of file SurfaceDrawContext.h.

                                                                       {
        if (edgeAA == GrQuadAAFlags::kAll) {
            this->fillRectToRect(clip, std::move(paint), GrAA::kYes, viewMatrix, rect,
                                 (optionalLocalRect) ? *optionalLocalRect : rect);
            return;
        }
        const SkRect& localRect = optionalLocalRect ? *optionalLocalRect : rect;
        DrawQuad quad{GrQuad::MakeFromRect(rect, viewMatrix), GrQuad(localRect), edgeAA};
        this->drawFilledQuad(clip, std::move(paint), &quad);
    }

◆ isBudgeted()

skgpu::Budgeted skgpu::ganesh::SurfaceDrawContext::isBudgeted ( ) const

Definition at line 1659 of file SurfaceDrawContext.cpp.

                                                   {
    ASSERT_SINGLE_OWNER
 
    if (fContext->abandoned()) {
        return skgpu::Budgeted::kNo;
    }
 
    SkDEBUGCODE(this->validate();)
 
    return this->asSurfaceProxy()->isBudgeted();
}

◆ Make() [1/3]

std::unique_ptr< SurfaceDrawContext > skgpu::ganesh::SurfaceDrawContext::Make	(	GrRecordingContext *	rContext,
		GrColorType	colorType,
		sk_sp< GrSurfaceProxy >	proxy,
		sk_sp< SkColorSpace >	colorSpace,
		GrSurfaceOrigin	origin,
		const SkSurfaceProps &	surfaceProps
	)

static

Definition at line 131 of file SurfaceDrawContext.cpp.

                                                                                                 {
    if (!rContext || !proxy || colorType == GrColorType::kUnknown) {
        return nullptr;
    }
 
    const GrBackendFormat& format = proxy->backendFormat();
    skgpu::Swizzle readSwizzle = rContext->priv().caps()->getReadSwizzle(format, colorType);
    skgpu::Swizzle writeSwizzle = rContext->priv().caps()->getWriteSwizzle(format, colorType);
 
    GrSurfaceProxyView readView (          proxy,  origin, readSwizzle);
    GrSurfaceProxyView writeView(std::move(proxy), origin, writeSwizzle);
 
    return std::make_unique<SurfaceDrawContext>(rContext,
                                                std::move(readView),
                                                std::move(writeView),
                                                colorType,
                                                std::move(colorSpace),
                                                surfaceProps);
}

◆ Make() [2/3]

std::unique_ptr< SurfaceDrawContext > skgpu::ganesh::SurfaceDrawContext::Make	(	GrRecordingContext *	rContext,
		GrColorType	colorType,
		sk_sp< SkColorSpace >	colorSpace,
		SkBackingFit	fit,
		SkISize	dimensions,
		const SkSurfaceProps &	surfaceProps,
		std::string_view	label,
		int	sampleCnt = `1`,
		skgpu::Mipmapped	mipmapped = `skgpu::Mipmapped::kNo`,
		skgpu::Protected	isProtected = `skgpu::Protected::kNo`,
		GrSurfaceOrigin	origin = `kBottomLeft_GrSurfaceOrigin`,
		skgpu::Budgeted	budgeted = `skgpu::Budgeted::kYes`
	)

static

Definition at line 205 of file SurfaceDrawContext.cpp.

                                                                                     {
    if (!rContext) {
        return nullptr;
    }
 
    auto format = rContext->priv().caps()->getDefaultBackendFormat(colorType, GrRenderable::kYes);
    if (!format.isValid()) {
        return nullptr;
    }
    sk_sp<GrTextureProxy> proxy = rContext->priv().proxyProvider()->createProxy(
            format,
            dimensions,
            GrRenderable::kYes,
            sampleCnt,
            mipmapped,
            fit,
            budgeted,
            isProtected,
            label);
    if (!proxy) {
        return nullptr;
    }
 
    return SurfaceDrawContext::Make(rContext,
                                    colorType,
                                    std::move(proxy),
                                    std::move(colorSpace),
                                    origin,
                                    surfaceProps);
}

◆ Make() [3/3]

std::unique_ptr< SurfaceDrawContext > skgpu::ganesh::SurfaceDrawContext::Make	(	GrRecordingContext *	rContext,
		sk_sp< SkColorSpace >	colorSpace,
		SkBackingFit	fit,
		SkISize	dimensions,
		const GrBackendFormat &	format,
		int	sampleCnt,
		skgpu::Mipmapped	mipmapped,
		skgpu::Protected	isProtected,
		skgpu::Swizzle	readSwizzle,
		skgpu::Swizzle	writeSwizzle,
		GrSurfaceOrigin	origin,
		skgpu::Budgeted	budgeted,
		const SkSurfaceProps &	surfaceProps,
		std::string_view	label
	)

static

Takes custom swizzles rather than determining swizzles from color type and format. It will have color type kUnknown.

Definition at line 156 of file SurfaceDrawContext.cpp.

                                                                                   {
    // It is probably not necessary to check if the context is abandoned here since uses of the
    // SurfaceDrawContext which need the context will mostly likely fail later on without an
    // issue. However having this hear adds some reassurance in case there is a path doesn't handle
    // an abandoned context correctly. It also lets us early out of some extra work.
    if (rContext->abandoned()) {
        return nullptr;
    }
 
    sk_sp<GrTextureProxy> proxy = rContext->priv().proxyProvider()->createProxy(
            format,
            dimensions,
            GrRenderable::kYes,
            sampleCnt,
            mipmapped,
            fit,
            budgeted,
            isProtected,
            label);
    if (!proxy) {
        return nullptr;
    }
 
    GrSurfaceProxyView readView (           proxy, origin,  readSwizzle);
    GrSurfaceProxyView writeView(std::move(proxy), origin, writeSwizzle);
 
    auto sdc = std::make_unique<SurfaceDrawContext>(rContext,
                                                    std::move(readView),
                                                    std::move(writeView),
                                                    GrColorType::kUnknown,
                                                    std::move(colorSpace),
                                                    surfaceProps);
    sdc->discard();
    return sdc;
}

◆ MakeFromBackendTexture()

std::unique_ptr< SurfaceDrawContext > skgpu::ganesh::SurfaceDrawContext::MakeFromBackendTexture	(	GrRecordingContext *	rContext,
		GrColorType	colorType,
		sk_sp< SkColorSpace >	colorSpace,
		const GrBackendTexture &	tex,
		int	sampleCnt,
		GrSurfaceOrigin	origin,
		const SkSurfaceProps &	surfaceProps,
		sk_sp< skgpu::RefCntedCallback >	releaseHelper
	)

static

Definition at line 269 of file SurfaceDrawContext.cpp.

                                                    {
    SkASSERT(sampleCnt > 0);
    sk_sp<GrTextureProxy> proxy(rContext->priv().proxyProvider()->wrapRenderableBackendTexture(
            tex, sampleCnt, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo,
            std::move(releaseHelper)));
    if (!proxy) {
        return nullptr;
    }
 
    return SurfaceDrawContext::Make(rContext, colorType, std::move(proxy), std::move(colorSpace),
                                    origin, surfaceProps);
}

◆ MakeWithFallback()

std::unique_ptr< SurfaceDrawContext > skgpu::ganesh::SurfaceDrawContext::MakeWithFallback	(	GrRecordingContext *	rContext,
		GrColorType	colorType,
		sk_sp< SkColorSpace >	colorSpace,
		SkBackingFit	fit,
		SkISize	dimensions,
		const SkSurfaceProps &	surfaceProps,
		int	sampleCnt,
		skgpu::Mipmapped	mipmapped,
		skgpu::Protected	isProtected,
		GrSurfaceOrigin	origin = `kBottomLeft_GrSurfaceOrigin`,
		skgpu::Budgeted	budgeted = `skgpu::Budgeted::kYes`
	)

static

Definition at line 247 of file SurfaceDrawContext.cpp.

                                {
    const GrCaps* caps = rContext->priv().caps();
    auto [ct, _] = caps->getFallbackColorTypeAndFormat(colorType, sampleCnt);
    if (ct == GrColorType::kUnknown) {
        return nullptr;
    }
    return SurfaceDrawContext::Make(rContext, ct, colorSpace, fit, dimensions, surfaceProps,
                                    /*label=*/"MakeSurfaceDrawContextWithFallback", sampleCnt,
                                    mipmapped, isProtected, origin, budgeted);
}

◆ maxWindowRectangles()

int skgpu::ganesh::SurfaceDrawContext::maxWindowRectangles ( ) const

Definition at line 799 of file SurfaceDrawContext.cpp.

                                                  {
    return this->asRenderTargetProxy()->maxWindowRectangles(*this->caps());
}

◆ mustRenderClip()

bool skgpu::ganesh::SurfaceDrawContext::mustRenderClip	(	uint32_t	clipStackGenID,
		const SkIRect &	devClipBounds,
		int	numClipAnalyticElements
	)

Definition at line 1501 of file SurfaceDrawContext.cpp.

                                                                     {
    auto opsTask = this->getOpsTask();
    return opsTask->fLastClipStackGenID != clipStackGenID ||
           !opsTask->fLastDevClipBounds.contains(devClipBounds) ||
           opsTask->fLastClipNumAnalyticElements != numClipAnalyticElements;
}

◆ numSamples()

int skgpu::ganesh::SurfaceDrawContext::numSamples ( ) const

inline

Definition at line 591 of file SurfaceDrawContext.h.

591{ return this->asRenderTargetProxy()->numSamples(); }

GrRenderTargetProxy::numSamples

int numSamples() const

Definition GrRenderTargetProxy.h:87

◆ refsWrappedObjects()

bool skgpu::ganesh::SurfaceDrawContext::refsWrappedObjects ( ) const

inline

Definition at line 582 of file SurfaceDrawContext.h.

582{ return this->asRenderTargetProxy()->refsWrappedObjects(); }

GrRenderTargetProxy::refsWrappedObjects

bool refsWrappedObjects() const

Definition GrRenderTargetProxy.cpp:158

◆ setLastClip()

void skgpu::ganesh::SurfaceDrawContext::setLastClip	(	uint32_t	clipStackGenID,
		const SkIRect &	devClipBounds,
		int	numClipAnalyticElements
	)

Definition at line 1492 of file SurfaceDrawContext.cpp.

                                                                  {
    auto opsTask = this->getOpsTask();
    opsTask->fLastClipStackGenID = clipStackGenID;
    opsTask->fLastDevClipBounds = devClipBounds;
    opsTask->fLastClipNumAnalyticElements = numClipAnalyticElements;
}

◆ stencilPath()

bool skgpu::ganesh::SurfaceDrawContext::stencilPath	(	const GrHardClip *	clip,
		GrAA	doStencilMSAA,
		const SkMatrix &	viewMatrix,
		const SkPath &	path
	)

Definition at line 861 of file SurfaceDrawContext.cpp.

                                                         {
    SkIRect clipBounds = clip ? clip->getConservativeBounds()
                              : SkIRect::MakeSize(this->dimensions());
    GrStyledShape shape(path, GrStyledShape::DoSimplify::kNo);
 
    PathRenderer::CanDrawPathArgs canDrawArgs;
    canDrawArgs.fCaps = fContext->priv().caps();
    canDrawArgs.fProxy = this->asRenderTargetProxy();
    canDrawArgs.fClipConservativeBounds = &clipBounds;
    canDrawArgs.fViewMatrix = &viewMatrix;
    canDrawArgs.fShape = &shape;
    canDrawArgs.fPaint = nullptr;
    canDrawArgs.fSurfaceProps = &fSurfaceProps;
    canDrawArgs.fAAType = (doStencilMSAA == GrAA::kYes) ? GrAAType::kMSAA : GrAAType::kNone;
    canDrawArgs.fHasUserStencilSettings = false;
    auto pr = this->drawingManager()->getPathRenderer(canDrawArgs,
                                                      false,
                                                      PathRendererChain::DrawType::kStencil);
    if (!pr) {
        SkDebugf("WARNING: No path renderer to stencil path.\n");
        return false;
    }
 
    PathRenderer::StencilPathArgs args;
    args.fContext = fContext;
    args.fSurfaceDrawContext = this;
    args.fClip = clip;
    args.fClipConservativeBounds = &clipBounds;
    args.fViewMatrix = &viewMatrix;
    args.fShape = &shape;
    args.fDoStencilMSAA = doStencilMSAA;
    pr->stencilPath(args);
    return true;
}

◆ stencilRect()

void skgpu::ganesh::SurfaceDrawContext::stencilRect	(	const GrClip *	clip,
		const GrUserStencilSettings *	ss,
		GrPaint &&	paint,
		GrAA	doStencilMSAA,
		const SkMatrix &	viewMatrix,
		const SkRect &	rect,
		const SkMatrix *	localMatrix = `nullptr`
	)

inline

Definition at line 524 of file SurfaceDrawContext.h.

                                                            {
        // Since this provides stencil settings to drawFilledQuad, it performs a different AA type
        // resolution compared to regular rect draws, which is the main reason it remains separate.
        DrawQuad quad{GrQuad::MakeFromRect(rect, viewMatrix),
                      localMatrix ? GrQuad::MakeFromRect(rect, *localMatrix) : GrQuad(rect),
                      doStencilMSAA == GrAA::kYes ? GrQuadAAFlags::kAll : GrQuadAAFlags::kNone};
        this->drawFilledQuad(clip, std::move(paint), &quad, ss);
    }

◆ surfaceProps()

const SkSurfaceProps & skgpu::ganesh::SurfaceDrawContext::surfaceProps ( ) const

inline

Definition at line 592 of file SurfaceDrawContext.h.

592{ return fSurfaceProps; }

◆ uniqueID()

GrSurfaceProxy::UniqueID skgpu::ganesh::SurfaceDrawContext::uniqueID ( ) const

inline

Definition at line 567 of file SurfaceDrawContext.h.

567{ return this->asSurfaceProxy()->uniqueID(); }

GrSurfaceProxy::uniqueID

UniqueID uniqueID() const

Definition GrSurfaceProxy.h:221

◆ waitOnSemaphores()

bool skgpu::ganesh::SurfaceDrawContext::waitOnSemaphores	(	int	numSemaphores,
		const GrBackendSemaphore	waitSemaphores[],
		bool	deleteSemaphoresAfterWait
	)

The next time this SurfaceDrawContext is flushed, the gpu will wait on the passed in semaphores before executing any commands.

Definition at line 1510 of file SurfaceDrawContext.cpp.

                                                                          {
    ASSERT_SINGLE_OWNER
    RETURN_FALSE_IF_ABANDONED
    SkDEBUGCODE(this->validate();)
    GR_CREATE_TRACE_MARKER_CONTEXT("SurfaceDrawContext", "waitOnSemaphores", fContext);
 
    AutoCheckFlush acf(this->drawingManager());
 
    if (numSemaphores && !this->caps()->backendSemaphoreSupport()) {
        return false;
    }
 
    auto direct = fContext->asDirectContext();
    if (!direct) {
        return false;
    }
 
    auto resourceProvider = direct->priv().resourceProvider();
 
    GrWrapOwnership ownership =
            deleteSemaphoresAfterWait ? kAdopt_GrWrapOwnership : kBorrow_GrWrapOwnership;
 
    std::unique_ptr<std::unique_ptr<GrSemaphore>[]> grSemaphores(
            new std::unique_ptr<GrSemaphore>[numSemaphores]);
    for (int i = 0; i < numSemaphores; ++i) {
        grSemaphores[i] = resourceProvider->wrapBackendSemaphore(waitSemaphores[i],
                                                                 GrSemaphoreWrapType::kWillWait,
                                                                 ownership);
    }
    this->drawingManager()->newWaitRenderTask(this->asSurfaceProxyRef(), std::move(grSemaphores),
                                              numSemaphores);
    return true;
}

◆ willReplaceOpsTask()

void skgpu::ganesh::SurfaceDrawContext::willReplaceOpsTask	(	OpsTask *	prevTask,
		OpsTask *	nextTask
	)

overrideprivatevirtual

Override to be notified in subclass before the current ops task is replaced.

Reimplemented from skgpu::ganesh::SurfaceFillContext.

Definition at line 315 of file SurfaceDrawContext.cpp.

                                                                                {
    if (prevTask && fNeedsStencil) {
        // Store the stencil values in memory upon completion of fOpsTask.
        prevTask->setMustPreserveStencil();
        // Reload the stencil buffer content at the beginning of newOpsTask.
        // FIXME: Could the topo sort insert a task between these two that modifies the stencil
        // values?
        nextTask->setInitialStencilContent(OpsTask::StencilContent::kPreserved);
    }
#if GR_GPU_STATS && defined(GR_TEST_UTILS)
    if (fCanUseDynamicMSAA) {
        fContext->priv().dmsaaStats().fNumRenderPasses++;
    }
#endif
}

◆ wrapsVkSecondaryCB()

bool skgpu::ganesh::SurfaceDrawContext::wrapsVkSecondaryCB ( ) const

inline

Definition at line 594 of file SurfaceDrawContext.h.

594{ return this->asRenderTargetProxy()->wrapsVkSecondaryCB(); }

GrRenderTargetProxy::wrapsVkSecondaryCB

bool wrapsVkSecondaryCB() const

Definition GrRenderTargetProxy.h:93

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

third_party/skia/src/gpu/ganesh/SurfaceDrawContext.h
third_party/skia/src/gpu/ganesh/SurfaceDrawContext.cpp

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ WillAddOpFn

Member Enumeration Documentation

◆ QuadOptimization

Constructor & Destructor Documentation

◆ SurfaceDrawContext()

◆ ~SurfaceDrawContext()

Member Function Documentation

◆ accessRenderTarget()

◆ addDrawOp() [1/2]

◆ addDrawOp() [2/2]

◆ alwaysAntialias()

◆ canDiscardPreviousOpsOnFullClear()

◆ canUseDynamicMSAA()

◆ chooseAA()

◆ chooseAAType()

◆ clearStencilClip()

◆ drawAndStencilPath()

◆ drawArc()

◆ drawAtlas()

◆ drawDrawable()

◆ drawFastShadow()

◆ drawGlyphRunList()

◆ drawImageLattice()

◆ drawMesh()

◆ drawOval()

◆ drawPaint()

◆ drawPath()

◆ drawQuadSet()

◆ drawRect()

◆ drawRegion()

◆ drawRRect()

◆ drawShape()

◆ drawStrokedLine()

◆ drawTexture()

◆ drawTextureQuad()

◆ drawTextureSet()

◆ drawVertices()

◆ fillPixelsWithLocalMatrix()

◆ fillQuadWithEdgeAA()

◆ fillRectToRect()

◆ fillRectWithEdgeAA()

◆ isBudgeted()

◆ Make() [1/3]

◆ Make() [2/3]

◆ Make() [3/3]

◆ MakeFromBackendTexture()

◆ MakeWithFallback()

◆ maxWindowRectangles()

◆ mustRenderClip()

◆ numSamples()

◆ refsWrappedObjects()

◆ setLastClip()

◆ stencilPath()

◆ stencilRect()

◆ surfaceProps()

◆ uniqueID()

◆ waitOnSemaphores()

◆ willReplaceOpsTask()

◆ wrapsVkSecondaryCB()