GrFixedClip Class Reference

#include <GrFixedClip.h>

Inheritance diagram for GrFixedClip:

Public Member Functions
	GrFixedClip (const SkISize &rtDims)
	GrFixedClip (const SkISize &rtDims, const SkIRect &scissorRect)
const GrScissorState &	scissorState () const
bool	scissorEnabled () const
const SkIRect &	scissorRect () const
void	disableScissor ()
bool	setScissor (const SkIRect &irect)
bool	intersect (const SkIRect &irect)
const GrWindowRectsState &	windowRectsState () const
bool	hasWindowRectangles () const
void	disableWindowRectangles ()
void	setWindowRectangles (const GrWindowRectangles &windows, GrWindowRectsState::Mode mode)
SkIRect	getConservativeBounds () const final
Effect	apply (GrAppliedHardClip *, SkIRect *) const final
PreClipResult	preApply (const SkRect &drawBounds, GrAA aa) const final
virtual Effect	apply (GrAppliedHardClip *out, SkIRect *bounds) const =0
Public Member Functions inherited from GrClip
virtual	~GrClip ()
virtual SkIRect	getConservativeBounds () const =0
virtual Effect	apply (GrRecordingContext *, skgpu::ganesh::SurfaceDrawContext *, GrDrawOp *, GrAAType, GrAppliedClip *, SkRect *bounds) const =0
virtual PreClipResult	preApply (const SkRect &drawBounds, GrAA aa) const

Additional Inherited Members
Public Types inherited from GrClip
enum class	Effect { kClipped , kUnclipped , kClippedOut }
enum class	BoundsType { kExterior , kInterior }
Static Public Member Functions inherited from GrClip
static bool	IsInsideClip (const SkIRect &innerClipBounds, const SkRect &drawBounds, GrAA aa)
static bool	IsOutsideClip (const SkIRect &outerClipBounds, const SkRect &drawBounds, GrAA aa)
static SkIRect	GetPixelIBounds (const SkRect &bounds, GrAA aa, BoundsType mode=BoundsType::kExterior)
static bool	IsPixelAligned (const SkRect &rect)
Static Public Attributes inherited from GrClip
static constexpr SkScalar	kBoundsTolerance = 1e-3f
static constexpr SkScalar	kHalfPixelRoundingTolerance = 5e-2f

Detailed Description

Implements GrHardClip with scissor and window rectangles.

Definition at line 18 of file GrFixedClip.h.

Constructor & Destructor Documentation

GrFixedClip() [1/2]

GrFixedClip::GrFixedClip ( const SkISize &  rtDims )

inlineexplicit

Definition at line 20 of file GrFixedClip.h.

: fScissorState(rtDims) {}

GrFixedClip() [2/2]

GrFixedClip::GrFixedClip ( const SkISize &  rtDims, const SkIRect &  scissorRect  )

inline

Definition at line 21 of file GrFixedClip.h.

            : GrFixedClip(rtDims) {
        SkAssertResult(fScissorState.set(scissorRect));
    }

Member Function Documentation

apply()

GrClip::Effect GrFixedClip::apply ( GrAppliedHardClip *  out, SkIRect *  bounds  ) const

finalvirtual

Sets the appropriate hardware state modifications on GrAppliedHardClip that will implement the clip. On input 'bounds' is a conservative bounds of the draw that is to be clipped. After return 'bounds' has been intersected with a conservative bounds of the clip.

Implements GrHardClip.

Definition at line 34 of file GrFixedClip.cpp.

                                                                             {
    if (!SkIRect::Intersects(fScissorState.rect(), *bounds)) {
        return Effect::kClippedOut;
    }
 
    Effect effect = Effect::kUnclipped;
    if (fScissorState.enabled() && !fScissorState.rect().contains(*bounds)) {
        SkAssertResult(bounds->intersect(fScissorState.rect()));
        out->setScissor(*bounds);
        effect = Effect::kClipped;
    }
 
    if (fWindowRectsState.enabled()) {
        out->addWindowRectangles(fWindowRectsState);
        // We could iterate each window rectangle to check for intersection, but be conservative
        // and report that it's clipped
        effect = Effect::kClipped;
    }
 
    return effect;
}

disableScissor()

void GrFixedClip::disableScissor ( )

inline

Definition at line 31 of file GrFixedClip.h.

{ fScissorState.setDisabled(); }

disableWindowRectangles()

void GrFixedClip::disableWindowRectangles ( )

inline

Definition at line 43 of file GrFixedClip.h.

{ fWindowRectsState.setDisabled(); }

getConservativeBounds()

SkIRect GrFixedClip::getConservativeBounds ( ) const

finalvirtual

Compute a conservative pixel bounds restricted to the given render target dimensions. The returned bounds represent the limits of pixels that can be drawn; anything outside of the bounds will be entirely clipped out.

Implements GrClip.

Definition at line 12 of file GrFixedClip.cpp.

                                                 {
    return fScissorState.rect();
}

hasWindowRectangles()

bool GrFixedClip::hasWindowRectangles ( ) const

inline

Definition at line 41 of file GrFixedClip.h.

{ return fWindowRectsState.enabled(); }

intersect()

bool GrFixedClip::intersect ( const SkIRect &  irect )

inline

Definition at line 36 of file GrFixedClip.h.

                                                       {
        return fScissorState.intersect(irect);
    }

preApply()

GrClip::PreClipResult GrFixedClip::preApply ( const SkRect &  drawBounds, GrAA  aa  ) const

finalvirtual

Perform preliminary, conservative analysis on the draw bounds as if it were provided to apply(). The results of this are returned the PreClipResults struct, where 'result.fEffect' corresponds to what 'apply' would return. If this value is kUnclipped or kNoDraw, then it can be assumed that apply() would also always result in the same Effect.

If kClipped is returned, apply() may further refine the effect to kUnclipped or kNoDraw, with one exception. When 'result.fIsRRect' is true, preApply() reports the single round rect and anti-aliased state that would act as an intersection on the draw geometry. If no further action is taken to modify the draw, apply() will represent this round rect in the applied clip.

When set, 'result.fRRect' will intersect with the render target bounds but may extend beyond it. If the render target bounds are the only clip effect on the draw, this is reported as kUnclipped and not as a degenerate rrect that matches the bounds.

Reimplemented from GrClip.

Definition at line 16 of file GrFixedClip.cpp.

                                                                                 {
    SkIRect pixelBounds = GetPixelIBounds(drawBounds, aa);
    if (!SkIRect::Intersects(fScissorState.rect(), pixelBounds)) {
        return Effect::kClippedOut;
    }
 
    if (fWindowRectsState.enabled()) {
        return Effect::kClipped;
    }
 
    if (!fScissorState.enabled() || fScissorState.rect().contains(pixelBounds)) {
        // Either no scissor or the scissor doesn't clip the draw
        return Effect::kUnclipped;
    }
    // Report the scissor as a degenerate round rect
    return {SkRect::Make(fScissorState.rect()), GrAA::kNo};
}

scissorEnabled()

bool GrFixedClip::scissorEnabled ( ) const

inline

Definition at line 27 of file GrFixedClip.h.

{ return fScissorState.enabled(); }

scissorRect()

const SkIRect & GrFixedClip::scissorRect ( ) const

inline

Definition at line 29 of file GrFixedClip.h.

{ return fScissorState.rect(); }

scissorState()

const GrScissorState & GrFixedClip::scissorState ( ) const

inline

Definition at line 26 of file GrFixedClip.h.

{ return fScissorState; }

setScissor()

bool GrFixedClip::setScissor ( const SkIRect &  irect )

inline

Definition at line 33 of file GrFixedClip.h.

                                                        {
        return fScissorState.set(irect);
    }

setWindowRectangles()

void GrFixedClip::setWindowRectangles ( const GrWindowRectangles &  windows, GrWindowRectsState::Mode  mode  )

inline

Definition at line 45 of file GrFixedClip.h.

                                                                                             {
        fWindowRectsState.set(windows, mode);
    }

windowRectsState()

const GrWindowRectsState & GrFixedClip::windowRectsState ( ) const

inline

Definition at line 40 of file GrFixedClip.h.

{ return fWindowRectsState; }

---

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

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