G3D::Box2D Class Reference

#include <Box2D.h>

Public Member Functions
	Box2D (const Vector2 &center=Vector2(0, 0), float w=0, float h=0, float angle=0)
	Box2D (const AABox2D &b)
	Box2D (const Vector2 &min, const Vector2 &max)
	Box2D (const CFrame &frame, Box2D &b)
bool	contains (const Vector2 &v) const
const Vector2 &	extent () const
	Distance from corner(0) to the next corner along the box's local axis a. More...
const Vector2 &	axis (int a) const
	Unit length vector along axis a. More...
float	area () const
	Surface area. More...
const Vector2 &	corner (int i) const
const Vector2 &	center () const
bool	overlaps (const Box2D &other) const

Private Member Functions
bool	overlaps1Way (const Box2D &other) const
void	computeAxes ()

Private Attributes
Vector2	m_corner [4]
Vector2	m_axisin [2]
Vector2	m_axis [2]
Vector2	m_center
float	origin [2]
float	m_area
Vector2	m_extent

Detailed Description

2D oriented box [http://www.flipcode.com/archives/2D_OBB_Intersection.shtml]

Constructor & Destructor Documentation

G3D::Box2D::Box2D	(	const Vector2 &	center = Vector2(0, 0),
		float	w = 0,
		float	h = 0,
		float	angle = 0
	)

Parameters

center	World-space center
w	Width along object-space x-axis
h	Height along object-space y-axis
angle	Counter-clockwise angle from object-space x-axis in radians

 {
 Vector2 X( cos(angle), sin(angle));
 Vector2 Y(-sin(angle), cos(angle));
 
 X *= w / 2;
 Y *= h / 2;
 
 m_corner[0] = center - X - Y;
 m_corner[1] = center + X - Y;
 m_corner[2] = center + X + Y;
 m_corner[3] = center - X + Y;
 
 computeAxes();
}

Here is the call graph for this function:

Here is the caller graph for this function:

G3D::Box2D::Box2D

(

const AABox2D &

b

)

 {
 for (int i = 0; i < 4; ++i) {
 m_corner[i] = b.corner(i);
 }
 
 computeAxes();
}

Here is the call graph for this function:

G3D::Box2D::Box2D	(	const Vector2 &	min,
		const Vector2 &	max
	)

 {
 *this = Box2D(Rect2D::xyxy(min, max));
}

Here is the call graph for this function:

G3D::Box2D::Box2D	(	const CFrame &	frame,
		Box2D &	b
	)

Transform b by frame, discarding the Z components, and compute the new box.

 {
 for (int i = 0; i < 4; ++i) {
 m_corner[i] = frame.pointToWorldSpace(Vector3(b.corner(i), 0)).xy();
 }
 computeAxes();
}

Here is the call graph for this function:

Member Function Documentation

float G3D::Box2D::area ( ) const

inline

Surface area.

 {
 return m_area;
 }

const Vector2& G3D::Box2D::axis ( int  a ) const

inline

Unit length vector along axis a.

 {
 debugAssert(a == 0 || a == 1);
 return m_axis[a];
 }

const Vector2& G3D::Box2D::center ( ) const

inline

 {
 return m_center;
 }

void G3D::Box2D::computeAxes ( )

private

Updates the axes after the m_corners move. Assumes the m_corners actually form a rectangle.

 {
 m_axis[0] = m_corner[1] - m_corner[0]; 
 m_axis[1] = m_corner[3] - m_corner[0]; 
 
 // Make the length of each m_axisin = 1/edge length so we know any
 // dot product must be less than 1 to fall within the edge.
 float len[2];
 for (int a = 0; a < 2; ++a) {
 float lenSq = m_axis[a].squaredLength();
 m_axisin[a] = m_axis[a] / lenSq;
 origin[a] = m_corner[0].dot(m_axisin[a]);
 len[a] = sqrt(lenSq); 
 m_axis[a] /= len[a];
 }

 // w * h
 m_area = len[0] * len[1];
 
 
 m_center = (m_corner[0] + m_corner[2]) * 0.5f;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::Box2D::contains ( const Vector2 &  v ) const

inline

 {
 // Take to object space:
 const Vector2& p = v - m_center;
 float x = p.dot(m_axisin[0]);
 float y = p.dot(m_axisin[1]);

 // Must be within extent/2 on both axes in object space
 return (abs(x) <= 0.5f) && (abs(y) <= 0.5f); 
 }

Here is the call graph for this function:

const Vector2& G3D::Box2D::corner ( int  i ) const

inline

 {
 debugAssert(i >=0 && i <= 3);
 return m_corner[i];
 }

Here is the caller graph for this function:

const Vector2& G3D::Box2D::extent ( ) const

inline

Distance from corner(0) to the next corner along the box's local axis a.

 {
 return m_extent;
 }

bool G3D::Box2D::overlaps ( const Box2D &  other ) const

inline

Returns true if the intersection of the boxes is non-empty.

 {
 return overlaps1Way(other) && other.overlaps1Way(*this);
 }

Here is the call graph for this function:

bool G3D::Box2D::overlaps1Way ( const Box2D &  other ) const

private

Returns true if other overlaps one dimension of this.

 {
 for (int a = 0; a < 2; ++a) {
 
 float t = other.m_corner[0].dot(m_axisin[a]);

 // Find the extent of box 2 on m_axisin a
 float tMin = t;
 float tMax = t;
 
 for (int c = 1; c < 4; ++c) {
 t = other.m_corner[c].dot(m_axisin[a]);
 
 if (t < tMin) {
 tMin = t;
 } else if (t > tMax) {
 tMax = t;
 }
 }
 
 // We have to subtract off the origin
 
 // See if [tMin, tMax] intersects [0, 1]
 if ((tMin > 1 + origin[a]) || (tMax < origin[a])) {
 // There was no intersection along this dimension;
 // the boxes cannot possibly overlap.
 return false;
 }
 }
 
 // There was no dimension along which there is no intersection.
 // Therefore the boxes overlap.
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

float G3D::Box2D::m_area

private

Surface area

Vector2 G3D::Box2D::m_axis[2]

private

Two edges of the box extended away from corner[0], with unit length

Vector2 G3D::Box2D::m_axisin[2]

private

Two edges of the box extended away from corner[0], with length = 1 / extentSquared

Vector2 G3D::Box2D::m_center

private

Centroid of the box

Vector2 G3D::Box2D::m_corner[4]

private

Corners of the box, where 0 is the lower left.

Vector2 G3D::Box2D::m_extent

private

float G3D::Box2D::origin[2]

private

origin[a] = m_corner[0].dot(m_axisin[a]);

---

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

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