Home | History | Annotate | Download | only in hwui 
      1 /*
      2  * Copyright (C) 2010 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #pragma once
     18 
     19 #include "Vertex.h"
     20 
     21 #include <utils/Log.h>
     22 
     23 #include <algorithm>
     24 #include <cmath>
     25 #include <iomanip>
     26 #include <ostream>
     27 #include <SkRect.h>
     28 
     29 namespace android {
     30 namespace uirenderer {
     31 
     32 #define RECT_STRING "%5.2f %5.2f %5.2f %5.2f"
     33 #define RECT_ARGS(r) \
     34     (r).left, (r).top, (r).right, (r).bottom
     35 #define SK_RECT_ARGS(r) \
     36     (r).left(), (r).top(), (r).right(), (r).bottom()
     37 
     38 ///////////////////////////////////////////////////////////////////////////////
     39 // Structs
     40 ///////////////////////////////////////////////////////////////////////////////
     41 
     42 class Rect {
     43 public:
     44     float left;
     45     float top;
     46     float right;
     47     float bottom;
     48 
     49     // Used by Region
     50     typedef float value_type;
     51 
     52     // we don't provide copy-ctor and operator= on purpose
     53     // because we want the compiler generated versions
     54 
     55     inline Rect():
     56             left(0),
     57             top(0),
     58             right(0),
     59             bottom(0) {
     60     }
     61 
     62     inline Rect(float left, float top, float right, float bottom):
     63             left(left),
     64             top(top),
     65             right(right),
     66             bottom(bottom) {
     67     }
     68 
     69     inline Rect(float width, float height):
     70             left(0.0f),
     71             top(0.0f),
     72             right(width),
     73             bottom(height) {
     74     }
     75 
     76     inline Rect(const SkIRect& rect):  // NOLINT, implicit
     77             left(rect.fLeft),
     78             top(rect.fTop),
     79             right(rect.fRight),
     80             bottom(rect.fBottom) {
     81     }
     82 
     83     inline Rect(const SkRect& rect):  // NOLINT, implicit
     84             left(rect.fLeft),
     85             top(rect.fTop),
     86             right(rect.fRight),
     87             bottom(rect.fBottom) {
     88     }
     89 
     90     friend int operator==(const Rect& a, const Rect& b) {
     91         return !memcmp(&a, &b, sizeof(a));
     92     }
     93 
     94     friend int operator!=(const Rect& a, const Rect& b) {
     95         return memcmp(&a, &b, sizeof(a));
     96     }
     97 
     98     inline void clear() {
     99         left = top = right = bottom = 0.0f;
    100     }
    101 
    102     inline bool isEmpty() const {
    103         // this is written in such way this it'll handle NANs to return
    104         // true (empty)
    105         return !((left < right) && (top < bottom));
    106     }
    107 
    108     inline void setEmpty() {
    109         left = top = right = bottom = 0.0f;
    110     }
    111 
    112     inline void set(float left, float top, float right, float bottom) {
    113         this->left = left;
    114         this->right = right;
    115         this->top = top;
    116         this->bottom = bottom;
    117     }
    118 
    119     inline void set(const Rect& r) {
    120         set(r.left, r.top, r.right, r.bottom);
    121     }
    122 
    123     inline void set(const SkIRect& r) {
    124         set(r.left(), r.top(), r.right(), r.bottom());
    125     }
    126 
    127     inline float getWidth() const {
    128         return right - left;
    129     }
    130 
    131     inline float getHeight() const {
    132         return bottom - top;
    133     }
    134 
    135     bool intersects(float l, float t, float r, float b) const {
    136         float tempLeft = std::max(left, l);
    137         float tempTop = std::max(top, t);
    138         float tempRight = std::min(right, r);
    139         float tempBottom = std::min(bottom, b);
    140 
    141         return ((tempLeft < tempRight) && (tempTop < tempBottom)); // !isEmpty
    142     }
    143 
    144     bool intersects(const Rect& r) const {
    145         return intersects(r.left, r.top, r.right, r.bottom);
    146     }
    147 
    148     /**
    149      * This method is named 'doIntersect' instead of 'intersect' so as not to be confused with
    150      * SkRect::intersect / android.graphics.Rect#intersect behavior, which do not modify the object
    151      * if the intersection of the rects would be empty.
    152      */
    153     void doIntersect(float l, float t, float r, float b) {
    154         left = std::max(left, l);
    155         top = std::max(top, t);
    156         right = std::min(right, r);
    157         bottom = std::min(bottom, b);
    158     }
    159 
    160     void doIntersect(const Rect& r) {
    161         doIntersect(r.left, r.top, r.right, r.bottom);
    162     }
    163 
    164     inline bool contains(float l, float t, float r, float b) const {
    165         return l >= left && t >= top && r <= right && b <= bottom;
    166     }
    167 
    168     inline bool contains(const Rect& r) const {
    169         return contains(r.left, r.top, r.right, r.bottom);
    170     }
    171 
    172     bool unionWith(const Rect& r) {
    173         if (r.left < r.right && r.top < r.bottom) {
    174             if (left < right && top < bottom) {
    175                 if (left > r.left) left = r.left;
    176                 if (top > r.top) top = r.top;
    177                 if (right < r.right) right = r.right;
    178                 if (bottom < r.bottom) bottom = r.bottom;
    179                 return true;
    180             } else {
    181                 left = r.left;
    182                 top = r.top;
    183                 right = r.right;
    184                 bottom = r.bottom;
    185                 return true;
    186             }
    187         }
    188         return false;
    189     }
    190 
    191     void translate(float dx, float dy) {
    192         left += dx;
    193         right += dx;
    194         top += dy;
    195         bottom += dy;
    196     }
    197 
    198     void inset(float delta) {
    199         outset(-delta);
    200     }
    201 
    202     void outset(float delta) {
    203         left -= delta;
    204         top -= delta;
    205         right += delta;
    206         bottom += delta;
    207     }
    208 
    209     void outset(float xdelta, float ydelta) {
    210         left -= xdelta;
    211         top -= ydelta;
    212         right += xdelta;
    213         bottom += ydelta;
    214     }
    215 
    216     /**
    217      * Similar to snapToPixelBoundaries, but estimates bounds conservatively to handle GL rounding
    218      * errors.
    219      *
    220      * This function should be used whenever estimating the damage rect of geometry already mapped
    221      * into layer space.
    222      */
    223     void snapGeometryToPixelBoundaries(bool snapOut) {
    224         if (snapOut) {
    225             /* For AA geometry with a ramp perimeter, don't snap by rounding - AA geometry will have
    226              * a 0.5 pixel perimeter not accounted for in its bounds. Instead, snap by
    227              * conservatively rounding out the bounds with floor/ceil.
    228              *
    229              * In order to avoid changing integer bounds with floor/ceil due to rounding errors
    230              * inset the bounds first by the fudge factor. Very small fraction-of-a-pixel errors
    231              * from this inset will only incur similarly small errors in output, due to transparency
    232              * in extreme outside of the geometry.
    233              */
    234             left = floorf(left + Vertex::GeometryFudgeFactor());
    235             top = floorf(top + Vertex::GeometryFudgeFactor());
    236             right = ceilf(right - Vertex::GeometryFudgeFactor());
    237             bottom = ceilf(bottom - Vertex::GeometryFudgeFactor());
    238         } else {
    239             /* For other geometry, we do the regular rounding in order to snap, but also outset the
    240              * bounds by a fudge factor. This ensures that ambiguous geometry (e.g. a non-AA Rect
    241              * with top left at (0.5, 0.5)) will err on the side of a larger damage rect.
    242              */
    243             left = floorf(left + 0.5f - Vertex::GeometryFudgeFactor());
    244             top = floorf(top + 0.5f - Vertex::GeometryFudgeFactor());
    245             right = floorf(right + 0.5f + Vertex::GeometryFudgeFactor());
    246             bottom = floorf(bottom + 0.5f + Vertex::GeometryFudgeFactor());
    247         }
    248     }
    249 
    250     void snapToPixelBoundaries() {
    251         left = floorf(left + 0.5f);
    252         top = floorf(top + 0.5f);
    253         right = floorf(right + 0.5f);
    254         bottom = floorf(bottom + 0.5f);
    255     }
    256 
    257     void roundOut() {
    258         left = floorf(left);
    259         top = floorf(top);
    260         right = ceilf(right);
    261         bottom = ceilf(bottom);
    262     }
    263 
    264     /*
    265      * Similar to unionWith, except this makes the assumption that both rects are non-empty
    266      * to avoid both emptiness checks.
    267      */
    268     void expandToCover(const Rect& other) {
    269         left = std::min(left, other.left);
    270         top = std::min(top, other.top);
    271         right = std::max(right, other.right);
    272         bottom = std::max(bottom, other.bottom);
    273     }
    274 
    275     void expandToCover(float x, float y) {
    276         left = std::min(left, x);
    277         top = std::min(top, y);
    278         right = std::max(right, x);
    279         bottom = std::max(bottom, y);
    280     }
    281 
    282     SkRect toSkRect() const {
    283         return SkRect::MakeLTRB(left, top, right, bottom);
    284     }
    285 
    286     SkIRect toSkIRect() const {
    287         return SkIRect::MakeLTRB(left, top, right, bottom);
    288     }
    289 
    290     void dump(const char* label = nullptr) const {
    291         ALOGD("%s[l=%.2f t=%.2f r=%.2f b=%.2f]", label ? label : "Rect", left, top, right, bottom);
    292     }
    293 
    294     friend std::ostream& operator<<(std::ostream& os, const Rect& rect) {
    295         if (rect.isEmpty()) {
    296             // Print empty, but continue, since empty rects may still have useful coordinate info
    297             os << "(empty)";
    298         }
    299 
    300         if (rect.left == 0 && rect.top == 0) {
    301             return os << "[" << rect.right << " x " << rect.bottom << "]";
    302         }
    303 
    304         return os << "[" << rect.left
    305                 << " " << rect.top
    306                 << " " << rect.right
    307                 << " " << rect.bottom << "]";
    308     }
    309 }; // class Rect
    310 
    311 }; // namespace uirenderer
    312 }; // namespace android
    313 
    314