Line data Source code
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 "GrTypes.h"
12 : #include "SkRRect.h"
13 : #include "SkRect.h"
14 :
15 : class GrAppliedClip;
16 : class GrContext;
17 : class GrRenderTargetContext;
18 :
19 : /**
20 : * GrClip is an abstract base class for applying a clip. It constructs a clip mask if necessary, and
21 : * fills out a GrAppliedClip instructing the caller on how to set up the draw state.
22 : */
23 0 : class GrClip {
24 : public:
25 : virtual bool quickContains(const SkRect&) const = 0;
26 0 : virtual bool quickContains(const SkRRect& rrect) const {
27 0 : return this->quickContains(rrect.getBounds());
28 : }
29 : virtual void getConservativeBounds(int width, int height, SkIRect* devResult,
30 : bool* isIntersectionOfRects = nullptr) const = 0;
31 : /**
32 : * This computes a GrAppliedClip from the clip which in turn can be used to build a GrPipeline.
33 : * To determine the appropriate clipping implementation the GrClip subclass must know whether
34 : * the draw will enable HW AA or uses the stencil buffer. On input 'bounds' is a conservative
35 : * bounds of the draw that is to be clipped. After return 'bounds' has been intersected with a
36 : * conservative bounds of the clip. A return value of false indicates that the draw can be
37 : * skipped as it is fully clipped out.
38 : */
39 : virtual bool apply(GrContext*, GrRenderTargetContext*, bool useHWAA,
40 : bool hasUserStencilSettings, GrAppliedClip* result,
41 : SkRect* bounds) const = 0;
42 :
43 0 : virtual ~GrClip() {}
44 :
45 : /**
46 : * This method quickly and conservatively determines whether the entire clip is equivalent to
47 : * intersection with a rrect. This will only return true if the rrect does not fully contain
48 : * the render target bounds. Moreover, the returned rrect need not be contained by the render
49 : * target bounds. We assume all draws will be implicitly clipped by the render target bounds.
50 : *
51 : * @param rtBounds The bounds of the render target that the clip will be applied to.
52 : * @param rrect If return is true rrect will contain the rrect equivalent to the clip within
53 : * rtBounds.
54 : * @param aa If return is true aa will indicate whether the rrect clip is antialiased.
55 : * @return true if the clip is equivalent to a single rrect, false otherwise.
56 : *
57 : */
58 : virtual bool isRRect(const SkRect& rtBounds, SkRRect* rrect, GrAA* aa) const = 0;
59 :
60 : /**
61 : * This is the maximum distance that a draw may extend beyond a clip's boundary and still count
62 : * count as "on the other side". We leave some slack because floating point rounding error is
63 : * likely to blame. The rationale for 1e-3 is that in the coverage case (and barring unexpected
64 : * rounding), as long as coverage stays within 0.5 * 1/256 of its intended value it shouldn't
65 : * have any effect on the final pixel values.
66 : */
67 : constexpr static SkScalar kBoundsTolerance = 1e-3f;
68 :
69 : /**
70 : * Returns true if the given query bounds count as entirely inside the clip.
71 : *
72 : * @param innerClipBounds device-space rect contained by the clip (SkRect or SkIRect).
73 : * @param queryBounds device-space bounds of the query region.
74 : */
75 : template <typename TRect>
76 0 : constexpr static bool IsInsideClip(const TRect& innerClipBounds, const SkRect& queryBounds) {
77 0 : return innerClipBounds.fRight - innerClipBounds.fLeft > kBoundsTolerance &&
78 0 : innerClipBounds.fBottom - innerClipBounds.fTop > kBoundsTolerance &&
79 0 : innerClipBounds.fLeft < queryBounds.fLeft + kBoundsTolerance &&
80 0 : innerClipBounds.fTop < queryBounds.fTop + kBoundsTolerance &&
81 0 : innerClipBounds.fRight > queryBounds.fRight - kBoundsTolerance &&
82 0 : innerClipBounds.fBottom > queryBounds.fBottom - kBoundsTolerance;
83 : }
84 :
85 : /**
86 : * Returns true if the given query bounds count as entirely outside the clip.
87 : *
88 : * @param outerClipBounds device-space rect that contains the clip (SkRect or SkIRect).
89 : * @param queryBounds device-space bounds of the query region.
90 : */
91 : template <typename TRect>
92 0 : constexpr static bool IsOutsideClip(const TRect& outerClipBounds, const SkRect& queryBounds) {
93 0 : return outerClipBounds.fRight - outerClipBounds.fLeft <= kBoundsTolerance ||
94 0 : outerClipBounds.fBottom - outerClipBounds.fTop <= kBoundsTolerance ||
95 0 : outerClipBounds.fLeft >= queryBounds.fRight - kBoundsTolerance ||
96 0 : outerClipBounds.fTop >= queryBounds.fBottom - kBoundsTolerance ||
97 0 : outerClipBounds.fRight <= queryBounds.fLeft + kBoundsTolerance ||
98 0 : outerClipBounds.fBottom <= queryBounds.fTop + kBoundsTolerance;
99 : }
100 :
101 : /**
102 : * Returns the minimal integer rect that counts as containing a given set of bounds.
103 : */
104 0 : static SkIRect GetPixelIBounds(const SkRect& bounds) {
105 0 : return SkIRect::MakeLTRB(SkScalarFloorToInt(bounds.fLeft + kBoundsTolerance),
106 0 : SkScalarFloorToInt(bounds.fTop + kBoundsTolerance),
107 0 : SkScalarCeilToInt(bounds.fRight - kBoundsTolerance),
108 0 : SkScalarCeilToInt(bounds.fBottom - kBoundsTolerance));
109 : }
110 :
111 : /**
112 : * Returns the minimal pixel-aligned rect that counts as containing a given set of bounds.
113 : */
114 0 : static SkRect GetPixelBounds(const SkRect& bounds) {
115 0 : return SkRect::MakeLTRB(SkScalarFloorToScalar(bounds.fLeft + kBoundsTolerance),
116 0 : SkScalarFloorToScalar(bounds.fTop + kBoundsTolerance),
117 0 : SkScalarCeilToScalar(bounds.fRight - kBoundsTolerance),
118 0 : SkScalarCeilToScalar(bounds.fBottom - kBoundsTolerance));
119 : }
120 :
121 : /**
122 : * Returns true if the given rect counts as aligned with pixel boundaries.
123 : */
124 0 : static bool IsPixelAligned(const SkRect& rect) {
125 0 : return SkScalarAbs(SkScalarRoundToScalar(rect.fLeft) - rect.fLeft) <= kBoundsTolerance &&
126 0 : SkScalarAbs(SkScalarRoundToScalar(rect.fTop) - rect.fTop) <= kBoundsTolerance &&
127 0 : SkScalarAbs(SkScalarRoundToScalar(rect.fRight) - rect.fRight) <= kBoundsTolerance &&
128 0 : SkScalarAbs(SkScalarRoundToScalar(rect.fBottom) - rect.fBottom) <= kBoundsTolerance;
129 : }
130 : };
131 :
132 : /**
133 : * Specialized implementation for no clip.
134 : */
135 0 : class GrNoClip final : public GrClip {
136 : private:
137 0 : bool quickContains(const SkRect&) const final { return true; }
138 0 : bool quickContains(const SkRRect&) const final { return true; }
139 0 : void getConservativeBounds(int width, int height, SkIRect* devResult,
140 : bool* isIntersectionOfRects) const final {
141 0 : devResult->setXYWH(0, 0, width, height);
142 0 : if (isIntersectionOfRects) {
143 0 : *isIntersectionOfRects = true;
144 : }
145 0 : }
146 0 : bool apply(GrContext*, GrRenderTargetContext*, bool, bool, GrAppliedClip*,
147 : SkRect*) const final {
148 0 : return true;
149 : }
150 0 : bool isRRect(const SkRect&, SkRRect*, GrAA*) const override { return false; }
151 : };
152 :
153 : #endif
|
