Rect2D.h

Go to the documentation of this file.

#ifndef G3D_Rect2D_h
#define G3D_Rect2D_h

// Linux defines this as a macro
#ifdef border
#undef border
#endif

#include "G3D/platform.h"
#include "G3D/Array.h"
#include "G3D/Vector2.h"

#ifdef _MSC_VER
// Turn off "conditional expression is constant" warning; MSVC generates this
// for debug assertions in inlined methods.
# pragma warning (disable : 4127)
#endif


namespace G3D {

class Any;

class Rect2D {
private:
 Point2 min, max;

 template<class T>
 static bool clipSide2D(
 const float p, bool clipGreater, int axis, 
 const Array<T>& inPoly, Array<T>& outPoly) {

 outPoly.clear();
 int i0 = -1;

 Vector2 pt1;
 bool c1 = true;

 float negate = clipGreater ? -1 : 1;

 // Find a point that is not clipped
 for (i0 = 0; (i0 < inPoly.length()) && c1; ++i0) {
 pt1 = inPoly[i0]; 
 c1 = (negate * pt1[axis]) < (negate * p);
 }

 // We incremented i0 one time to many
 --i0;

 if (c1) {
 // We could not find an unclipped point
 return true;
 }

 outPoly.append(pt1);

 // for each point in inPoly,
 // if the point is outside the side and the previous one was also outside, continue
 // if the point is outside the side and the previous one was inside, cut the line
 // if the point is inside the side and the previous one was also inside, append the points
 // if the point is inside the side and the previous one was outside, cut the line 
 for (int i = 1; i <= inPoly.length(); ++i) {
 T pt2 = inPoly[(i + i0) % inPoly.length()];
 bool c2 = (negate * pt2[axis]) < (negate * p);

 if (c1 ^ c2) {

 if (!c1 && c2 && (i > 1)) {
 // Unclipped to clipped trasition and not the first iteration
 outPoly.append(pt1);
 }

 // only one point is clipped, find where the line crosses the clipping plane


 float alpha;
 if (pt2[axis] == pt1[axis]) {
 alpha = 0;
 } else {
 alpha = (p - pt1[axis]) / (pt2[axis] - pt1[axis]);
 }
 outPoly.append(pt1.lerp(pt2, alpha));
 } else if (! (c1 || c2) && (i != 1)) {
 // neither point is clipped (don't do this the first time 
 // because we appended the first pt before the loop)
 outPoly.append(pt1);
 }
 
 pt1 = pt2;
 c1 = c2;
 }

 return false;
 }

 Rect2D(bool /*b*/) {}
public:

 Rect2D(const Any& any);
 
 Any toAny() const;

 Rect2D(const Rect2D& r) : min(r.min), max(r.max) {}

 Rect2D() : min(fnan(), fnan()), max(fnan(), fnan()) {}

 static const Rect2D& empty();

 inline bool isEmpty() const {
 return min.isNaN() && max.isNaN();
 }

 Rect2D(const Vector2& wh) : min(0, 0), max(wh.x, wh.y) {}

 Vector2 extent() const {
 if (isEmpty()) {
 return Vector2::zero();
 } else {
 return max - min;
 }
 }

 Point2 randomPoint() const {
 return Point2(uniformRandom(0, max.x - min.x) + min.x,
 uniformRandom(0, max.y - min.y) + min.y);
 }

 float width() const {
 if (isEmpty()) {
 return 0;
 } else {
 return max.x - min.x;
 }
 }

 float height() const {
 if (isEmpty()) {
 return 0;
 } else {
 return max.y - min.y;
 }
 }

 float x0() const {
 return min.x;
 }

 float x1() const {
 return max.x;
 }

 float y0() const {
 return min.y;
 }

 float y1() const {
 return max.y;
 }

 Point2 x0y0() const {
 return min;
 }

 Point2 x1y0() const {
 return Point2(max.x, min.y);
 }

 Point2 x0y1() const {
 return Point2(min.x, max.y);
 }

 Point2 x1y1() const {
 return max;
 }

 Vector2 wh() const {
 if (isEmpty()) {
 return Vector2::zero();
 } else {
 return max - min;
 }
 }

 Point2 center() const {
 return (max + min) * 0.5;
 }

 float area() const {
 return width() * height();
 }

 bool isFinite() const {
 return (min.isFinite() && max.isFinite());
 }

 Rect2D lerp(const Rect2D& other, float alpha) const {
 Rect2D out(false);
 
 out.min = min.lerp(other.min, alpha);
 out.max = max.lerp(other.max, alpha);

 return out;
 }

 static Rect2D xyxy(float x0, float y0, float x1, float y1) {
 Rect2D r(false);
 
 r.min.x = G3D::min(x0, x1);
 r.min.y = G3D::min(y0, y1);
 r.max.x = G3D::max(x0, x1);
 r.max.y = G3D::max(y0, y1);

 return r;
 }

 static Rect2D xyxy(const Point2& v0, const Point2& v1) {
 Rect2D r(false);

 r.min = v0.min(v1);
 r.max = v0.max(v1);

 return r;
 }

 static Rect2D xywh(float x, float y, float w, float h) {
 return xyxy(x, y, x + w, y + h);
 }

 static Rect2D xywh(const Point2& v, const Vector2& w) {
 return xyxy(v.x, v.y, v.x + w.x, v.y + w.y);
 }

 static Rect2D inf() {
 return xyxy(Vector2::inf(), Vector2::inf());
 }

 bool contains(const Point2& v) const {
 // This will automatically return false if isEmpty()
 return (v.x >= min.x) && (v.y >= min.y) && (v.x <= max.x) && (v.y <= max.y);
 }

 bool contains(const Rect2D& r) const {
 // This will automatically return false if isEmpty()
 return (min.x <= r.min.x) && (min.y <= r.min.y) &&
 (max.x >= r.max.x) && (max.y >= r.max.y);
 }

 bool intersects(const Rect2D& r) const {
 // This will automatically return false if isEmpty()
 return (min.x < r.max.x) && (min.y < r.max.y) &&
 (max.x > r.min.x) && (max.y > r.min.y);
 }

 bool intersectsOrTouches(const Rect2D& r) const {
 // This will automatically return false if isEmpty()
 return (min.x <= r.max.x) && (min.y <= r.max.y) &&
 (max.x >= r.min.x) && (max.y >= r.min.y);
 }

 Rect2D operator*(float s) const {
 return xyxy(min.x * s, min.y * s, max.x * s, max.y * s);
 }

 Rect2D operator*(const Vector2& s) const {
 return xyxy(min * s, max * s);
 }

 Rect2D operator/(float s) const {
 return xyxy(min / s, max / s);
 }

 Rect2D operator/(const Vector2& s) const {
 return xyxy(min / s, max / s);
 }

 Rect2D operator+(const Vector2& v) const {
 return xyxy(min + v, max + v);
 }

 Rect2D operator-(const Vector2& v) const {
 return xyxy(min - v, max - v);
 }

 bool operator==(const Rect2D& other) const {
 return (min == other.min) && (max == other.max);
 }

 bool operator!=(const Rect2D& other) const {
 return (min != other.min) || (max != other.max);
 }

 void serialize(class BinaryOutput& b) const;

 void deserialize(class BinaryInput& b);

 Point2 corner(int i) const {
 debugAssert(i >= 0 && i < 4);
 switch (i & 3) {
 case 0:
 return Point2(min.x, min.y);
 case 1:
 return Point2(max.x, min.y);
 case 2:
 return Point2(max.x, max.y);
 case 3:
 return Point2(min.x, max.y);
 default:
 // Should never get here
 return Point2(0, 0);
 }
 }


 Rect2D border(float delta) const {
 return Rect2D::xywh(x0() + delta, 
 y0() + delta, 
 width() - 2.0f * delta, 
 height() - 2.0f * delta);
 }

 Rect2D expand(float delta) const {
 float newX = x0() - delta;
 float newY = y0() - delta;
 float newW = width() + 2.0f * delta;
 float newH = height() + 2.0f * delta;

 if (newW < 0.0f) {
 newX = (x0() + width()) / 2.0f;
 newW = 0.0f;
 }

 if (newH < 0.0f) {
 newY = (y0() + height()) / 2.0f;
 newH = 0.0f;
 }
 return Rect2D::xywh(newX, newY, newW, newH);
 }

 void merge(const Rect2D& other) {
 if (isEmpty()) {
 *this = other;
 } else if (! other.isEmpty()) {
 min = min.min(other.min);
 max = max.max(other.max);
 }
 }

 Rect2D(const Rect2D& a, const Rect2D& b) {
 *this = a;
 merge(b);
 }

 template<class T>
 void clip(const Array<T>& inPoly, Array<T>& outPoly) const {

 const bool greaterThan = true;
 const bool lessThan = false;
 const int X = 0;
 const int Y = 1;

 Array<T> temp;

 bool entirelyClipped =
 clipSide2D(x0(), lessThan, X, inPoly, temp) ||
 clipSide2D(x1(), greaterThan, X, temp, outPoly) ||
 clipSide2D(y0(), lessThan, Y, outPoly, temp) || 
 clipSide2D(y1(), greaterThan, Y, temp, outPoly);

 if (entirelyClipped) {
 outPoly.clear();
 }
 }


 Rect2D largestCenteredSubRect(float ww, float hh) const {
 float textureAspect = hh / ww;
 float viewAspect = height() / width();

 if (viewAspect > textureAspect) {
 // The view is too tall
 float h = width() * textureAspect;
 float y = (height() - h) / 2;
 return Rect2D::xywh(0, y, width(), h) + corner(0);
 } else {
 // The view is too wide
 float w = height() / textureAspect;
 float x = (width() - w) / 2;
 return Rect2D::xywh(x, 0, w, height()) + corner(0);
 }
 }

 Rect2D intersect(const Rect2D& other) const {
 if (intersects(other)) {
 return Rect2D::xyxy(min.max(other.min), max.min(other.max));
 } else {
 return empty();
 }
 }
};

typedef Rect2D AABox2D;
}

#endif