Home | History | Annotate | Download | only in gpu 
      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 class GrClip {
     24 public:
     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
     94             // Is the clip so small that it is effectively empty?
     95             outerClipBounds.fRight - outerClipBounds.fLeft <= kBoundsTolerance ||
     96             outerClipBounds.fBottom - outerClipBounds.fTop <= kBoundsTolerance ||
     97 
     98             // Are the query bounds effectively outside the clip?
     99             outerClipBounds.fLeft >= queryBounds.fRight - kBoundsTolerance ||
    100             outerClipBounds.fTop >= queryBounds.fBottom - kBoundsTolerance ||
    101             outerClipBounds.fRight <= queryBounds.fLeft + kBoundsTolerance ||
    102             outerClipBounds.fBottom <= queryBounds.fTop + kBoundsTolerance;
    103     }
    104 
    105     /**
    106      * Returns the minimal integer rect that counts as containing a given set of bounds.
    107      */
    108     static SkIRect GetPixelIBounds(const SkRect& bounds) {
    109         return SkIRect::MakeLTRB(SkScalarFloorToInt(bounds.fLeft + kBoundsTolerance),
    110                                  SkScalarFloorToInt(bounds.fTop + kBoundsTolerance),
    111                                  SkScalarCeilToInt(bounds.fRight - kBoundsTolerance),
    112                                  SkScalarCeilToInt(bounds.fBottom - kBoundsTolerance));
    113     }
    114 
    115     /**
    116      * Returns the minimal pixel-aligned rect that counts as containing a given set of bounds.
    117      */
    118     static SkRect GetPixelBounds(const SkRect& bounds) {
    119         return SkRect::MakeLTRB(SkScalarFloorToScalar(bounds.fLeft + kBoundsTolerance),
    120                                 SkScalarFloorToScalar(bounds.fTop + kBoundsTolerance),
    121                                 SkScalarCeilToScalar(bounds.fRight - kBoundsTolerance),
    122                                 SkScalarCeilToScalar(bounds.fBottom - kBoundsTolerance));
    123     }
    124 
    125     /**
    126      * Returns true if the given rect counts as aligned with pixel boundaries.
    127      */
    128     static bool IsPixelAligned(const SkRect& rect) {
    129         return SkScalarAbs(SkScalarRoundToScalar(rect.fLeft) - rect.fLeft) <= kBoundsTolerance &&
    130                SkScalarAbs(SkScalarRoundToScalar(rect.fTop) - rect.fTop) <= kBoundsTolerance &&
    131                SkScalarAbs(SkScalarRoundToScalar(rect.fRight) - rect.fRight) <= kBoundsTolerance &&
    132                SkScalarAbs(SkScalarRoundToScalar(rect.fBottom) - rect.fBottom) <= kBoundsTolerance;
    133     }
    134 };
    135 
    136 /**
    137  * Specialized implementation for no clip.
    138  */
    139 class GrNoClip final : public GrClip {
    140 private:
    141     bool quickContains(const SkRect&) const final { return true; }
    142     bool quickContains(const SkRRect&) const final { return true; }
    143     void getConservativeBounds(int width, int height, SkIRect* devResult,
    144                                bool* isIntersectionOfRects) const final {
    145         devResult->setXYWH(0, 0, width, height);
    146         if (isIntersectionOfRects) {
    147             *isIntersectionOfRects = true;
    148         }
    149     }
    150     bool apply(GrContext*, GrRenderTargetContext*, bool, bool, GrAppliedClip*,
    151                SkRect*) const final {
    152         return true;
    153     }
    154     bool isRRect(const SkRect&, SkRRect*, GrAA*) const override { return false; }
    155 };
    156 
    157 #endif
    158