NeL: NLMISC::CAABBox class Reference

00061 : Center(0,0,0), HalfSize(0,0,0) {}
+

00060 {
+00061         CVector         hswap;
+00062 
+00063         // The bbox is back of the plane if only one of his vertex is in back.
+00064         if(p*(Center + HalfSize) < 0)   return true;
+00065         if(p*(Center - HalfSize) < 0)   return true;
+00066         hswap.set(-HalfSize.x, HalfSize.y, HalfSize.z);
+00067         if(p*(Center + hswap) < 0)      return true;
+00068         if(p*(Center - hswap) < 0)      return true;
+00069         hswap.set(HalfSize.x, -HalfSize.y, HalfSize.z);
+00070         if(p*(Center + hswap) < 0)      return true;
+00071         if(p*(Center - hswap) < 0)      return true;
+00072         hswap.set(HalfSize.x, HalfSize.y, -HalfSize.z);
+00073         if(p*(Center + hswap) < 0)      return true;
+00074         if(p*(Center - hswap) < 0)      return true;
+00075 
+00076         return false;
+00077 }
+

00040 {
+00041         CVector         hswap;
+00042 
+00043         // The bbox is front of the plane if only one of his vertex is in front.
+00044         if(p*(Center + HalfSize) > 0)   return true;
+00045         if(p*(Center - HalfSize) > 0)   return true;
+00046         hswap.set(-HalfSize.x, HalfSize.y, HalfSize.z);
+00047         if(p*(Center + hswap) > 0)      return true;
+00048         if(p*(Center - hswap) > 0)      return true;
+00049         hswap.set(HalfSize.x, -HalfSize.y, HalfSize.z);
+00050         if(p*(Center + hswap) > 0)      return true;
+00051         if(p*(Center - hswap) > 0)      return true;
+00052         hswap.set(HalfSize.x, HalfSize.y, -HalfSize.z);
+00053         if(p*(Center + hswap) > 0)      return true;
+00054         if(p*(Center - hswap) > 0)      return true;
+00055 
+00056         return false;
+00057 }
+

00157 {
+00158         // Trivial test. If both are in, they are inchanged
+00159         if(include(a) && include(b))
+00160                 return true;
+00161         // Else, must clip the segment againts the pyamid.
+00162         CPlane          planes[6];
+00163         makePyramid(planes);
+00164         CVector         p0=a , p1=b;
+00165         // clip the segment against all planes
+00166         for(uint i=0;i<6;i++)
+00167         {
+00168                 if(!planes[i].clipSegmentBack(p0, p1))
+00169                         return false;
+00170         }
+00171         // get result
+00172         a= p0;
+00173         b= p1;
+00174         return true;
+00175 }
+

00232 {       
+00233         CAABBox result;
+00234         CVector min, max;
+00235         CVector min1 = b1.getMin() 
+00236                     ,max1 = b1.getMax() 
+00237                         ,min2 = b2.getMin() 
+00238                     ,max2 = b2.getMax();
+00239         max.maxof(max1, max2);
+00240         min.minof(min1, min2);
+00241         result.setMinMax(min, max);
+00242         return result;
+00243 }
+

00248 {
+00249         CVector min1 = b1.getMin(), max1 = b1.getMax(),
+00250                         min2 = b2.getMin(), max2 = b2.getMax();
+00251         CVector minr, maxr;
+00252 
+00253         // don't test if intersect or not.
+00254         maxr.minof(max1, max2);
+00255         minr.maxof(min1, min2);
+00256 
+00257         setMinMax(minr, maxr);
+00258 }
+

00216 {
+00217         CVector         bmin= getMin(), bmax= getMax();
+00218 
+00219         bmin.minof(bmin, v);
+00220         bmax.maxof(bmax, v);
+00221         setMinMax(bmin, bmax);
+00222 }
+

00090 {return Center;}
+

00091 {return HalfSize;}
+

00089 {ret= Center+HalfSize;}
+

00087 {return Center+HalfSize;}
+

00088 {ret= Center-HalfSize;}
+

00086 {return Center-HalfSize;}
+

00096 {return HalfSize.norm();}
+

00094 {ret= HalfSize*2;}
+

00093 {return HalfSize*2;}
+

00095 {
+00096         if(Center.x+HalfSize.x < box.Center.x+box.HalfSize.x)   return false;
+00097         if(Center.x-HalfSize.x > box.Center.x-box.HalfSize.x)   return false;
+00098         if(Center.y+HalfSize.y < box.Center.y+box.HalfSize.y)   return false;
+00099         if(Center.y-HalfSize.y > box.Center.y-box.HalfSize.y)   return false;
+00100         if(Center.z+HalfSize.z < box.Center.z+box.HalfSize.z)   return false;
+00101         if(Center.z-HalfSize.z > box.Center.z-box.HalfSize.z)   return false;
+00102         return true;
+00103 }
+

00082 {
+00083         if(Center.x+HalfSize.x<a.x)     return false;
+00084         if(Center.x-HalfSize.x>a.x)     return false;
+00085         if(Center.y+HalfSize.y<a.y)     return false;
+00086         if(Center.y-HalfSize.y>a.y)     return false;
+00087         if(Center.z+HalfSize.z<a.z)     return false;
+00088         if(Center.z-HalfSize.z>a.z)     return false;
+00089         return true;
+00090 }
+

00138 {
+00139         // Trivial test.
+00140         if(include(a) || include(b))
+00141                 return true;
+00142         // Else, must test if the segment intersect the pyamid.
+00143         CPlane          planes[6];
+00144         makePyramid(planes);
+00145         CVector         p0=a , p1=b;
+00146         // clip the segment against all planes
+00147         for(uint i=0;i<6;i++)
+00148         {
+00149                 if(!planes[i].clipSegmentBack(p0, p1))
+00150                         return false;
+00151         }
+00152         return true;
+00153 }
+

00179 {
+00180         if (Center.x + HalfSize.x < s.Center.x - s.Radius) return false; 
+00181         if (Center.y + HalfSize.y < s.Center.y - s.Radius) return false; 
+00182         if (Center.z + HalfSize.z < s.Center.z - s.Radius) return false; 
+00183 
+00184         if (Center.x - HalfSize.x > s.Center.x + s.Radius) return false; 
+00185         if (Center.y - HalfSize.y > s.Center.y + s.Radius) return false; 
+00186         if (Center.z - HalfSize.z > s.Center.z + s.Radius) return false; 
+00187 
+00188         return true;
+00189 }
+

00122 {
+00123         // Trivial test.
+00124         if(include(a) || include(b) || include(c))
+00125                 return true;
+00126         // Else, must test if the polygon intersect the pyamid.
+00127         CPlane          planes[6];
+00128         makePyramid(planes);
+00129         CPolygon        poly(a,b,c);
+00130         poly.clip(planes, 6);
+00131         if(poly.getNumVertices()==0)
+00132                 return false;
+00133         return true;
+00134 }
+

00108 {
+00109         CVector mina = getMin(), maxa = getMax(),
+00110                         minb = box.getMin(), maxb = box.getMax();
+00111 
+00112         return ! ( mina.x > maxb.x ||
+00113                            mina.y > maxb.y ||
+00114                            mina.z > maxb.z ||
+00115                            minb.x > maxa.x ||
+00116                            minb.y > maxa.y ||
+00117                            minb.z > maxa.z);
+00118 }
+

00195 {
+00196         planes[0].make(CVector(-1,0,0), Center-HalfSize);
+00197         planes[1].make(CVector(+1,0,0), Center+HalfSize);
+00198         planes[2].make(CVector(0,-1,0), Center-HalfSize);
+00199         planes[3].make(CVector(0,+1,0), Center+HalfSize);
+00200         planes[4].make(CVector(0,0,-1), Center-HalfSize);
+00201         planes[5].make(CVector(0,0,+1), Center+HalfSize);
+00202 }
+

00207 {
+00208         (void)f.serialVersion(0);
+00209         f.serial(Center);
+00210         f.serial(HalfSize);
+00211 }
+

00066 {Center= center;}
+

00067 {HalfSize= hs;}
+

00072         {
+00073                 Center= (bmin+bmax)/2;
+00074                 HalfSize= bmax-Center;
+00075         }
+

00069 {HalfSize= s/2;}
+

00263 {
+00264         // TODO : optimize this a bit if possible...
+00265         CAABBox result; 
+00266 
+00267         /* OMG. Old code was false!!  
+00268                 if we have ht= M * h
+00269                 then CVector(-ht.x, ht.y, ht.z) != M * CVector(-h.x, h.y, h.z) !!!!
+00270         */
+00271         // compute corners.
+00272         CVector p[8];
+00273         CVector min= box.getMin();
+00274         CVector max= box.getMax();
+00275         p[0].set(min.x, min.y, min.z);
+00276         p[1].set(max.x, min.y, min.z);
+00277         p[2].set(min.x, max.y, min.z);
+00278         p[3].set(max.x, max.y, min.z);
+00279         p[4].set(min.x, min.y, max.z);
+00280         p[5].set(max.x, min.y, max.z);
+00281         p[6].set(min.x, max.y, max.z);
+00282         p[7].set(max.x, max.y, max.z);
+00283         CVector tmp;
+00284         min = max = mat * p[0];
+00285         // transform corners.
+00286         for(uint i=1;i<8;i++)
+00287         {
+00288                 tmp= mat * p[i];
+00289                 min.minof(min, tmp);
+00290                 max.maxof(max, tmp);
+00291         }
+00292 
+00293         result.setMinMax(min, max);
+00294         
+00295         return result;  
+00296 }
+


Clip
bool	clipBack (const CPlane &p) const
	Is the bbox partially in back of the plane??
bool	clipFront (const CPlane &p) const
	Is the bbox partially in front of the plane??
bool	clipSegment (CVector &a, CVector &b) const
	clip the segment by the bbox. return false if don't intersect. a and b are modified.
bool	include (const CAABBox &box) const
	Does the bbox include entirely this bbox.
bool	include (const CVector &a) const
	Does the bbox include this point.
bool	intersect (const CVector &a, const CVector &b) const
	Does the bbox instersect the segment AB.
bool	intersect (const CBSphere &s) const
	Does the bbox instersect the sphere s.
bool	intersect (const CVector &a, const CVector &b, const CVector &c) const
	Does the bbox intersect the triangle ABC.
bool	intersect (const CAABBox &box) const
	Does the bbox intersect the bbox box.
Misc
void	computeIntersection (const CAABBox &b1, const CAABBox &b2)
void	makePyramid (CPlane planes[6]) const
	Build the equivalent polytope of planes.
CAABBox	computeAABBoxUnion (const CAABBox &b1, const CAABBox &b2)
CAABBox	transformAABBox (const CMatrix &mat, const CAABBox &box)
Builds.
void	extend (const CVector &v)
void	setCenter (const CVector &center)
void	setHalfSize (const CVector &hs)
void	setMinMax (const CVector &bmin, const CVector &bmax)
	Build the bbox, with a min/max style bbox.
void	setSize (const CVector &s)
	Set the size of the bbox (ie 2* the halfSize).
Gets.
const CVector &	getCenter () const
const CVector &	getHalfSize () const
void	getMax (CVector &ret) const
CVector	getMax () const
void	getMin (CVector &ret) const
CVector	getMin () const
float	getRadius () const
	Return the radius of the bbox.
void	getSize (CVector &ret) const
CVector	getSize () const
	Return the size of the bbox.
Public Member Functions
	CAABBox ()
	Empty bbox Constructor. (for AABBoxExt::getRadius() correctness).
void	serial (NLMISC::IStream &f)
Protected Attributes
CVector	Center
	The center of the bbox.
CVector	HalfSize
	The size/2 of the bbox.

NLMISC::CAABBox Class Reference

Detailed Description

Clip

Misc

Builds.

Gets.

Public Member Functions

Protected Attributes

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation