G3D::Rect2D Class Reference

#include <Rect2D.h>

Public Member Functions
	Rect2D (const Any &any)
Any	toAny () const
	Rect2D (const Rect2D &r)
	Rect2D ()
bool	isEmpty () const
	Rect2D (const Vector2 &wh)
Vector2	extent () const
Point2	randomPoint () const
	Uniformly random point on the interior. More...
float	width () const
float	height () const
float	x0 () const
float	x1 () const
float	y0 () const
float	y1 () const
Point2	x0y0 () const
Point2	x1y0 () const
Point2	x0y1 () const
Point2	x1y1 () const
Vector2	wh () const
Point2	center () const
float	area () const
bool	isFinite () const
Rect2D	lerp (const Rect2D &other, float alpha) const
bool	contains (const Point2 &v) const
bool	contains (const Rect2D &r) const
bool	intersects (const Rect2D &r) const
bool	intersectsOrTouches (const Rect2D &r) const
Rect2D	operator* (float s) const
Rect2D	operator* (const Vector2 &s) const
Rect2D	operator/ (float s) const
Rect2D	operator/ (const Vector2 &s) const
Rect2D	operator+ (const Vector2 &v) const
Rect2D	operator- (const Vector2 &v) const
bool	operator== (const Rect2D &other) const
bool	operator!= (const Rect2D &other) const
void	serialize (class BinaryOutput &b) const
void	deserialize (class BinaryInput &b)
Point2	corner (int i) const
Rect2D	border (float delta) const
Rect2D	expand (float delta) const
void	merge (const Rect2D &other)
	Rect2D (const Rect2D &a, const Rect2D &b)
template<class T >
void	clip (const Array< T > &inPoly, Array< T > &outPoly) const
Rect2D	largestCenteredSubRect (float ww, float hh) const
Rect2D	intersect (const Rect2D &other) const

Static Public Member Functions
static const Rect2D &	empty ()
static Rect2D	xyxy (float x0, float y0, float x1, float y1)
static Rect2D	xyxy (const Point2 &v0, const Point2 &v1)
static Rect2D	xywh (float x, float y, float w, float h)
static Rect2D	xywh (const Point2 &v, const Vector2 &w)
static Rect2D	inf ()

Private Member Functions
	Rect2D (bool)

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

Private Attributes
Point2	min
Point2	max

Detailed Description

If you are using this class for pixel rectangles, keep in mind that the last pixel you can draw to is at x0() + width() - 1.

Constructor & Destructor Documentation

G3D::Rect2D::Rect2D ( bool  )

inlineprivate

Uninitialized constructor

{}

G3D::Rect2D::Rect2D

(

const Any &

any

)

Parameters

any	Must either Rect2D::xywh(#, #, #, #) or Rect2D::xyxy(#, #, #, #)

 {
 if (any.name() == "Rect2D::empty" || any.name() == "AABox2D::empty") {
 *this = empty();
 return;
 }

 any.verifyName("Rect2D::xyxy", "Rect2D::xywh");
 any.verifyType(Any::ARRAY);
 any.verifySize(4);
 if (any.name() == "Rect2D::xywh") {
 *this = Rect2D::xywh(any[0], any[1], any[2], any[3]);
 } else {
 *this = Rect2D::xyxy(any[0], any[1], any[2], any[3]);
 }
}

Here is the call graph for this function:

G3D::Rect2D::Rect2D ( const Rect2D &  r )

inline

: min(r.min), max(r.max) {}

G3D::Rect2D::Rect2D ( )

inline

Creates the empty set rectangle.

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

G3D::Rect2D::Rect2D ( const Vector2 &  wh )

inline

Creates a rectangle at 0,0 with the given width and height

: min(0, 0), max(wh.x, wh.y) {}

G3D::Rect2D::Rect2D ( const Rect2D &  a, const Rect2D &  b  )

inline

Computes a rectangle that contains both a and b. Note that even if or has zero area, its origin will be included.

 {
 *this = a;
 merge(b);
 }

Here is the call graph for this function:

Member Function Documentation

float G3D::Rect2D::area ( ) const

inline

 {
 return width() * height();
 }

Here is the call graph for this function:

Rect2D G3D::Rect2D::border ( float  delta ) const

inline

Deprecated:

See also

expand()

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

Here is the call graph for this function:

Point2 G3D::Rect2D::center ( ) const

inline

 {
 return (max + min) * 0.5;
 }

template<class T >

void G3D::Rect2D::clip ( const Array< T > &  inPoly, Array< T > &  outPoly  ) const

inline

Clips so that the rightmost point of the outPoly is at rect.x1 (e.g. a 800x600 window produces rightmost point 799, not 800). The results are suitable for pixel rendering if iRounded. Templated so that it will work for Vector2,3,4 (the z and w components are interpolated linearly). The template parameter must define T.lerp and contain x and y components.

If the entire polygon is clipped by a single side, the result will be empty. The result might also have zero area but not be empty.

 {

 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();
 }
 }

Here is the call graph for this function:

template<class T >

static bool G3D::Rect2D::clipSide2D ( const float  p, bool  clipGreater, int  axis, const Array< T > &  inPoly, Array< T > &  outPoly  )

inlinestaticprivate

Returns true if the whole polygon is clipped.

Parameters

p	Value of the point
axis	Index [0 or 1] of the axis to clip along?
clipGreater	Are we clipping greater than or less than the line?
inPoly	Polygon being clipped
outPoly	The clipped polygon

 {

 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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::Rect2D::contains ( const Point2 &  v ) const

inline

 {
 // 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 G3D::Rect2D::contains ( const Rect2D &  r ) const

inline

 {
 // 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);
 }

Point2 G3D::Rect2D::corner ( int  i ) const

inline

Returns the corners in the order: (min,min), (max,min), (max,max), (min,max).

 {
 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);
 }
 }

Here is the caller graph for this function:

void G3D::Rect2D::deserialize

(

class BinaryInput &

b

)

 {
 min.deserialize(b);
 max.deserialize(b);
}

Here is the call graph for this function:

const Rect2D & G3D::Rect2D::empty ( )

static

 {
 static Rect2D r;
 return r;
}

Here is the caller graph for this function:

Rect2D G3D::Rect2D::expand ( float  delta ) const

inline

Returns a new Rect2D that is bigger/smaller by the specified amount (negative is shrink.)

 {
 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);
 }

Here is the call graph for this function:

Vector2 G3D::Rect2D::extent ( ) const

inline

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

Here is the call graph for this function:

float G3D::Rect2D::height ( ) const

inline

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

Here is the call graph for this function:

Here is the caller graph for this function:

static Rect2D G3D::Rect2D::inf ( )

inlinestatic

Constructs a Rect2D with infinite boundaries. Use isFinite() to test either min or max.

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

Here is the call graph for this function:

Rect2D G3D::Rect2D::intersect ( const Rect2D &  other ) const

inline

Returns the overlap region between the two rectangles. This may have zero area if they do not intersect. See the two-Rect2D constructor and merge() for a way to compute a union-like rectangle.

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

Here is the call graph for this function:

bool G3D::Rect2D::intersects ( const Rect2D &  r ) const

inline

True if there is non-zero area to the intersection between this and r. Note that two rectangles that are adjacent do not intersect because there is zero area to the overlap, even though one of them "contains" the corners of the other.

 {
 // 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);
 }

Here is the caller graph for this function:

bool G3D::Rect2D::intersectsOrTouches ( const Rect2D &  r ) const

inline

Like intersection, but counts the adjacent case as touching.

 {
 // 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 G3D::Rect2D::isEmpty ( ) const

inline

Returns true if this is the empty set, which is distinct from a zero-area rectangle.

 {
 return min.isNaN() && max.isNaN();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::Rect2D::isFinite ( ) const

inline

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

Here is the call graph for this function:

Rect2D G3D::Rect2D::largestCenteredSubRect ( float  ww, float  hh  ) const

inline

Returns the largest, centered Rect2D that can fit inside this while maintaining the aspect ratio of x:y. Convenient for displaying images in odd-shaped windows.

 {
 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);
 }
 }

Here is the call graph for this function:

Rect2D G3D::Rect2D::lerp ( const Rect2D &  other, float  alpha  ) const

inline

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

 return out;
 }

Here is the call graph for this function:

void G3D::Rect2D::merge ( const Rect2D &  other )

inline

 {
 if (isEmpty()) {
 *this = other;
 } else if (! other.isEmpty()) {
 min = min.min(other.min);
 max = max.max(other.max);
 }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::Rect2D::operator!= ( const Rect2D &  other ) const

inline

 {
 return (min != other.min) || (max != other.max);
 }

Rect2D G3D::Rect2D::operator* ( float  s ) const

inline

 {
 return xyxy(min.x * s, min.y * s, max.x * s, max.y * s);
 }

Here is the call graph for this function:

Rect2D G3D::Rect2D::operator* ( const Vector2 &  s ) const

inline

 {
 return xyxy(min * s, max * s);
 }

Here is the call graph for this function:

Rect2D G3D::Rect2D::operator+ ( const Vector2 &  v ) const

inline

 {
 return xyxy(min + v, max + v);
 }

Here is the call graph for this function:

Rect2D G3D::Rect2D::operator- ( const Vector2 &  v ) const

inline

 {
 return xyxy(min - v, max - v);
 }

Here is the call graph for this function:

Rect2D G3D::Rect2D::operator/ ( float  s ) const

inline

 {
 return xyxy(min / s, max / s);
 }

Here is the call graph for this function:

Rect2D G3D::Rect2D::operator/ ( const Vector2 &  s ) const

inline

 {
 return xyxy(min / s, max / s);
 }

Here is the call graph for this function:

bool G3D::Rect2D::operator== ( const Rect2D &  other ) const

inline

 {
 return (min == other.min) && (max == other.max);
 }

Point2 G3D::Rect2D::randomPoint ( ) const

inline

Uniformly random point on the interior.

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

Here is the call graph for this function:

void G3D::Rect2D::serialize

(

class BinaryOutput &

b

)

const

 {
 min.serialize(b);
 max.serialize(b);
}

Here is the call graph for this function:

Any G3D::Rect2D::toAny

(

)

const

Converts the Rect2D to an Any.

 {
 if (isEmpty()) {
 return Any(Any::ARRAY, "Rect2D::empty");
 } else {
 Any any(Any::ARRAY, "Rect2D::xywh");
 any.append(Any(x0()), Any(y0()), Any(width()), Any(height()));
 return any;
 }
}

Here is the call graph for this function:

Vector2 G3D::Rect2D::wh ( ) const

inline

Width and height

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

Here is the call graph for this function:

float G3D::Rect2D::width ( ) const

inline

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

Here is the call graph for this function:

Here is the caller graph for this function:

float G3D::Rect2D::x0 ( ) const

inline

 {
 return min.x;
 }

Here is the caller graph for this function:

Point2 G3D::Rect2D::x0y0 ( ) const

inline

Min, min corner

 {
 return min;
 }

Point2 G3D::Rect2D::x0y1 ( ) const

inline

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

float G3D::Rect2D::x1 ( ) const

inline

 {
 return max.x;
 }

Here is the caller graph for this function:

Point2 G3D::Rect2D::x1y0 ( ) const

inline

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

Point2 G3D::Rect2D::x1y1 ( ) const

inline

Max,max corner

 {
 return max;
 }

static Rect2D G3D::Rect2D::xywh ( float  x, float  y, float  w, float  h  )

inlinestatic

 {
 return xyxy(x, y, x + w, y + h);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static Rect2D G3D::Rect2D::xywh ( const Point2 &  v, const Vector2 &  w  )

inlinestatic

 {
 return xyxy(v.x, v.y, v.x + w.x, v.y + w.y);
 }

Here is the call graph for this function:

static Rect2D G3D::Rect2D::xyxy ( float  x0, float  y0, float  x1, float  y1  )

inlinestatic

 {
 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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static Rect2D G3D::Rect2D::xyxy ( const Point2 &  v0, const Point2 &  v1  )

inlinestatic

 {
 Rect2D r(false);

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

 return r;
 }

Here is the call graph for this function:

float G3D::Rect2D::y0 ( ) const

inline

 {
 return min.y;
 }

Here is the caller graph for this function:

float G3D::Rect2D::y1 ( ) const

inline

 {
 return max.y;
 }

Here is the caller graph for this function:

Member Data Documentation

Point2 G3D::Rect2D::max

private

Point2 G3D::Rect2D::min

private

---

The documentation for this class was generated from the following files:

• dep/g3dlite/include/G3D/Rect2D.h
• dep/g3dlite/source/Rect2D.cpp