AABox.h

Go to the documentation of this file.

#ifndef G3D_AABox_h
#define G3D_AABox_h

#include "G3D/platform.h"
#include "G3D/debug.h"
#include "G3D/Array.h"
#include "G3D/Plane.h"
#include "G3D/Sphere.h"
#include "G3D/Vector3.h"

namespace G3D {

class Any;

class AABox {
private:
 friend class Intersect;

 static int dummy;

 Point3 lo;

 Point3 hi;

public:

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

 explicit AABox(const Point3& v) {
 lo = hi = v;
 }

 explicit AABox(const class Any& a);

 Any toAny() const;
 
 bool isEmpty() const {
 return lo.isNaN();
 }

 AABox(const Point3& low, const Point3& high) {
 set(low, high);
 }

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

 AABox operator/(float f) const {
 return *this * (1.0f / f);
 }

 inline void set(const Point3& low, const Point3& high) {
 debugAssert(
 (low.x <= high.x) &&
 (low.y <= high.y) &&
 (low.z <= high.z));
 debugAssert(! low.isNaN() && ! high.isNaN());
 lo = low;
 hi = high;
 }

 inline void merge(const AABox& a) {
 if (isEmpty()) {
 lo = a.lo;
 hi = a.hi;
 } else if (! a.isEmpty()) {
 lo = lo.min(a.lo);
 hi = hi.max(a.hi);
 }
 }

 inline void merge(const Point3& a) {
 if (isEmpty()) {
 lo = hi = a;
 } else {
 lo = lo.min(a);
 hi = hi.max(a);
 }
 }

 void merge(const class Box& b);

 void serialize(class BinaryOutput& b) const;
 
 void deserialize(class BinaryInput& b);

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

 inline const Point3& low() const {
 return lo;
 }

 inline const Point3& high() const {
 return hi;
 }

 static const AABox& maxFinite();

 static const AABox& large();

 static const AABox& inf();

 static const AABox& zero();

 static const AABox& empty();

 inline Point3 center() const {
 return (lo + hi) * 0.5;
 }

 Point3 corner(int index) const;

 inline float extent(int a) const {
 if (isEmpty()) {
 return 0.0f;
 }
 debugAssert(a < 3);
 return hi[a] - lo[a];
 }


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


 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;

 inline bool contains(const AABox& other) const {
 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);
 }

 inline bool contains(const Point3& point) const {
 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);
 }

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

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

 Point3 randomInteriorPoint() const;

 Point3 randomSurfacePoint() const;

 bool intersects(const AABox& other) const;

 bool intersects(const Sphere& other) const;

 AABox intersect(const AABox& other) const {
 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);
 }
 }

 inline size_t hashCode() const {
 return lo.hashCode() + hi.hashCode();
 }

 inline bool operator==(const AABox& b) const {
 if (isEmpty() && b.isEmpty()) {
 return true;
 } else {
 return (lo == b.lo) && (hi == b.hi);
 }
 }

 inline bool operator!=(const AABox& b) const {
 if (isEmpty()) {
 return b.isEmpty();
 } else {
 return !((lo == b.lo) && (hi == b.hi));
 }
 }

 inline AABox operator+(const Vector3& v) const {
 AABox out;
 out.lo = lo + v;
 out.hi = hi + v;
 return out;
 }

 inline AABox operator-(const Vector3& v) const {
 AABox out;
 out.lo = lo - v;
 out.hi = hi - v;
 return out;
 }

 void getBounds(AABox& out) const {
 out = *this;
 }

 void getBounds(Sphere& out) const;
};

}

template <> struct HashTrait<G3D::AABox> {
 static size_t hashCode(const G3D::AABox& key) { return key.hashCode(); }
};



#endif