libs/hwui/Rect.h - platform/frameworks/base - Gitiles

 /*
  * Copyright (C) 2010 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #ifndef ANDROID_HWUI_RECT_H
 #define ANDROID_HWUI_RECT_H

 #include <cmath>
 #include <algorithm>
 #include <SkRect.h>

 #include <utils/Log.h>

 #include "Vertex.h"

 namespace android {
 namespace uirenderer {

 #define RECT_STRING "%5.2f %5.2f %5.2f %5.2f"
 #define RECT_ARGS(r) \
     (r).left, (r).top, (r).right, (r).bottom
 #define SK_RECT_ARGS(r) \
     (r).left(), (r).top(), (r).right(), (r).bottom()

 ///////////////////////////////////////////////////////////////////////////////
 // Structs
 ///////////////////////////////////////////////////////////////////////////////

 class Rect {
 public:
     float left;
     float top;
     float right;
     float bottom;

     // Used by Region
     typedef float value_type;

     // we don't provide copy-ctor and operator= on purpose
     // because we want the compiler generated versions

     inline Rect():
             left(0),
             top(0),
             right(0),
             bottom(0) {
     }

     inline Rect(float left, float top, float right, float bottom):
             left(left),
             top(top),
             right(right),
             bottom(bottom) {
     }

     inline Rect(float width, float height):
             left(0.0f),
             top(0.0f),
             right(width),
             bottom(height) {
     }

     inline Rect(const SkRect& rect):
             left(rect.fLeft),
             top(rect.fTop),
             right(rect.fRight),
             bottom(rect.fBottom) {
     }

     friend int operator==(const Rect& a, const Rect& b) {
         return !memcmp(&a, &b, sizeof(a));
     }

     friend int operator!=(const Rect& a, const Rect& b) {
         return memcmp(&a, &b, sizeof(a));
     }

     inline void clear() {
         left = top = right = bottom = 0.0f;
     }

     inline bool isEmpty() const {
         // this is written in such way this it'll handle NANs to return
         // true (empty)
         return !((left < right) && (top < bottom));
     }

     inline void setEmpty() {
         left = top = right = bottom = 0.0f;
     }

     inline void set(float left, float top, float right, float bottom) {
         this->left = left;
         this->right = right;
         this->top = top;
         this->bottom = bottom;
     }

     inline void set(const Rect& r) {
         set(r.left, r.top, r.right, r.bottom);
     }

     inline void set(const SkIRect& r) {
         set(r.left(), r.top(), r.right(), r.bottom());
     }

     inline float getWidth() const {
         return right - left;
     }

     inline float getHeight() const {
         return bottom - top;
     }

     bool intersects(float l, float t, float r, float b) const {
         float tempLeft = std::max(left, l);
         float tempTop = std::max(top, t);
         float tempRight = std::min(right, r);
         float tempBottom = std::min(bottom, b);

         return ((tempLeft < tempRight) && (tempTop < tempBottom)); // !isEmpty
     }

     bool intersects(const Rect& r) const {
         return intersects(r.left, r.top, r.right, r.bottom);
     }

     /**
      * This method is named 'doIntersect' instead of 'intersect' so as not to be confused with
      * SkRect::intersect / android.graphics.Rect#intersect behavior, which do not modify the object
      * if the intersection of the rects would be empty.
      */
     void doIntersect(float l, float t, float r, float b) {
         left = std::max(left, l);
         top = std::max(top, t);
         right = std::min(right, r);
         bottom = std::min(bottom, b);
     }

     void doIntersect(const Rect& r) {
         doIntersect(r.left, r.top, r.right, r.bottom);
     }

     inline bool contains(float l, float t, float r, float b) const {
         return l >= left && t >= top && r <= right && b <= bottom;
     }

     inline bool contains(const Rect& r) const {
         return contains(r.left, r.top, r.right, r.bottom);
     }

     bool unionWith(const Rect& r) {
         if (r.left < r.right && r.top < r.bottom) {
             if (left < right && top < bottom) {
                 if (left > r.left) left = r.left;
                 if (top > r.top) top = r.top;
                 if (right < r.right) right = r.right;
                 if (bottom < r.bottom) bottom = r.bottom;
                 return true;
             } else {
                 left = r.left;
                 top = r.top;
                 right = r.right;
                 bottom = r.bottom;
                 return true;
             }
         }
         return false;
     }

     void translate(float dx, float dy) {
         left += dx;
         right += dx;
         top += dy;
         bottom += dy;
     }

     void inset(float delta) {
         outset(-delta);
     }

     void outset(float delta) {
         left -= delta;
         top -= delta;
         right += delta;
         bottom += delta;
     }

     void outset(float xdelta, float ydelta) {
         left -= xdelta;
         top -= ydelta;
         right += xdelta;
         bottom += ydelta;
     }

     /**
      * Similar to snapToPixelBoundaries, but estimates bounds conservatively to handle GL rounding
      * errors.
      *
      * This function should be used whenever estimating the damage rect of geometry already mapped
      * into layer space.
      */
     void snapGeometryToPixelBoundaries(bool snapOut) {
         if (snapOut) {
             /* For AA geometry with a ramp perimeter, don't snap by rounding - AA geometry will have
              * a 0.5 pixel perimeter not accounted for in its bounds. Instead, snap by
              * conservatively rounding out the bounds with floor/ceil.
              *
              * In order to avoid changing integer bounds with floor/ceil due to rounding errors
              * inset the bounds first by the fudge factor. Very small fraction-of-a-pixel errors
              * from this inset will only incur similarly small errors in output, due to transparency
              * in extreme outside of the geometry.
              */
             left = floorf(left + Vertex::GeometryFudgeFactor());
             top = floorf(top + Vertex::GeometryFudgeFactor());
             right = ceilf(right - Vertex::GeometryFudgeFactor());
             bottom = ceilf(bottom - Vertex::GeometryFudgeFactor());
         } else {
             /* For other geometry, we do the regular rounding in order to snap, but also outset the
              * bounds by a fudge factor. This ensures that ambiguous geometry (e.g. a non-AA Rect
              * with top left at (0.5, 0.5)) will err on the side of a larger damage rect.
              */
             left = floorf(left + 0.5f - Vertex::GeometryFudgeFactor());
             top = floorf(top + 0.5f - Vertex::GeometryFudgeFactor());
             right = floorf(right + 0.5f + Vertex::GeometryFudgeFactor());
             bottom = floorf(bottom + 0.5f + Vertex::GeometryFudgeFactor());
         }
     }

     void snapToPixelBoundaries() {
         left = floorf(left + 0.5f);
         top = floorf(top + 0.5f);
         right = floorf(right + 0.5f);
         bottom = floorf(bottom + 0.5f);
     }

     void roundOut() {
         left = floorf(left);
         top = floorf(top);
         right = ceilf(right);
         bottom = ceilf(bottom);
     }

     void expandToCoverVertex(float x, float y) {
         left = std::min(left, x);
         top = std::min(top, y);
         right = std::max(right, x);
         bottom = std::max(bottom, y);
     }

     void expandToCoverRect(float otherLeft, float otherTop, float otherRight, float otherBottom) {
         left = std::min(left, otherLeft);
         top = std::min(top, otherTop);
         right = std::max(right, otherRight);
         bottom = std::max(bottom, otherBottom);
     }

     SkRect toSkRect() const {
         return SkRect::MakeLTRB(left, top, right, bottom);
     }

     SkIRect toSkIRect() const {
         return SkIRect::MakeLTRB(left, top, right, bottom);
     }

     void dump(const char* label = nullptr) const {
         ALOGD("%s[l=%f t=%f r=%f b=%f]", label ? label : "Rect", left, top, right, bottom);
     }
 }; // class Rect

 }; // namespace uirenderer
 }; // namespace android

 #endif // ANDROID_HWUI_RECT_H
	/*
	* Copyright (C) 2010 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#ifndef ANDROID_HWUI_RECT_H
	#define ANDROID_HWUI_RECT_H

	#include <cmath>
	#include <algorithm>
	#include <SkRect.h>

	#include <utils/Log.h>

	#include "Vertex.h"

	namespace android {
	namespace uirenderer {

	#define RECT_STRING "%5.2f %5.2f %5.2f %5.2f"
	#define RECT_ARGS(r) \
	(r).left, (r).top, (r).right, (r).bottom
	#define SK_RECT_ARGS(r) \
	(r).left(), (r).top(), (r).right(), (r).bottom()

	///////////////////////////////////////////////////////////////////////////////
	// Structs
	///////////////////////////////////////////////////////////////////////////////

	class Rect {
	public:
	float left;
	float top;
	float right;
	float bottom;

	// Used by Region
	typedef float value_type;

	// we don't provide copy-ctor and operator= on purpose
	// because we want the compiler generated versions

	inline Rect():
	left(0),
	top(0),
	right(0),
	bottom(0) {
	}

	inline Rect(float left, float top, float right, float bottom):
	left(left),
	top(top),
	right(right),
	bottom(bottom) {
	}

	inline Rect(float width, float height):
	left(0.0f),
	top(0.0f),
	right(width),
	bottom(height) {
	}

	inline Rect(const SkRect& rect):
	left(rect.fLeft),
	top(rect.fTop),
	right(rect.fRight),
	bottom(rect.fBottom) {
	}

	friend int operator==(const Rect& a, const Rect& b) {
	return !memcmp(&a, &b, sizeof(a));
	}

	friend int operator!=(const Rect& a, const Rect& b) {
	return memcmp(&a, &b, sizeof(a));
	}

	inline void clear() {
	left = top = right = bottom = 0.0f;
	}

	inline bool isEmpty() const {
	// this is written in such way this it'll handle NANs to return
	// true (empty)
	return !((left < right) && (top < bottom));
	}

	inline void setEmpty() {
	left = top = right = bottom = 0.0f;
	}

	inline void set(float left, float top, float right, float bottom) {
	this->left = left;
	this->right = right;
	this->top = top;
	this->bottom = bottom;
	}

	inline void set(const Rect& r) {
	set(r.left, r.top, r.right, r.bottom);
	}

	inline void set(const SkIRect& r) {
	set(r.left(), r.top(), r.right(), r.bottom());
	}

	inline float getWidth() const {
	return right - left;
	}

	inline float getHeight() const {
	return bottom - top;
	}

	bool intersects(float l, float t, float r, float b) const {
	float tempLeft = std::max(left, l);
	float tempTop = std::max(top, t);
	float tempRight = std::min(right, r);
	float tempBottom = std::min(bottom, b);

	return ((tempLeft < tempRight) && (tempTop < tempBottom)); // !isEmpty
	}

	bool intersects(const Rect& r) const {
	return intersects(r.left, r.top, r.right, r.bottom);
	}

	/**
	* This method is named 'doIntersect' instead of 'intersect' so as not to be confused with
	* SkRect::intersect / android.graphics.Rect#intersect behavior, which do not modify the object
	* if the intersection of the rects would be empty.
	*/
	void doIntersect(float l, float t, float r, float b) {
	left = std::max(left, l);
	top = std::max(top, t);
	right = std::min(right, r);
	bottom = std::min(bottom, b);
	}

	void doIntersect(const Rect& r) {
	doIntersect(r.left, r.top, r.right, r.bottom);
	}

	inline bool contains(float l, float t, float r, float b) const {
	return l >= left && t >= top && r <= right && b <= bottom;
	}

	inline bool contains(const Rect& r) const {
	return contains(r.left, r.top, r.right, r.bottom);
	}

	bool unionWith(const Rect& r) {
	if (r.left < r.right && r.top < r.bottom) {
	if (left < right && top < bottom) {
	if (left > r.left) left = r.left;
	if (top > r.top) top = r.top;
	if (right < r.right) right = r.right;
	if (bottom < r.bottom) bottom = r.bottom;
	return true;
	} else {
	left = r.left;
	top = r.top;
	right = r.right;
	bottom = r.bottom;
	return true;
	}
	}
	return false;
	}

	void translate(float dx, float dy) {
	left += dx;
	right += dx;
	top += dy;
	bottom += dy;
	}

	void inset(float delta) {
	outset(-delta);
	}

	void outset(float delta) {
	left -= delta;
	top -= delta;
	right += delta;
	bottom += delta;
	}

	void outset(float xdelta, float ydelta) {
	left -= xdelta;
	top -= ydelta;
	right += xdelta;
	bottom += ydelta;
	}

	/**
	* Similar to snapToPixelBoundaries, but estimates bounds conservatively to handle GL rounding
	* errors.
	*
	* This function should be used whenever estimating the damage rect of geometry already mapped
	* into layer space.
	*/
	void snapGeometryToPixelBoundaries(bool snapOut) {
	if (snapOut) {
	/* For AA geometry with a ramp perimeter, don't snap by rounding - AA geometry will have
	* a 0.5 pixel perimeter not accounted for in its bounds. Instead, snap by
	* conservatively rounding out the bounds with floor/ceil.
	*
	* In order to avoid changing integer bounds with floor/ceil due to rounding errors
	* inset the bounds first by the fudge factor. Very small fraction-of-a-pixel errors
	* from this inset will only incur similarly small errors in output, due to transparency
	* in extreme outside of the geometry.
	*/
	left = floorf(left + Vertex::GeometryFudgeFactor());
	top = floorf(top + Vertex::GeometryFudgeFactor());
	right = ceilf(right - Vertex::GeometryFudgeFactor());
	bottom = ceilf(bottom - Vertex::GeometryFudgeFactor());
	} else {
	/* For other geometry, we do the regular rounding in order to snap, but also outset the
	* bounds by a fudge factor. This ensures that ambiguous geometry (e.g. a non-AA Rect
	* with top left at (0.5, 0.5)) will err on the side of a larger damage rect.
	*/
	left = floorf(left + 0.5f - Vertex::GeometryFudgeFactor());
	top = floorf(top + 0.5f - Vertex::GeometryFudgeFactor());
	right = floorf(right + 0.5f + Vertex::GeometryFudgeFactor());
	bottom = floorf(bottom + 0.5f + Vertex::GeometryFudgeFactor());
	}
	}

	void snapToPixelBoundaries() {
	left = floorf(left + 0.5f);
	top = floorf(top + 0.5f);
	right = floorf(right + 0.5f);
	bottom = floorf(bottom + 0.5f);
	}

	void roundOut() {
	left = floorf(left);
	top = floorf(top);
	right = ceilf(right);
	bottom = ceilf(bottom);
	}

	void expandToCoverVertex(float x, float y) {
	left = std::min(left, x);
	top = std::min(top, y);
	right = std::max(right, x);
	bottom = std::max(bottom, y);
	}

	void expandToCoverRect(float otherLeft, float otherTop, float otherRight, float otherBottom) {
	left = std::min(left, otherLeft);
	top = std::min(top, otherTop);
	right = std::max(right, otherRight);
	bottom = std::max(bottom, otherBottom);
	}

	SkRect toSkRect() const {
	return SkRect::MakeLTRB(left, top, right, bottom);
	}

	SkIRect toSkIRect() const {
	return SkIRect::MakeLTRB(left, top, right, bottom);
	}

	void dump(const char* label = nullptr) const {
	ALOGD("%s[l=%f t=%f r=%f b=%f]", label ? label : "Rect", left, top, right, bottom);
	}
	}; // class Rect

	}; // namespace uirenderer
	}; // namespace android

	#endif // ANDROID_HWUI_RECT_H