joshualitt | 44701df | 2015-02-23 14:44:57 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2010 Google Inc. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
| 7 | |
| 8 | #ifndef GrClip_DEFINED |
| 9 | #define GrClip_DEFINED |
| 10 | |
Chris Dalton | bbfd516 | 2017-11-07 13:35:22 -0700 | [diff] [blame] | 11 | #include "GrAppliedClip.h" |
| 12 | #include "GrRenderTargetContext.h" |
csmartdalton | 02fa32c | 2016-08-19 13:29:27 -0700 | [diff] [blame] | 13 | #include "SkRRect.h" |
Brian Salomon | c65aec9 | 2017-03-09 09:03:58 -0500 | [diff] [blame] | 14 | #include "SkRect.h" |
joshualitt | 44701df | 2015-02-23 14:44:57 -0800 | [diff] [blame] | 15 | |
csmartdalton | 02fa32c | 2016-08-19 13:29:27 -0700 | [diff] [blame] | 16 | class GrContext; |
joshualitt | 44701df | 2015-02-23 14:44:57 -0800 | [diff] [blame] | 17 | |
| 18 | /** |
cdalton | 846c051 | 2016-05-13 10:25:00 -0700 | [diff] [blame] | 19 | * GrClip is an abstract base class for applying a clip. It constructs a clip mask if necessary, and |
| 20 | * fills out a GrAppliedClip instructing the caller on how to set up the draw state. |
| 21 | */ |
| 22 | class GrClip { |
| 23 | public: |
| 24 | virtual bool quickContains(const SkRect&) const = 0; |
bsalomon | 7f0d9f3 | 2016-08-15 14:49:10 -0700 | [diff] [blame] | 25 | virtual bool quickContains(const SkRRect& rrect) const { |
| 26 | return this->quickContains(rrect.getBounds()); |
| 27 | } |
cdalton | 846c051 | 2016-05-13 10:25:00 -0700 | [diff] [blame] | 28 | virtual void getConservativeBounds(int width, int height, SkIRect* devResult, |
| 29 | bool* isIntersectionOfRects = nullptr) const = 0; |
Brian Salomon | 97180af | 2017-03-14 13:42:58 -0400 | [diff] [blame] | 30 | /** |
| 31 | * This computes a GrAppliedClip from the clip which in turn can be used to build a GrPipeline. |
| 32 | * To determine the appropriate clipping implementation the GrClip subclass must know whether |
| 33 | * the draw will enable HW AA or uses the stencil buffer. On input 'bounds' is a conservative |
| 34 | * bounds of the draw that is to be clipped. After return 'bounds' has been intersected with a |
| 35 | * conservative bounds of the clip. A return value of false indicates that the draw can be |
| 36 | * skipped as it is fully clipped out. |
| 37 | */ |
Robert Phillips | 6f0e02f | 2019-02-13 11:02:28 -0500 | [diff] [blame] | 38 | virtual bool apply(GrRecordingContext*, GrRenderTargetContext*, bool useHWAA, |
Chris Dalton | bbfd516 | 2017-11-07 13:35:22 -0700 | [diff] [blame] | 39 | bool hasUserStencilSettings, GrAppliedClip*, SkRect* bounds) const = 0; |
cdalton | 846c051 | 2016-05-13 10:25:00 -0700 | [diff] [blame] | 40 | |
| 41 | virtual ~GrClip() {} |
csmartdalton | 97f6cd5 | 2016-07-13 13:37:08 -0700 | [diff] [blame] | 42 | |
csmartdalton | 97f6cd5 | 2016-07-13 13:37:08 -0700 | [diff] [blame] | 43 | /** |
bsalomon | cb31e51 | 2016-08-26 10:48:19 -0700 | [diff] [blame] | 44 | * This method quickly and conservatively determines whether the entire clip is equivalent to |
| 45 | * intersection with a rrect. This will only return true if the rrect does not fully contain |
| 46 | * the render target bounds. Moreover, the returned rrect need not be contained by the render |
| 47 | * target bounds. We assume all draws will be implicitly clipped by the render target bounds. |
| 48 | * |
| 49 | * @param rtBounds The bounds of the render target that the clip will be applied to. |
| 50 | * @param rrect If return is true rrect will contain the rrect equivalent to the clip within |
| 51 | * rtBounds. |
| 52 | * @param aa If return is true aa will indicate whether the rrect clip is antialiased. |
| 53 | * @return true if the clip is equivalent to a single rrect, false otherwise. |
| 54 | * |
| 55 | */ |
Brian Salomon | 0e8fc8b | 2016-12-09 15:10:07 -0500 | [diff] [blame] | 56 | virtual bool isRRect(const SkRect& rtBounds, SkRRect* rrect, GrAA* aa) const = 0; |
bsalomon | cb31e51 | 2016-08-26 10:48:19 -0700 | [diff] [blame] | 57 | |
| 58 | /** |
csmartdalton | cbecb08 | 2016-07-22 08:59:08 -0700 | [diff] [blame] | 59 | * This is the maximum distance that a draw may extend beyond a clip's boundary and still count |
| 60 | * count as "on the other side". We leave some slack because floating point rounding error is |
| 61 | * likely to blame. The rationale for 1e-3 is that in the coverage case (and barring unexpected |
| 62 | * rounding), as long as coverage stays within 0.5 * 1/256 of its intended value it shouldn't |
| 63 | * have any effect on the final pixel values. |
csmartdalton | 97f6cd5 | 2016-07-13 13:37:08 -0700 | [diff] [blame] | 64 | */ |
csmartdalton | cbecb08 | 2016-07-22 08:59:08 -0700 | [diff] [blame] | 65 | constexpr static SkScalar kBoundsTolerance = 1e-3f; |
| 66 | |
| 67 | /** |
| 68 | * Returns true if the given query bounds count as entirely inside the clip. |
| 69 | * |
| 70 | * @param innerClipBounds device-space rect contained by the clip (SkRect or SkIRect). |
| 71 | * @param queryBounds device-space bounds of the query region. |
| 72 | */ |
Brian Salomon | c65aec9 | 2017-03-09 09:03:58 -0500 | [diff] [blame] | 73 | template <typename TRect> |
| 74 | constexpr static bool IsInsideClip(const TRect& innerClipBounds, const SkRect& queryBounds) { |
Jim Van Verth | ba7cf29 | 2017-11-02 20:18:56 +0000 | [diff] [blame] | 75 | return innerClipBounds.fRight > innerClipBounds.fLeft + kBoundsTolerance && |
| 76 | innerClipBounds.fBottom > innerClipBounds.fTop + kBoundsTolerance && |
csmartdalton | 77f2fae | 2016-08-08 09:55:06 -0700 | [diff] [blame] | 77 | innerClipBounds.fLeft < queryBounds.fLeft + kBoundsTolerance && |
| 78 | innerClipBounds.fTop < queryBounds.fTop + kBoundsTolerance && |
| 79 | innerClipBounds.fRight > queryBounds.fRight - kBoundsTolerance && |
| 80 | innerClipBounds.fBottom > queryBounds.fBottom - kBoundsTolerance; |
csmartdalton | 97f6cd5 | 2016-07-13 13:37:08 -0700 | [diff] [blame] | 81 | } |
| 82 | |
csmartdalton | cbecb08 | 2016-07-22 08:59:08 -0700 | [diff] [blame] | 83 | /** |
| 84 | * Returns true if the given query bounds count as entirely outside the clip. |
| 85 | * |
| 86 | * @param outerClipBounds device-space rect that contains the clip (SkRect or SkIRect). |
| 87 | * @param queryBounds device-space bounds of the query region. |
| 88 | */ |
Brian Salomon | c65aec9 | 2017-03-09 09:03:58 -0500 | [diff] [blame] | 89 | template <typename TRect> |
| 90 | constexpr static bool IsOutsideClip(const TRect& outerClipBounds, const SkRect& queryBounds) { |
Chris Dalton | 348060f | 2017-06-05 13:15:37 -0600 | [diff] [blame] | 91 | return |
| 92 | // Is the clip so small that it is effectively empty? |
| 93 | outerClipBounds.fRight - outerClipBounds.fLeft <= kBoundsTolerance || |
| 94 | outerClipBounds.fBottom - outerClipBounds.fTop <= kBoundsTolerance || |
| 95 | |
| 96 | // Are the query bounds effectively outside the clip? |
| 97 | outerClipBounds.fLeft >= queryBounds.fRight - kBoundsTolerance || |
| 98 | outerClipBounds.fTop >= queryBounds.fBottom - kBoundsTolerance || |
| 99 | outerClipBounds.fRight <= queryBounds.fLeft + kBoundsTolerance || |
| 100 | outerClipBounds.fBottom <= queryBounds.fTop + kBoundsTolerance; |
csmartdalton | cbecb08 | 2016-07-22 08:59:08 -0700 | [diff] [blame] | 101 | } |
| 102 | |
| 103 | /** |
| 104 | * Returns the minimal integer rect that counts as containing a given set of bounds. |
| 105 | */ |
| 106 | static SkIRect GetPixelIBounds(const SkRect& bounds) { |
| 107 | return SkIRect::MakeLTRB(SkScalarFloorToInt(bounds.fLeft + kBoundsTolerance), |
| 108 | SkScalarFloorToInt(bounds.fTop + kBoundsTolerance), |
| 109 | SkScalarCeilToInt(bounds.fRight - kBoundsTolerance), |
| 110 | SkScalarCeilToInt(bounds.fBottom - kBoundsTolerance)); |
| 111 | } |
| 112 | |
| 113 | /** |
| 114 | * Returns the minimal pixel-aligned rect that counts as containing a given set of bounds. |
| 115 | */ |
| 116 | static SkRect GetPixelBounds(const SkRect& bounds) { |
| 117 | return SkRect::MakeLTRB(SkScalarFloorToScalar(bounds.fLeft + kBoundsTolerance), |
| 118 | SkScalarFloorToScalar(bounds.fTop + kBoundsTolerance), |
| 119 | SkScalarCeilToScalar(bounds.fRight - kBoundsTolerance), |
| 120 | SkScalarCeilToScalar(bounds.fBottom - kBoundsTolerance)); |
| 121 | } |
| 122 | |
| 123 | /** |
| 124 | * Returns true if the given rect counts as aligned with pixel boundaries. |
| 125 | */ |
| 126 | static bool IsPixelAligned(const SkRect& rect) { |
| 127 | return SkScalarAbs(SkScalarRoundToScalar(rect.fLeft) - rect.fLeft) <= kBoundsTolerance && |
| 128 | SkScalarAbs(SkScalarRoundToScalar(rect.fTop) - rect.fTop) <= kBoundsTolerance && |
| 129 | SkScalarAbs(SkScalarRoundToScalar(rect.fRight) - rect.fRight) <= kBoundsTolerance && |
| 130 | SkScalarAbs(SkScalarRoundToScalar(rect.fBottom) - rect.fBottom) <= kBoundsTolerance; |
| 131 | } |
cdalton | 846c051 | 2016-05-13 10:25:00 -0700 | [diff] [blame] | 132 | }; |
| 133 | |
Chris Dalton | bbfd516 | 2017-11-07 13:35:22 -0700 | [diff] [blame] | 134 | |
| 135 | /** |
| 136 | * GrHardClip never uses coverage FPs. It can only enforce the clip using the already-existing |
| 137 | * stencil buffer contents and/or fixed-function state like scissor. Always aliased if MSAA is off. |
| 138 | */ |
| 139 | class GrHardClip : public GrClip { |
| 140 | public: |
| 141 | /** |
| 142 | * Sets the appropriate hardware state modifications on GrAppliedHardClip that will implement |
| 143 | * the clip. On input 'bounds' is a conservative bounds of the draw that is to be clipped. After |
| 144 | * return 'bounds' has been intersected with a conservative bounds of the clip. A return value |
| 145 | * of false indicates that the draw can be skipped as it is fully clipped out. |
| 146 | */ |
| 147 | virtual bool apply(int rtWidth, int rtHeight, GrAppliedHardClip* out, SkRect* bounds) const = 0; |
| 148 | |
| 149 | private: |
Robert Phillips | 6f0e02f | 2019-02-13 11:02:28 -0500 | [diff] [blame] | 150 | bool apply(GrRecordingContext*, GrRenderTargetContext* rtc, bool useHWAA, |
| 151 | bool hasUserStencilSettings, GrAppliedClip* out, SkRect* bounds) const final { |
Chris Dalton | bbfd516 | 2017-11-07 13:35:22 -0700 | [diff] [blame] | 152 | return this->apply(rtc->width(), rtc->height(), &out->hardClip(), bounds); |
| 153 | } |
| 154 | }; |
| 155 | |
cdalton | 846c051 | 2016-05-13 10:25:00 -0700 | [diff] [blame] | 156 | /** |
| 157 | * Specialized implementation for no clip. |
| 158 | */ |
Chris Dalton | bbfd516 | 2017-11-07 13:35:22 -0700 | [diff] [blame] | 159 | class GrNoClip final : public GrHardClip { |
cdalton | 846c051 | 2016-05-13 10:25:00 -0700 | [diff] [blame] | 160 | private: |
Brian Salomon | c65aec9 | 2017-03-09 09:03:58 -0500 | [diff] [blame] | 161 | bool quickContains(const SkRect&) const final { return true; } |
| 162 | bool quickContains(const SkRRect&) const final { return true; } |
cdalton | 846c051 | 2016-05-13 10:25:00 -0700 | [diff] [blame] | 163 | void getConservativeBounds(int width, int height, SkIRect* devResult, |
csmartdalton | 02fa32c | 2016-08-19 13:29:27 -0700 | [diff] [blame] | 164 | bool* isIntersectionOfRects) const final { |
| 165 | devResult->setXYWH(0, 0, width, height); |
| 166 | if (isIntersectionOfRects) { |
| 167 | *isIntersectionOfRects = true; |
| 168 | } |
| 169 | } |
Chris Dalton | bbfd516 | 2017-11-07 13:35:22 -0700 | [diff] [blame] | 170 | bool apply(int rtWidth, int rtHeight, GrAppliedHardClip*, SkRect*) const final { return true; } |
Brian Salomon | 0e8fc8b | 2016-12-09 15:10:07 -0500 | [diff] [blame] | 171 | bool isRRect(const SkRect&, SkRRect*, GrAA*) const override { return false; } |
cdalton | 846c051 | 2016-05-13 10:25:00 -0700 | [diff] [blame] | 172 | }; |
| 173 | |
joshualitt | 44701df | 2015-02-23 14:44:57 -0800 | [diff] [blame] | 174 | #endif |