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
15class GrAppliedClip;
16class GrContext;
17class 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 */
23class GrClip {
24public:
25    virtual bool quickContains(const SkRect&) const = 0;
26    virtual bool quickContains(const SkRRect& rrect) const {
27        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    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    constexpr static bool IsInsideClip(const TRect& innerClipBounds, const SkRect& queryBounds) {
77        return innerClipBounds.fRight - innerClipBounds.fLeft > kBoundsTolerance &&
78               innerClipBounds.fBottom - innerClipBounds.fTop > kBoundsTolerance &&
79               innerClipBounds.fLeft < queryBounds.fLeft + kBoundsTolerance &&
80               innerClipBounds.fTop < queryBounds.fTop + kBoundsTolerance &&
81               innerClipBounds.fRight > queryBounds.fRight - kBoundsTolerance &&
82               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    constexpr static bool IsOutsideClip(const TRect& outerClipBounds, const SkRect& queryBounds) {
93        return outerClipBounds.fRight - outerClipBounds.fLeft <= kBoundsTolerance ||
94               outerClipBounds.fBottom - outerClipBounds.fTop <= kBoundsTolerance ||
95               outerClipBounds.fLeft >= queryBounds.fRight - kBoundsTolerance ||
96               outerClipBounds.fTop >= queryBounds.fBottom - kBoundsTolerance ||
97               outerClipBounds.fRight <= queryBounds.fLeft + kBoundsTolerance ||
98               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    static SkIRect GetPixelIBounds(const SkRect& bounds) {
105        return SkIRect::MakeLTRB(SkScalarFloorToInt(bounds.fLeft + kBoundsTolerance),
106                                 SkScalarFloorToInt(bounds.fTop + kBoundsTolerance),
107                                 SkScalarCeilToInt(bounds.fRight - kBoundsTolerance),
108                                 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    static SkRect GetPixelBounds(const SkRect& bounds) {
115        return SkRect::MakeLTRB(SkScalarFloorToScalar(bounds.fLeft + kBoundsTolerance),
116                                SkScalarFloorToScalar(bounds.fTop + kBoundsTolerance),
117                                SkScalarCeilToScalar(bounds.fRight - kBoundsTolerance),
118                                SkScalarCeilToScalar(bounds.fBottom - kBoundsTolerance));
119    }
120
121    /**
122     * Returns true if the given rect counts as aligned with pixel boundaries.
123     */
124    static bool IsPixelAligned(const SkRect& rect) {
125        return SkScalarAbs(SkScalarRoundToScalar(rect.fLeft) - rect.fLeft) <= kBoundsTolerance &&
126               SkScalarAbs(SkScalarRoundToScalar(rect.fTop) - rect.fTop) <= kBoundsTolerance &&
127               SkScalarAbs(SkScalarRoundToScalar(rect.fRight) - rect.fRight) <= kBoundsTolerance &&
128               SkScalarAbs(SkScalarRoundToScalar(rect.fBottom) - rect.fBottom) <= kBoundsTolerance;
129    }
130};
131
132/**
133 * Specialized implementation for no clip.
134 */
135class GrNoClip final : public GrClip {
136private:
137    bool quickContains(const SkRect&) const final { return true; }
138    bool quickContains(const SkRRect&) const final { return true; }
139    void getConservativeBounds(int width, int height, SkIRect* devResult,
140                               bool* isIntersectionOfRects) const final {
141        devResult->setXYWH(0, 0, width, height);
142        if (isIntersectionOfRects) {
143            *isIntersectionOfRects = true;
144        }
145    }
146    bool apply(GrContext*, GrRenderTargetContext*, bool, bool, GrAppliedClip*,
147               SkRect*) const final {
148        return true;
149    }
150    bool isRRect(const SkRect&, SkRRect*, GrAA*) const override { return false; }
151};
152
153#endif
154