GrOp Class Reference

#include <GrOp.h>

Inheritance diagram for GrOp:

Classes
class	ChainRange

Public Types
enum class	CombineResult { kMerged , kMayChain , kCannotCombine }
enum class	HasAABloat : bool { kNo = false , kYes = true }
enum class	IsHairline : bool { kNo = false , kYes = true }
using	Owner = std::unique_ptr< GrOp >

Public Member Functions
virtual	~GrOp ()=default
virtual const char *	name () const =0
virtual void	visitProxies (const GrVisitProxyFunc &) const
CombineResult	combineIfPossible (GrOp *that, SkArenaAlloc *alloc, const GrCaps &caps)
const SkRect &	bounds () const
void	setClippedBounds (const SkRect &clippedBounds)
bool	hasAABloat () const
bool	hasZeroArea () const
void	operator delete (void *p)
template<typename T >
const T &	cast () const
template<typename T >
T *	cast ()
uint32_t	classID () const
uint32_t	uniqueID () const
void	prePrepare (GrRecordingContext *context, const GrSurfaceProxyView &dstView, GrAppliedClip *clip, const GrDstProxyView &dstProxyView, GrXferBarrierFlags renderPassXferBarriers, GrLoadOp colorLoadOp)
void	prepare (GrOpFlushState *state)
void	execute (GrOpFlushState *state, const SkRect &chainBounds)
void	chainConcat (GrOp::Owner)
bool	isChainHead () const
bool	isChainTail () const
GrOp *	nextInChain () const
GrOp *	prevInChain () const
GrOp::Owner	cutChain ()
void	setBounds (const SkRect &newBounds, HasAABloat aabloat, IsHairline zeroArea)
void	setTransformedBounds (const SkRect &srcBounds, const SkMatrix &m, HasAABloat aabloat, IsHairline zeroArea)
void	makeFullScreen (GrSurfaceProxy *proxy)

Static Public Member Functions
template<typename Op , typename... Args>
static Owner	Make (GrRecordingContext *context, Args &&... args)
template<typename Op , typename... Args>
static Owner	MakeWithProcessorSet (GrRecordingContext *context, const SkPMColor4f &color, GrPaint &&paint, Args &&... args)
template<typename Op , typename... Args>
static Owner	MakeWithExtraMemory (GrRecordingContext *context, size_t extraSize, Args &&... args)
static uint32_t	GenOpClassID ()

Private Member Functions
virtual CombineResult	onCombineIfPossible (GrOp *, SkArenaAlloc *, const GrCaps &)
virtual void	onPrePrepare (GrRecordingContext *, const GrSurfaceProxyView &writeView, GrAppliedClip *, const GrDstProxyView &, GrXferBarrierFlags renderPassXferBarriers, GrLoadOp colorLoadOp)=0
virtual void	onPrepare (GrOpFlushState *)=0
virtual void	onExecute (GrOpFlushState *, const SkRect &chainBounds)=0

Detailed Description

Definition at line 70 of file GrOp.h.

Member Typedef Documentation

Owner

using GrOp::Owner = std::unique_ptr<GrOp>

Definition at line 72 of file GrOp.h.

Member Enumeration Documentation

CombineResult

enum class GrOp::CombineResult

strong

Enumerator
kMerged	The op that combineIfPossible was called on now represents its own work plus that of the passed op. The passed op should be destroyed without being flushed. Currently it is not legal to merge an op passed to combineIfPossible() the passed op is already in a chain (though the op on which combineIfPossible() was called may be).
kMayChain	The caller may (but is not required) to chain these ops together. If they are chained then prepare() and execute() will be called on the head op but not the other ops in the chain. The head op will prepare and execute on behalf of all the ops in the chain.
kCannotCombine	The ops cannot be combined.

Definition at line 99 of file GrOp.h.

                             {
        /**
         * The op that combineIfPossible was called on now represents its own work plus that of
         * the passed op. The passed op should be destroyed without being flushed. Currently it
         * is not legal to merge an op passed to combineIfPossible() the passed op is already in a
         * chain (though the op on which combineIfPossible() was called may be).
         */
        kMerged,
        /**
         * The caller *may* (but is not required) to chain these ops together. If they are chained
         * then prepare() and execute() will be called on the head op but not the other ops in the
         * chain. The head op will prepare and execute on behalf of all the ops in the chain.
         */
        kMayChain,
        /**
         * The ops cannot be combined.
         */
        kCannotCombine
    };

HasAABloat

enum class GrOp::HasAABloat : bool

strong

Indicates that the op will produce geometry that extends beyond its bounds for the purpose of ensuring that the fragment shader runs on partially covered pixels for non-MSAA antialiasing.

Enumerator
kNo
kYes

Definition at line 266 of file GrOp.h.

                          : bool {
        kNo = false,
        kYes = true
    };

IsHairline

enum class GrOp::IsHairline : bool

strong

Indicates that the geometry being drawn in a hairline stroke. A point that is drawn in device space is also considered a hairline.

Enumerator
kNo
kYes

Definition at line 274 of file GrOp.h.

                          : bool {
        kNo = false,
        kYes = true
    };

Constructor & Destructor Documentation

~GrOp()

virtual GrOp::~GrOp ( )

virtualdefault

Member Function Documentation

bounds()

const SkRect & GrOp::bounds ( ) const

inline

Definition at line 122 of file GrOp.h.

                                 {
        SkASSERT(kUninitialized_BoundsFlag != fBoundsFlags);
        return fBounds;
    }

cast() [1/2]

template<typename T >

T * GrOp::cast ( )

inline

Definition at line 153 of file GrOp.h.

                                    {
        SkASSERT(T::ClassID() == this->classID());
        return static_cast<T*>(this);
    }

cast() [2/2]

template<typename T >

const T & GrOp::cast ( ) const

inline

Helper for safely down-casting to a GrOp subclass

Definition at line 148 of file GrOp.h.

                                                {
        SkASSERT(T::ClassID() == this->classID());
        return *static_cast<const T*>(this);
    }

chainConcat()

void GrOp::chainConcat

(

GrOp::Owner

next

)

Concatenates two op chains. This op must be a tail and the passed op must be a head. The ops must be of the same subclass.

Definition at line 31 of file GrOp.cpp.

                                     {
    SkASSERT(next);
    SkASSERT(this->classID() == next->classID());
    SkASSERT(this->isChainTail());
    SkASSERT(next->isChainHead());
    fNextInChain = std::move(next);
    fNextInChain->fPrevInChain = this;
}

classID()

uint32_t GrOp::classID ( ) const

inline

Definition at line 158 of file GrOp.h.

{ SkASSERT(kIllegalOpID != fClassID); return fClassID; }

combineIfPossible()

GrOp::CombineResult GrOp::combineIfPossible	(	GrOp *	that,
		SkArenaAlloc *	alloc,
		const GrCaps &	caps
	)

Definition at line 19 of file GrOp.cpp.

                                                                                             {
    SkASSERT(this != that);
    if (this->classID() != that->classID()) {
        return CombineResult::kCannotCombine;
    }
    auto result = this->onCombineIfPossible(that, alloc, caps);
    if (result == CombineResult::kMerged) {
        this->joinBounds(*that);
    }
    return result;
}

cutChain()

GrOp::Owner GrOp::cutChain

(

)

Cuts the chain after this op. The returned op is the op that was previously next in the chain or null if this was already a tail.

Definition at line 40 of file GrOp.cpp.

                         {
    if (fNextInChain) {
        fNextInChain->fPrevInChain = nullptr;
        return std::move(fNextInChain);
    }
    return nullptr;
}

execute()

void GrOp::execute ( GrOpFlushState *  state, const SkRect &  chainBounds  )

inline

Issues the op's commands to GrGpu.

Definition at line 191 of file GrOp.h.

                                                                   {
        TRACE_EVENT0_ALWAYS("skia.gpu", TRACE_STR_STATIC(name()));
        this->onExecute(state, chainBounds);
    }

GenOpClassID()

static uint32_t GrOp::GenOpClassID ( )

inlinestatic

Definition at line 292 of file GrOp.h.

{ return GenID(&gCurrOpClassID); }

hasAABloat()

bool GrOp::hasAABloat ( ) const

inline

Definition at line 133 of file GrOp.h.

                            {
        SkASSERT(fBoundsFlags != kUninitialized_BoundsFlag);
        return SkToBool(fBoundsFlags & kAABloat_BoundsFlag);
    }

hasZeroArea()

bool GrOp::hasZeroArea ( ) const

inline

Definition at line 138 of file GrOp.h.

                             {
        SkASSERT(fBoundsFlags != kUninitialized_BoundsFlag);
        return SkToBool(fBoundsFlags & kZeroArea_BoundsFlag);
    }

isChainHead()

bool GrOp::isChainHead ( ) const

inline

Returns true if this is the head of a chain (including a length 1 chain).

Definition at line 240 of file GrOp.h.

{ return !fPrevInChain; }

isChainTail()

bool GrOp::isChainTail ( ) const

inline

Returns true if this is the tail of a chain (including a length 1 chain).

Definition at line 242 of file GrOp.h.

{ return !fNextInChain; }

Make()

template<typename Op , typename... Args>

static Owner GrOp::Make ( GrRecordingContext *  context, Args &&...  args  )

inlinestatic

Definition at line 75 of file GrOp.h.

                                                                   {
        return Owner{new Op(std::forward<Args>(args)...)};
    }

makeFullScreen()

void GrOp::makeFullScreen ( GrSurfaceProxy *  proxy )

inline

Definition at line 288 of file GrOp.h.

                                               {
        this->setBounds(proxy->getBoundsRect(), HasAABloat::kNo, IsHairline::kNo);
    }

MakeWithExtraMemory()

template<typename Op , typename... Args>

static Owner GrOp::MakeWithExtraMemory ( GrRecordingContext *  context, size_t  extraSize, Args &&...  args  )

inlinestatic

Definition at line 85 of file GrOp.h.

                                                                           {
        void* bytes = ::operator new(sizeof(Op) + extraSize);
        return Owner{new (bytes) Op(std::forward<Args>(args)...)};
    }

MakeWithProcessorSet()

template<typename Op , typename... Args>

GrOp::Owner GrOp::MakeWithProcessorSet ( GrRecordingContext *  context, const SkPMColor4f &  color, GrPaint &&  paint, Args &&...  args  )

static

Definition at line 197 of file GrSimpleMeshDrawOpHelper.h.

                                         {
    char* bytes = (char*)::operator new(sizeof(Op) + sizeof(GrProcessorSet));
    char* setMem = bytes + sizeof(Op);
    GrProcessorSet* processorSet = new (setMem) GrProcessorSet{std::move(paint)};
    return Owner{new (bytes) Op(processorSet, color, std::forward<Args>(args)...)};
}

name()

virtual const char * GrOp::name ( ) const

pure virtual

Implemented in skiagm::BezierConicTestOp, skiagm::BezierQuadTestOp, skgpu::ganesh::AtlasTextOp, skgpu::ganesh::ClearOp, skgpu::ganesh::DrawableOp, skgpu::ganesh::DrawAtlasPathOp, CircleOp, ButtCapDashedCircleOp, EllipseOp, DIEllipseOp, CircularRRectOp, EllipticalRRectOp, skgpu::ganesh::PathInnerTriangulateOp, skgpu::ganesh::PathStencilCoverOp, skgpu::ganesh::PathTessellateOp, skgpu::ganesh::StrokeTessellateOp, TestVertexOp, GrThreadSafeVertexTestOp, LazyProxyTest::Op, and LazyFailedInstantiationTestOp.

nextInChain()

GrOp * GrOp::nextInChain ( ) const

inline

The next op in the chain.

Definition at line 244 of file GrOp.h.

{ return fNextInChain.get(); }

onCombineIfPossible()

virtual CombineResult GrOp::onCombineIfPossible ( GrOp *  , SkArenaAlloc *  , const GrCaps &    )

inlineprivatevirtual

Reimplemented in skgpu::ganesh::DrawAtlasPathOp, skgpu::ganesh::PathTessellateOp, skgpu::ganesh::StrokeTessellateOp, skgpu::ganesh::AtlasTextOp, skgpu::ganesh::ClearOp, CircleOp, ButtCapDashedCircleOp, EllipseOp, DIEllipseOp, CircularRRectOp, EllipticalRRectOp, and skgpu::ganesh::DrawableOp.

Definition at line 305 of file GrOp.h.

                                                                                   {
        return CombineResult::kCannotCombine;
    }

onExecute()

virtual void GrOp::onExecute ( GrOpFlushState *  , const SkRect &  chainBounds  )

privatepure virtual

Implemented in skgpu::ganesh::AtlasTextOp, skgpu::ganesh::DrawableOp, skgpu::ganesh::DrawAtlasPathOp, skgpu::ganesh::PathInnerTriangulateOp, skgpu::ganesh::PathStencilCoverOp, skgpu::ganesh::PathTessellateOp, skgpu::ganesh::StrokeTessellateOp, LazyProxyTest::Op, skiagm::BezierTestOp, CircleOp, ButtCapDashedCircleOp, EllipseOp, DIEllipseOp, CircularRRectOp, EllipticalRRectOp, TestVertexOp, GrThreadSafeVertexTestOp, skgpu::ganesh::ClearOp, and LazyFailedInstantiationTestOp.

onPrepare()

virtual void GrOp::onPrepare ( GrOpFlushState *  )

privatepure virtual

Implemented in skgpu::ganesh::ClearOp, skgpu::ganesh::DrawableOp, skgpu::ganesh::DrawAtlasPathOp, skgpu::ganesh::PathInnerTriangulateOp, skgpu::ganesh::PathStencilCoverOp, skgpu::ganesh::PathTessellateOp, skgpu::ganesh::StrokeTessellateOp, LazyProxyTest::Op, LazyFailedInstantiationTestOp, GrThreadSafeVertexTestOp, and GrMeshDrawOp.

onPrePrepare()

virtual void GrOp::onPrePrepare ( GrRecordingContext *  , const GrSurfaceProxyView &  writeView, GrAppliedClip *  , const GrDstProxyView &  , GrXferBarrierFlags  renderPassXferBarriers, GrLoadOp  colorLoadOp  )

privatepure virtual

Implemented in skgpu::ganesh::PathInnerTriangulateOp, skgpu::ganesh::PathStencilCoverOp, skgpu::ganesh::PathTessellateOp, skgpu::ganesh::StrokeTessellateOp, skgpu::ganesh::ClearOp, skgpu::ganesh::DrawableOp, LazyProxyTest::Op, LazyFailedInstantiationTestOp, skgpu::ganesh::DrawAtlasPathOp, GrMeshDrawOp, and GrThreadSafeVertexTestOp.

operator delete()

void GrOp::operator delete ( void *  p )

inline

Definition at line 143 of file GrOp.h.

{ ::operator delete(p); }

prepare()

void GrOp::prepare ( GrOpFlushState *  state )

inline

Called prior to executing. The op should perform any resource creation or data transfers necessary before execute() is called.

Definition at line 185 of file GrOp.h.

                                        {
        TRACE_EVENT0_ALWAYS("skia.gpu", TRACE_STR_STATIC(name()));
        this->onPrepare(state);
    }

prePrepare()

void GrOp::prePrepare ( GrRecordingContext *  context, const GrSurfaceProxyView &  dstView, GrAppliedClip *  clip, const GrDstProxyView &  dstProxyView, GrXferBarrierFlags  renderPassXferBarriers, GrLoadOp  colorLoadOp  )

inline

This can optionally be called before 'prepare' (but after sorting). Each op that overrides onPrePrepare must be prepared to handle both cases (when onPrePrepare has been called ahead of time and when it has not been called).

Definition at line 173 of file GrOp.h.

                                                                                     {
        TRACE_EVENT0_ALWAYS("skia.gpu", TRACE_STR_STATIC(name()));
        this->onPrePrepare(context, dstView, clip, dstProxyView, renderPassXferBarriers,
                           colorLoadOp);
    }

prevInChain()

GrOp * GrOp::prevInChain ( ) const

inline

The previous op in the chain.

Definition at line 246 of file GrOp.h.

{ return fPrevInChain; }

setBounds()

void GrOp::setBounds ( const SkRect &  newBounds, HasAABloat  aabloat, IsHairline  zeroArea  )

inline

Definition at line 279 of file GrOp.h.

                                                                                     {
        fBounds = newBounds;
        this->setBoundsFlags(aabloat, zeroArea);
    }

setClippedBounds()

void GrOp::setClippedBounds ( const SkRect &  clippedBounds )

inline

Definition at line 127 of file GrOp.h.

                                                       {
        fBounds = clippedBounds;
        // The clipped bounds already incorporate any effect of the bounds flags.
        fBoundsFlags = 0;
    }

setTransformedBounds()

void GrOp::setTransformedBounds ( const SkRect &  srcBounds, const SkMatrix &  m, HasAABloat  aabloat, IsHairline  zeroArea  )

inline

Definition at line 283 of file GrOp.h.

                                                                       {
        m.mapRect(&fBounds, srcBounds);
        this->setBoundsFlags(aabloat, zeroArea);
    }

uniqueID()

uint32_t GrOp::uniqueID ( ) const

inline

Definition at line 161 of file GrOp.h.

                              {
        if (kIllegalOpID == fUniqueID) {
            fUniqueID = GenOpID();
        }
        return fUniqueID;
    }

visitProxies()

virtual void GrOp::visitProxies ( const GrVisitProxyFunc &  ) const

inlinevirtual

Reimplemented in skgpu::ganesh::AtlasTextOp, skgpu::ganesh::PathInnerTriangulateOp, skgpu::ganesh::PathStencilCoverOp, skgpu::ganesh::PathTessellateOp, skgpu::ganesh::StrokeTessellateOp, skiagm::BezierTestOp, skgpu::ganesh::DrawAtlasPathOp, CircleOp, ButtCapDashedCircleOp, EllipseOp, DIEllipseOp, CircularRRectOp, EllipticalRRectOp, TestVertexOp, LazyProxyTest::Op, and LazyFailedInstantiationTestOp.

Definition at line 95 of file GrOp.h.

                                                             {
        // This default implementation assumes the op has no proxies
    }

---

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

• third_party/skia/src/gpu/ganesh/ops/GrOp.h
• third_party/skia/src/gpu/ganesh/ops/GrOp.cpp
• third_party/skia/src/gpu/ganesh/ops/GrSimpleMeshDrawOpHelper.h