G3D::AABox Class Reference

#include <AABox.h>

Public Member Functions
	AABox ()
	AABox (const Point3 &v)
	AABox (const class Any &a)
Any	toAny () const
bool	isEmpty () const
	AABox (const Point3 &low, const Point3 &high)
AABox	operator* (float f) const
AABox	operator/ (float f) const
void	set (const Point3 &low, const Point3 &high)
void	merge (const AABox &a)
void	merge (const Point3 &a)
void	merge (const class Box &b)
void	serialize (class BinaryOutput &b) const
void	deserialize (class BinaryInput &b)
bool	isFinite () const
const Point3 &	low () const
const Point3 &	high () const
Point3	center () const
Point3	corner (int index) const
float	extent (int a) const
Vector3	extent () const
void	split (const Vector3::Axis &axis, float location, AABox &low, AABox &high) const
bool	culledBy (const Array< Plane > &plane, int32 &cullingPlaneIndex, const uint32 testMask, uint32 &childMask) const
bool	culledBy (const Array< Plane > &plane, int32 &cullingPlaneIndex=dummy, const uint32 testMask=0xFFFFFFFF) const
bool	contains (const AABox &other) const
bool	contains (const Point3 &point) const
float	area () const
float	volume () const
Point3	randomInteriorPoint () const
Point3	randomSurfacePoint () const
bool	intersects (const AABox &other) const
bool	intersects (const Sphere &other) const
AABox	intersect (const AABox &other) const
size_t	hashCode () const
bool	operator== (const AABox &b) const
bool	operator!= (const AABox &b) const
AABox	operator+ (const Vector3 &v) const
AABox	operator- (const Vector3 &v) const
void	getBounds (AABox &out) const
void	getBounds (Sphere &out) const

Static Public Member Functions
static const AABox &	maxFinite ()
static const AABox &	large ()
static const AABox &	inf ()
static const AABox &	zero ()
static const AABox &	empty ()

Private Attributes
Point3	lo
Point3	hi

Static Private Attributes
static int	dummy = 0

Friends
class	Intersect

Detailed Description

An axis-aligned box.

Constructor & Destructor Documentation

G3D::AABox::AABox ( )

inline

Creates the empty bounds, i.e., an empty set of points.

: lo(fnan(), fnan(), fnan()), hi(fnan(), fnan(), fnan()) {}

Here is the caller graph for this function:

G3D::AABox::AABox ( const Point3 &  v )

inlineexplicit

Constructs a zero-volume AABox at v.

 {
 lo = hi = v;
 }

G3D::AABox::AABox ( const class Any &  a )

explicit

Format is one of:

• AABox(lowpoint, highpoint)
• AABox(point)
• AABox::empty()
• AABox::inf()

G3D::AABox::AABox ( const Point3 &  low, const Point3 &  high  )

inline

Assumes that low is less than or equal to high along each dimension. To have this automatically enforced, use AABox(low.min(high), low.max(high));

 {
 set(low, high);
 }

Here is the call graph for this function:

Member Function Documentation

float G3D::AABox::area ( ) const

inline

 {
 if (isEmpty()) { return 0; }
 Vector3 diag = hi - lo;
 return 2.0f * (diag.x * diag.y + diag.y * diag.z + diag.x * diag.z);
 }

Here is the call graph for this function:

Point3 G3D::AABox::center ( ) const

inline

Returns the centroid of the box (NaN if empty)

 {
 return (lo + hi) * 0.5;
 }

Here is the caller graph for this function:

bool G3D::AABox::contains ( const AABox &  other ) const

inline

less than or equal to containment

 {
 return 
 (other.hi.x <= hi.x) &&
 (other.hi.y <= hi.y) &&
 (other.hi.z <= hi.z) &&
 (other.lo.x >= lo.x) &&
 (other.lo.y >= lo.y) &&
 (other.lo.z >= lo.z);
 }

Here is the caller graph for this function:

bool G3D::AABox::contains ( const Point3 &  point ) const

inline

 {
 return
 (point.x >= lo.x) &&
 (point.y >= lo.y) &&
 (point.z >= lo.z) &&
 (point.x <= hi.x) &&
 (point.y <= hi.y) &&
 (point.z <= hi.z);
 }

Vector3 G3D::AABox::corner

(

int

index

)

const

 {

 // default constructor inits all components to 0
 Vector3 v;

 switch (index)
 {
 case 0:
 v.x = lo.x;
 v.y = lo.y;
 v.z = hi.z;
 break;

 case 1:
 v.x = hi.x;
 v.y = lo.y;
 v.z = hi.z;
 break;

 case 2:
 v.x = hi.x;
 v.y = hi.y;
 v.z = hi.z;
 break;

 case 3:
 v.x = lo.x;
 v.y = hi.y;
 v.z = hi.z;
 break;

 case 4:
 v.x = lo.x;
 v.y = lo.y;
 v.z = lo.z;
 break;

 case 5:
 v.x = hi.x;
 v.y = lo.y;
 v.z = lo.z;
 break;

 case 6:
 v.x = hi.x;
 v.y = hi.y;
 v.z = lo.z;
 break;

 case 7:
 v.x = lo.x;
 v.y = hi.y;
 v.z = lo.z;
 break;

 default:
 debugAssertM(false, "Invalid corner index");
 break;
 }

 return v;
}

Here is the caller graph for this function:

bool G3D::AABox::culledBy	(	const Array< Plane > &	plane,
		int32 &	cullingPlaneIndex,
		const uint32	testMask,
		uint32 &	childMask
	)		const

Conservative culling test for up to 32 planes. Returns true if there exists a plane[p] for which the entire object is in the negative half space (opposite the plane normal).

testMask and childMask are used for optimizing bounding volume hierarchies. The version of this method that produces childMask is slower than the version without; it should only be used for parent nodes.

Parameters

cullingPlaneIndex	The index of the first plane for which the entire object is in the negative half-space. The function exits early when one plane is found. -1 when the function returns false (i.e. when no plane culls the whole object).
testMask	If bit p is 0, the bounding volume automatically passes the culling test for plane[p] (i.e. it is known that the volume is entirely within the positive half space). The function must return false if testMask is 0 and test all planes when testMask is -1 (0xFFFFFFFF).
childMask	Test mask for the children of this volume.

Here is the caller graph for this function:

bool G3D::AABox::culledBy	(	const Array< Plane > &	plane,
		int32 &	cullingPlaneIndex = dummy,
		const uint32	testMask = 0xFFFFFFFF
	)		const

Conservative culling test that does not produce a mask for children.

void G3D::AABox::deserialize

(

class BinaryInput &

b

)

 {
 lo = b.readVector3();
 hi = b.readVector3();
}

Here is the call graph for this function:

Here is the caller graph for this function:

const AABox & G3D::AABox::empty ( )

static

 {
 static const AABox b;
 return b;
}

Here is the caller graph for this function:

float G3D::AABox::extent ( int  a ) const

inline

Distance from corner(0) to the next corner along axis a.

 {
 if (isEmpty()) {
 return 0.0f;
 }
 debugAssert(a < 3);
 return hi[a] - lo[a];
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Vector3 G3D::AABox::extent ( ) const

inline

 {
 if (isEmpty()) {
 return Vector3::zero();
 }
 return hi - lo;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::AABox::getBounds ( AABox &  out ) const

inline

 {
 out = *this;
 }

Here is the caller graph for this function:

void G3D::AABox::getBounds

(

Sphere &

out

)

const

 {
 s.center = center();
 s.radius = extent().length() / 2;
}

Here is the call graph for this function:

size_t G3D::AABox::hashCode ( ) const

inline

 {
 return lo.hashCode() + hi.hashCode();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const Point3& G3D::AABox::high ( ) const

inline

Returns not-a-number if empty

 {
 return hi;
 }

Here is the caller graph for this function:

const AABox & G3D::AABox::inf ( )

static

 {
 static const AABox b = AABox(-Vector3::inf(), Vector3::inf());
 return b;
}

Here is the call graph for this function:

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

inline

Return the intersection of the two boxes

 {
 if (isEmpty() || other.isEmpty()) {
 return empty();
 }

 const Point3& H = hi.min(other.hi);
 const Point3& L = lo.max(other.lo).min(H);

 if (H.x < L.x && H.y < L.y && H.z < L.z) {
 return empty();
 } else {
 return AABox(L, H);
 }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::AABox::intersects

(

const AABox &

other

)

const

Returns true if there is any overlap

 {
 // Must be overlap along all three axes.
 // Try to find a separating axis.

 for (int a = 0; a < 3; ++a) {

 // |--------|
 // |------|

 if ((lo[a] > other.hi[a]) ||
 (hi[a] < other.lo[a])) {
 return false;
 }
 }

 return true;
}

Here is the caller graph for this function:

bool G3D::AABox::intersects

(

const Sphere &

other

)

const

Returns true if there is any overlap. [Jim] Arvo's algorithm from Graphics Gems II

 {
 double d = 0; 

 //find the square of the distance
 //from the sphere to the box
 for (int i = 0; i < 3; ++i) {
 if (sphere.center[i] < lo[i]) {
 d += square(sphere.center[i] - lo[i]);
 } else if (sphere.center[i] > hi[i]) {
 d += square(sphere.center[i] - hi[i]);
 }
 }

 return d <= square(sphere.radius);
}

Here is the call graph for this function:

bool G3D::AABox::isEmpty ( ) const

inline

 {
 return lo.isNaN();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::AABox::isFinite ( ) const

inline

 {
 return isEmpty() || (lo.isFinite() && hi.isFinite());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const AABox & G3D::AABox::large ( )

static

A large finite box. This is smaller than FLT_MAX because it leaves room to add boxes together.

 {
 static const AABox b = AABox(Vector3::minFinite() * 0.5f, 
 Vector3::maxFinite() * 0.5f);
 return b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const Point3& G3D::AABox::low ( ) const

inline

Returns not-a-number if empty

 {
 return lo;
 }

Here is the caller graph for this function:

const AABox & G3D::AABox::maxFinite ( )

static

The largest possible finite box.

 {
 static const AABox b = AABox(Vector3::minFinite(), 
 Vector3::maxFinite());
 return b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::AABox::merge ( const AABox &  a )

inline

Grows to include the bounds of a

 {
 if (isEmpty()) {
 lo = a.lo;
 hi = a.hi;
 } else if (! a.isEmpty()) {
 lo = lo.min(a.lo);
 hi = hi.max(a.hi);
 }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::AABox::merge ( const Point3 &  a )

inline

 {
 if (isEmpty()) {
 lo = hi = a;
 } else {
 lo = lo.min(a);
 hi = hi.max(a);
 }
 }

Here is the call graph for this function:

void G3D::AABox::merge

(

const class Box &

b

)

bool G3D::AABox::operator!= ( const AABox &  b ) const

inline

 {
 if (isEmpty()) {
 return b.isEmpty();
 } else {
 return !((lo == b.lo) && (hi == b.hi));
 }
 }

Here is the call graph for this function:

AABox G3D::AABox::operator* ( float  f ) const

inline

 {
 if (f < 0) {
 return AABox(hi * f, lo * f);
 } else {
 return AABox(lo * f, hi * f);
 }
 }

Here is the call graph for this function:

AABox G3D::AABox::operator+ ( const Vector3 &  v ) const

inline

 {
 AABox out;
 out.lo = lo + v;
 out.hi = hi + v;
 return out;
 }

AABox G3D::AABox::operator- ( const Vector3 &  v ) const

inline

 {
 AABox out;
 out.lo = lo - v;
 out.hi = hi - v;
 return out;
 }

AABox G3D::AABox::operator/ ( float  f ) const

inline

 {
 return *this * (1.0f / f);
 }

bool G3D::AABox::operator== ( const AABox &  b ) const

inline

 {
 if (isEmpty() && b.isEmpty()) {
 return true;
 } else {
 return (lo == b.lo) && (hi == b.hi);
 }
 }

Here is the call graph for this function:

Vector3 G3D::AABox::randomInteriorPoint

(

)

const

 {
 return Vector3(
 (float)uniformRandom(lo.x, hi.x), 
 (float)uniformRandom(lo.y, hi.y), 
 (float)uniformRandom(lo.z, hi.z));
}

Here is the call graph for this function:

Vector3 G3D::AABox::randomSurfacePoint

(

)

const

 {
 Vector3 extent = hi - lo;
 float aXY = extent.x * extent.y;
 float aYZ = extent.y * extent.z;
 float aZX = extent.z * extent.x;

 float r = (float)uniformRandom(0.0f, aXY + aYZ + aZX);

 // Choose evenly between positive and negative face planes
 float d = ((float)uniformRandom(0, 1) < 0.5f) ? 0.0f : 1.0f;

 // The probability of choosing a given face is proportional to
 // its area.
 if (r < aXY) {
 return 
 lo + 
 Vector3(
 (float)uniformRandom(0.0f, extent.x),
 (float)uniformRandom(0.0f, extent.y),
 d * extent.z);
 } else if (r < aYZ) {
 return 
 lo + 
 Vector3(
 d * extent.x,
 (float)uniformRandom(0, extent.y),
 (float)uniformRandom(0, extent.z));
 } else {
 return 
 lo + 
 Vector3(
 (float)uniformRandom(0, extent.x),
 d * extent.y,
 (float)uniformRandom(0, extent.z));
 }
}

Here is the call graph for this function:

void G3D::AABox::serialize

(

class BinaryOutput &

b

)

const

 {
 b.writeVector3(lo);
 b.writeVector3(hi);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::AABox::set ( const Point3 &  low, const Point3 &  high  )

inline

Assumes that low is less than or equal to high along each dimension.

 {
 debugAssert(
 (low.x <= high.x) &&
 (low.y <= high.y) &&
 (low.z <= high.z));
 debugAssert(! low.isNaN() && ! high.isNaN());
 lo = low;
 hi = high;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::AABox::split	(	const Vector3::Axis &	axis,
		float	location,
		AABox &	low,
		AABox &	high
	)		const

Splits the box into two AABoxes along the specified axis. low contains the part that was closer to negative infinity along axis, high contains the other part. Either may have zero volume.

 {
 // Low, medium, and high along the chosen axis
 float L = G3D::min(location, lo[axis]);
 float M = G3D::min(G3D::max(location, lo[axis]), hi[axis]);
 float H = G3D::max(location, hi[axis]);

 // Copy over this box.
 high = low = *this;

 // Now move the split points along the special axis
 low.lo[axis] = L;
 low.hi[axis] = M;
 high.lo[axis] = M;
 high.hi[axis] = H;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Any G3D::AABox::toAny

(

)

const

 {
 if (isEmpty()) {
 return Any(Any::ARRAY, "AABox::empty");
 } else if (! isFinite()) {
 return Any(Any::ARRAY, "AABox::inf");
 } else {
 Any a(Any::ARRAY, "AABox");
 if (lo == hi) {
 a.append(lo);
 } else {
 a.append(lo, hi);
 }
 return a;
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

float G3D::AABox::volume ( ) const

inline

 {
 if (isEmpty()) { return 0; }
 Vector3 diag = hi - lo;
 return diag.x * diag.y * diag.z;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const AABox & G3D::AABox::zero ( )

static

 {
 static const AABox b = AABox(Vector3::zero(), Vector3::zero());
 return b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

friend class Intersect

friend

Member Data Documentation

int G3D::AABox::dummy = 0

staticprivate

Optional argument placeholder

Point3 G3D::AABox::hi

private

NaN if empty

Point3 G3D::AABox::lo

private

NaN if empty

---

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

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