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 
11 #include "GrAppliedClip.h"
12 #include "GrRenderTargetContext.h"
13 #include "SkRRect.h"
14 #include "SkRect.h"
15 
16 class GrContext;
17 
18 /**
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;
25     virtual bool quickContains(const SkRRect& rrect) const {
26         return this->quickContains(rrect.getBounds());
27     }
28     virtual void getConservativeBounds(int width, int height, SkIRect* devResult,
29                                        bool* isIntersectionOfRects = nullptr) const = 0;
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      */
38     virtual bool apply(GrContext*, GrRenderTargetContext*, bool useHWAA,
39                        bool hasUserStencilSettings, GrAppliedClip*, SkRect* bounds) const = 0;
40 
41     virtual ~GrClip() {}
42 
43     /**
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      */
56     virtual bool isRRect(const SkRect& rtBounds, SkRRect* rrect, GrAA* aa) const = 0;
57 
58     /**
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.
64      */
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      */
73     template <typename TRect>
74     constexpr static bool IsInsideClip(const TRect& innerClipBounds, const SkRect& queryBounds) {
75         return innerClipBounds.fRight > innerClipBounds.fLeft + kBoundsTolerance &&
76                innerClipBounds.fBottom > innerClipBounds.fTop + kBoundsTolerance &&
77                innerClipBounds.fLeft < queryBounds.fLeft + kBoundsTolerance &&
78                innerClipBounds.fTop < queryBounds.fTop + kBoundsTolerance &&
79                innerClipBounds.fRight > queryBounds.fRight - kBoundsTolerance &&
80                innerClipBounds.fBottom > queryBounds.fBottom - kBoundsTolerance;
81     }
82 
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      */
89     template <typename TRect>
90     constexpr static bool IsOutsideClip(const TRect& outerClipBounds, const SkRect& queryBounds) {
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;
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     }
132 };
133 
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:
150     bool apply(GrContext*, GrRenderTargetContext* rtc, bool useHWAA, bool hasUserStencilSettings,
151                GrAppliedClip* out, SkRect* bounds) const final {
152         return this->apply(rtc->width(), rtc->height(), &out->hardClip(), bounds);
153     }
154 };
155 
156 /**
157  * Specialized implementation for no clip.
158  */
159 class GrNoClip final : public GrHardClip {
160 private:
161     bool quickContains(const SkRect&) const final { return true; }
162     bool quickContains(const SkRRect&) const final { return true; }
163     void getConservativeBounds(int width, int height, SkIRect* devResult,
164                                bool* isIntersectionOfRects) const final {
165         devResult->setXYWH(0, 0, width, height);
166         if (isIntersectionOfRects) {
167             *isIntersectionOfRects = true;
168         }
169     }
170     bool apply(int rtWidth, int rtHeight, GrAppliedHardClip*, SkRect*) const final { return true; }
171     bool isRRect(const SkRect&, SkRRect*, GrAA*) const override { return false; }
172 };
173 
174 #endif
175