libs/hwui/Rect.h

   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):
  77             left(rect.fLeft),
  78             top(rect.fTop),
  79             right(rect.fRight),
  80             bottom(rect.fBottom) {
  81     }
  82
  83     inline Rect(const SkRect& rect):
  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