OgreAxisAlignedBox.h
Go to the documentation of this file.

    00001 /*
    00002 -----------------------------------------------------------------------------
    00003 This source file is part of OGRE
    00004 (Object-oriented Graphics Rendering Engine)
    00005 For the latest info, see http://www.ogre3d.org/
    00006
    00007 Copyright (c) 2000-2012 Torus Knot Software Ltd
    00008
    00009 Permission is hereby granted, free of charge, to any person obtaining a copy
    00010 of this software and associated documentation files (the "Software"), to deal
    00011 in the Software without restriction, including without limitation the rights
    00012 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    00013 copies of the Software, and to permit persons to whom the Software is
    00014 furnished to do so, subject to the following conditions:
    00015
    00016 The above copyright notice and this permission notice shall be included in
    00017 all copies or substantial portions of the Software.
    00018
    00019 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    00020 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    00021 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    00022 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    00023 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    00024 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
    00025 THE SOFTWARE.
    00026 -----------------------------------------------------------------------------
    00027 */
    00028 #ifndef __AxisAlignedBox_H_
    00029 #define __AxisAlignedBox_H_
    00030
    00031 // Precompiler options
    00032 #include "OgrePrerequisites.h"
    00033
    00034 #include "OgreVector3.h"
    00035 #include "OgreMatrix4.h"
    00036
    00037 namespace Ogre {
    00054     class _OgreExport AxisAlignedBox
    00055     {
    00056     public:
    00057         enum Extent
    00058         {
    00059             EXTENT_NULL,
    00060             EXTENT_FINITE,
    00061             EXTENT_INFINITE
    00062         };
    00063     protected:
    00064
    00065         Vector3 mMinimum;
    00066         Vector3 mMaximum;
    00067         Extent mExtent;
    00068         mutable Vector3* mCorners;
    00069
    00070     public:
    00071         /*
    00072         1-----2
    00073         /|    /|
    00074         / |   / |
    00075         5-----4  |
    00076         |  0--|--3
    00077         | /   | /
    00078         |/    |/
    00079         6-----7
    00080         */
    00081         typedef enum {
    00082             FAR_LEFT_BOTTOM = 0,
    00083             FAR_LEFT_TOP = 1,
    00084             FAR_RIGHT_TOP = 2,
    00085             FAR_RIGHT_BOTTOM = 3,
    00086             NEAR_RIGHT_BOTTOM = 7,
    00087             NEAR_LEFT_BOTTOM = 6,
    00088             NEAR_LEFT_TOP = 5,
    00089             NEAR_RIGHT_TOP = 4
    00090         } CornerEnum;
    00091         inline AxisAlignedBox() : mMinimum(Vector3::ZERO), mMaximum(Vector3::UNIT_SCALE), mCorners(0)
    00092         {
    00093             // Default to a null box
    00094             setMinimum( -0.5, -0.5, -0.5 );
    00095             setMaximum( 0.5, 0.5, 0.5 );
    00096             mExtent = EXTENT_NULL;
    00097         }
    00098         inline AxisAlignedBox(Extent e) : mMinimum(Vector3::ZERO), mMaximum(Vector3::UNIT_SCALE), mCorners(0)
    00099         {
    00100             setMinimum( -0.5, -0.5, -0.5 );
    00101             setMaximum( 0.5, 0.5, 0.5 );
    00102             mExtent = e;
    00103         }
    00104
    00105         inline AxisAlignedBox(const AxisAlignedBox & rkBox) : mMinimum(Vector3::ZERO), mMaximum(Vector3::UNIT_SCALE), mCorners(0)
    00106
    00107         {
    00108             if (rkBox.isNull())
    00109                 setNull();
    00110             else if (rkBox.isInfinite())
    00111                 setInfinite();
    00112             else
    00113                 setExtents( rkBox.mMinimum, rkBox.mMaximum );
    00114         }
    00115
    00116         inline AxisAlignedBox( const Vector3& min, const Vector3& max ) : mMinimum(Vector3::ZERO), mMaximum(Vector3::UNIT_SCALE), mCorners(0)
    00117         {
    00118             setExtents( min, max );
    00119         }
    00120
    00121         inline AxisAlignedBox(
    00122             Real mx, Real my, Real mz,
    00123             Real Mx, Real My, Real Mz ) : mMinimum(Vector3::ZERO), mMaximum(Vector3::UNIT_SCALE), mCorners(0)
    00124         {
    00125             setExtents( mx, my, mz, Mx, My, Mz );
    00126         }
    00127
    00128         AxisAlignedBox& operator=(const AxisAlignedBox& rhs)
    00129         {
    00130             // Specifically override to avoid copying mCorners
    00131             if (rhs.isNull())
    00132                 setNull();
    00133             else if (rhs.isInfinite())
    00134                 setInfinite();
    00135             else
    00136                 setExtents(rhs.mMinimum, rhs.mMaximum);
    00137
    00138             return *this;
    00139         }
    00140
    00141         ~AxisAlignedBox()
    00142         {
    00143             if (mCorners)
    00144                 OGRE_FREE(mCorners, MEMCATEGORY_SCENE_CONTROL);
    00145         }
    00146
    00147
    00150         inline const Vector3& getMinimum(void) const
    00151         {
    00152             return mMinimum;
    00153         }
    00154
    00158         inline Vector3& getMinimum(void)
    00159         {
    00160             return mMinimum;
    00161         }
    00162
    00165         inline const Vector3& getMaximum(void) const
    00166         {
    00167             return mMaximum;
    00168         }
    00169
    00173         inline Vector3& getMaximum(void)
    00174         {
    00175             return mMaximum;
    00176         }
    00177
    00178
    00181         inline void setMinimum( const Vector3& vec )
    00182         {
    00183             mExtent = EXTENT_FINITE;
    00184             mMinimum = vec;
    00185         }
    00186
    00187         inline void setMinimum( Real x, Real y, Real z )
    00188         {
    00189             mExtent = EXTENT_FINITE;
    00190             mMinimum.x = x;
    00191             mMinimum.y = y;
    00192             mMinimum.z = z;
    00193         }
    00194
    00198         inline void setMinimumX(Real x)
    00199         {
    00200             mMinimum.x = x;
    00201         }
    00202
    00203         inline void setMinimumY(Real y)
    00204         {
    00205             mMinimum.y = y;
    00206         }
    00207
    00208         inline void setMinimumZ(Real z)
    00209         {
    00210             mMinimum.z = z;
    00211         }
    00212
    00215         inline void setMaximum( const Vector3& vec )
    00216         {
    00217             mExtent = EXTENT_FINITE;
    00218             mMaximum = vec;
    00219         }
    00220
    00221         inline void setMaximum( Real x, Real y, Real z )
    00222         {
    00223             mExtent = EXTENT_FINITE;
    00224             mMaximum.x = x;
    00225             mMaximum.y = y;
    00226             mMaximum.z = z;
    00227         }
    00228
    00232         inline void setMaximumX( Real x )
    00233         {
    00234             mMaximum.x = x;
    00235         }
    00236
    00237         inline void setMaximumY( Real y )
    00238         {
    00239             mMaximum.y = y;
    00240         }
    00241
    00242         inline void setMaximumZ( Real z )
    00243         {
    00244             mMaximum.z = z;
    00245         }
    00246
    00249         inline void setExtents( const Vector3& min, const Vector3& max )
    00250         {
    00251             assert( (min.x <= max.x && min.y <= max.y && min.z <= max.z) &&
    00252                 "The minimum corner of the box must be less than or equal to maximum corner" );
    00253
    00254             mExtent = EXTENT_FINITE;
    00255             mMinimum = min;
    00256             mMaximum = max;
    00257         }
    00258
    00259         inline void setExtents(
    00260             Real mx, Real my, Real mz,
    00261             Real Mx, Real My, Real Mz )
    00262         {
    00263             assert( (mx <= Mx && my <= My && mz <= Mz) &&
    00264                 "The minimum corner of the box must be less than or equal to maximum corner" );
    00265
    00266             mExtent = EXTENT_FINITE;
    00267
    00268             mMinimum.x = mx;
    00269             mMinimum.y = my;
    00270             mMinimum.z = mz;
    00271
    00272             mMaximum.x = Mx;
    00273             mMaximum.y = My;
    00274             mMaximum.z = Mz;
    00275
    00276         }
    00277
    00302         inline const Vector3* getAllCorners(void) const
    00303         {
    00304             assert( (mExtent == EXTENT_FINITE) && "Can't get corners of a null or infinite AAB" );
    00305
    00306             // The order of these items is, using right-handed co-ordinates:
    00307             // Minimum Z face, starting with Min(all), then anticlockwise
    00308             //   around face (looking onto the face)
    00309             // Maximum Z face, starting with Max(all), then anticlockwise
    00310             //   around face (looking onto the face)
    00311             // Only for optimization/compatibility.
    00312             if (!mCorners)
    00313                 mCorners = OGRE_ALLOC_T(Vector3, 8, MEMCATEGORY_SCENE_CONTROL);
    00314
    00315             mCorners[0] = mMinimum;
    00316             mCorners[1].x = mMinimum.x; mCorners[1].y = mMaximum.y; mCorners[1].z = mMinimum.z;
    00317             mCorners[2].x = mMaximum.x; mCorners[2].y = mMaximum.y; mCorners[2].z = mMinimum.z;
    00318             mCorners[3].x = mMaximum.x; mCorners[3].y = mMinimum.y; mCorners[3].z = mMinimum.z;
    00319
    00320             mCorners[4] = mMaximum;
    00321             mCorners[5].x = mMinimum.x; mCorners[5].y = mMaximum.y; mCorners[5].z = mMaximum.z;
    00322             mCorners[6].x = mMinimum.x; mCorners[6].y = mMinimum.y; mCorners[6].z = mMaximum.z;
    00323             mCorners[7].x = mMaximum.x; mCorners[7].y = mMinimum.y; mCorners[7].z = mMaximum.z;
    00324
    00325             return mCorners;
    00326         }
    00327
    00330         Vector3 getCorner(CornerEnum cornerToGet) const
    00331         {
    00332             switch(cornerToGet)
    00333             {
    00334             case FAR_LEFT_BOTTOM:
    00335                 return mMinimum;
    00336             case FAR_LEFT_TOP:
    00337                 return Vector3(mMinimum.x, mMaximum.y, mMinimum.z);
    00338             case FAR_RIGHT_TOP:
    00339                 return Vector3(mMaximum.x, mMaximum.y, mMinimum.z);
    00340             case FAR_RIGHT_BOTTOM:
    00341                 return Vector3(mMaximum.x, mMinimum.y, mMinimum.z);
    00342             case NEAR_RIGHT_BOTTOM:
    00343                 return Vector3(mMaximum.x, mMinimum.y, mMaximum.z);
    00344             case NEAR_LEFT_BOTTOM:
    00345                 return Vector3(mMinimum.x, mMinimum.y, mMaximum.z);
    00346             case NEAR_LEFT_TOP:
    00347                 return Vector3(mMinimum.x, mMaximum.y, mMaximum.z);
    00348             case NEAR_RIGHT_TOP:
    00349                 return mMaximum;
    00350             default:
    00351                 return Vector3();
    00352             }
    00353         }
    00354
    00355         _OgreExport friend std::ostream& operator<<( std::ostream& o, const AxisAlignedBox aab )
    00356         {
    00357             switch (aab.mExtent)
    00358             {
    00359             case EXTENT_NULL:
    00360                 o << "AxisAlignedBox(null)";
    00361                 return o;
    00362
    00363             case EXTENT_FINITE:
    00364                 o << "AxisAlignedBox(min=" << aab.mMinimum << ", max=" << aab.mMaximum << ")";
    00365                 return o;
    00366
    00367             case EXTENT_INFINITE:
    00368                 o << "AxisAlignedBox(infinite)";
    00369                 return o;
    00370
    00371             default: // shut up compiler
    00372                 assert( false && "Never reached" );
    00373                 return o;
    00374             }
    00375         }
    00376
    00380         void merge( const AxisAlignedBox& rhs )
    00381         {
    00382             // Do nothing if rhs null, or this is infinite
    00383             if ((rhs.mExtent == EXTENT_NULL) || (mExtent == EXTENT_INFINITE))
    00384             {
    00385                 return;
    00386             }
    00387             // Otherwise if rhs is infinite, make this infinite, too
    00388             else if (rhs.mExtent == EXTENT_INFINITE)
    00389             {
    00390                 mExtent = EXTENT_INFINITE;
    00391             }
    00392             // Otherwise if current null, just take rhs
    00393             else if (mExtent == EXTENT_NULL)
    00394             {
    00395                 setExtents(rhs.mMinimum, rhs.mMaximum);
    00396             }
    00397             // Otherwise merge
    00398             else
    00399             {
    00400                 Vector3 min = mMinimum;
    00401                 Vector3 max = mMaximum;
    00402                 max.makeCeil(rhs.mMaximum);
    00403                 min.makeFloor(rhs.mMinimum);
    00404
    00405                 setExtents(min, max);
    00406             }
    00407
    00408         }
    00409
    00412         inline void merge( const Vector3& point )
    00413         {
    00414             switch (mExtent)
    00415             {
    00416             case EXTENT_NULL: // if null, use this point
    00417                 setExtents(point, point);
    00418                 return;
    00419
    00420             case EXTENT_FINITE:
    00421                 mMaximum.makeCeil(point);
    00422                 mMinimum.makeFloor(point);
    00423                 return;
    00424
    00425             case EXTENT_INFINITE: // if infinite, makes no difference
    00426                 return;
    00427             }
    00428
    00429             assert( false && "Never reached" );
    00430         }
    00431
    00441         inline void transform( const Matrix4& matrix )
    00442         {
    00443             // Do nothing if current null or infinite
    00444             if( mExtent != EXTENT_FINITE )
    00445                 return;
    00446
    00447             Vector3 oldMin, oldMax, currentCorner;
    00448
    00449             // Getting the old values so that we can use the existing merge method.
    00450             oldMin = mMinimum;
    00451             oldMax = mMaximum;
    00452
    00453             // reset
    00454             setNull();
    00455
    00456             // We sequentially compute the corners in the following order :
    00457             // 0, 6, 5, 1, 2, 4 ,7 , 3
    00458             // This sequence allows us to only change one member at a time to get at all corners.
    00459
    00460             // For each one, we transform it using the matrix
    00461             // Which gives the resulting point and merge the resulting point.
    00462
    00463             // First corner
    00464             // min min min
    00465             currentCorner = oldMin;
    00466             merge( matrix * currentCorner );
    00467
    00468             // min,min,max
    00469             currentCorner.z = oldMax.z;
    00470             merge( matrix * currentCorner );
    00471
    00472             // min max max
    00473             currentCorner.y = oldMax.y;
    00474             merge( matrix * currentCorner );
    00475
    00476             // min max min
    00477             currentCorner.z = oldMin.z;
    00478             merge( matrix * currentCorner );
    00479
    00480             // max max min
    00481             currentCorner.x = oldMax.x;
    00482             merge( matrix * currentCorner );
    00483
    00484             // max max max
    00485             currentCorner.z = oldMax.z;
    00486             merge( matrix * currentCorner );
    00487
    00488             // max min max
    00489             currentCorner.y = oldMin.y;
    00490             merge( matrix * currentCorner );
    00491
    00492             // max min min
    00493             currentCorner.z = oldMin.z;
    00494             merge( matrix * currentCorner );
    00495         }
    00496
    00508         void transformAffine(const Matrix4& m)
    00509         {
    00510             assert(m.isAffine());
    00511
    00512             // Do nothing if current null or infinite
    00513             if ( mExtent != EXTENT_FINITE )
    00514                 return;
    00515
    00516             Vector3 centre = getCenter();
    00517             Vector3 halfSize = getHalfSize();
    00518
    00519             Vector3 newCentre = m.transformAffine(centre);
    00520             Vector3 newHalfSize(
    00521                 Math::Abs(m[0][0]) * halfSize.x + Math::Abs(m[0][1]) * halfSize.y + Math::Abs(m[0][2]) * halfSize.z,
    00522                 Math::Abs(m[1][0]) * halfSize.x + Math::Abs(m[1][1]) * halfSize.y + Math::Abs(m[1][2]) * halfSize.z,
    00523                 Math::Abs(m[2][0]) * halfSize.x + Math::Abs(m[2][1]) * halfSize.y + Math::Abs(m[2][2]) * halfSize.z);
    00524
    00525             setExtents(newCentre - newHalfSize, newCentre + newHalfSize);
    00526         }
    00527
    00530         inline void setNull()
    00531         {
    00532             mExtent = EXTENT_NULL;
    00533         }
    00534
    00537         inline bool isNull(void) const
    00538         {
    00539             return (mExtent == EXTENT_NULL);
    00540         }
    00541
    00544         bool isFinite(void) const
    00545         {
    00546             return (mExtent == EXTENT_FINITE);
    00547         }
    00548
    00551         inline void setInfinite()
    00552         {
    00553             mExtent = EXTENT_INFINITE;
    00554         }
    00555
    00558         bool isInfinite(void) const
    00559         {
    00560             return (mExtent == EXTENT_INFINITE);
    00561         }
    00562
    00564         inline bool intersects(const AxisAlignedBox& b2) const
    00565         {
    00566             // Early-fail for nulls
    00567             if (this->isNull() || b2.isNull())
    00568                 return false;
    00569
    00570             // Early-success for infinites
    00571             if (this->isInfinite() || b2.isInfinite())
    00572                 return true;
    00573
    00574             // Use up to 6 separating planes
    00575             if (mMaximum.x < b2.mMinimum.x)
    00576                 return false;
    00577             if (mMaximum.y < b2.mMinimum.y)
    00578                 return false;
    00579             if (mMaximum.z < b2.mMinimum.z)
    00580                 return false;
    00581
    00582             if (mMinimum.x > b2.mMaximum.x)
    00583                 return false;
    00584             if (mMinimum.y > b2.mMaximum.y)
    00585                 return false;
    00586             if (mMinimum.z > b2.mMaximum.z)
    00587                 return false;
    00588
    00589             // otherwise, must be intersecting
    00590             return true;
    00591
    00592         }
    00593
    00595         inline AxisAlignedBox intersection(const AxisAlignedBox& b2) const
    00596         {
    00597             if (this->isNull() || b2.isNull())
    00598             {
    00599                 return AxisAlignedBox();
    00600             }
    00601             else if (this->isInfinite())
    00602             {
    00603                 return b2;
    00604             }
    00605             else if (b2.isInfinite())
    00606             {
    00607                 return *this;
    00608             }
    00609
    00610             Vector3 intMin = mMinimum;
    00611             Vector3 intMax = mMaximum;
    00612
    00613             intMin.makeCeil(b2.getMinimum());
    00614             intMax.makeFloor(b2.getMaximum());
    00615
    00616             // Check intersection isn't null
    00617             if (intMin.x < intMax.x &&
    00618                 intMin.y < intMax.y &&
    00619                 intMin.z < intMax.z)
    00620             {
    00621                 return AxisAlignedBox(intMin, intMax);
    00622             }
    00623
    00624             return AxisAlignedBox();
    00625         }
    00626
    00628         Real volume(void) const
    00629         {
    00630             switch (mExtent)
    00631             {
    00632             case EXTENT_NULL:
    00633                 return 0.0f;
    00634
    00635             case EXTENT_FINITE:
    00636                 {
    00637                     Vector3 diff = mMaximum - mMinimum;
    00638                     return diff.x * diff.y * diff.z;
    00639                 }
    00640
    00641             case EXTENT_INFINITE:
    00642                 return Math::POS_INFINITY;
    00643
    00644             default: // shut up compiler
    00645                 assert( false && "Never reached" );
    00646                 return 0.0f;
    00647             }
    00648         }
    00649
    00651         inline void scale(const Vector3& s)
    00652         {
    00653             // Do nothing if current null or infinite
    00654             if (mExtent != EXTENT_FINITE)
    00655                 return;
    00656
    00657             // NB assumes centered on origin
    00658             Vector3 min = mMinimum * s;
    00659             Vector3 max = mMaximum * s;
    00660             setExtents(min, max);
    00661         }
    00662
    00664         bool intersects(const Sphere& s) const
    00665         {
    00666             return Math::intersects(s, *this);
    00667         }
    00669         bool intersects(const Plane& p) const
    00670         {
    00671             return Math::intersects(p, *this);
    00672         }
    00674         bool intersects(const Vector3& v) const
    00675         {
    00676             switch (mExtent)
    00677             {
    00678             case EXTENT_NULL:
    00679                 return false;
    00680
    00681             case EXTENT_FINITE:
    00682                 return(v.x >= mMinimum.x  &&  v.x <= mMaximum.x  &&
    00683                     v.y >= mMinimum.y  &&  v.y <= mMaximum.y  &&
    00684                     v.z >= mMinimum.z  &&  v.z <= mMaximum.z);
    00685
    00686             case EXTENT_INFINITE:
    00687                 return true;
    00688
    00689             default: // shut up compiler
    00690                 assert( false && "Never reached" );
    00691                 return false;
    00692             }
    00693         }
    00695         Vector3 getCenter(void) const
    00696         {
    00697             assert( (mExtent == EXTENT_FINITE) && "Can't get center of a null or infinite AAB" );
    00698
    00699             return Vector3(
    00700                 (mMaximum.x + mMinimum.x) * 0.5f,
    00701                 (mMaximum.y + mMinimum.y) * 0.5f,
    00702                 (mMaximum.z + mMinimum.z) * 0.5f);
    00703         }
    00705         Vector3 getSize(void) const
    00706         {
    00707             switch (mExtent)
    00708             {
    00709             case EXTENT_NULL:
    00710                 return Vector3::ZERO;
    00711
    00712             case EXTENT_FINITE:
    00713                 return mMaximum - mMinimum;
    00714
    00715             case EXTENT_INFINITE:
    00716                 return Vector3(
    00717                     Math::POS_INFINITY,
    00718                     Math::POS_INFINITY,
    00719                     Math::POS_INFINITY);
    00720
    00721             default: // shut up compiler
    00722                 assert( false && "Never reached" );
    00723                 return Vector3::ZERO;
    00724             }
    00725         }
    00727         Vector3 getHalfSize(void) const
    00728         {
    00729             switch (mExtent)
    00730             {
    00731             case EXTENT_NULL:
    00732                 return Vector3::ZERO;
    00733
    00734             case EXTENT_FINITE:
    00735                 return (mMaximum - mMinimum) * 0.5;
    00736
    00737             case EXTENT_INFINITE:
    00738                 return Vector3(
    00739                     Math::POS_INFINITY,
    00740                     Math::POS_INFINITY,
    00741                     Math::POS_INFINITY);
    00742
    00743             default: // shut up compiler
    00744                 assert( false && "Never reached" );
    00745                 return Vector3::ZERO;
    00746             }
    00747         }
    00748
    00751         bool contains(const Vector3& v) const
    00752         {
    00753             if (isNull())
    00754                 return false;
    00755             if (isInfinite())
    00756                 return true;
    00757
    00758             return mMinimum.x <= v.x && v.x <= mMaximum.x &&
    00759                    mMinimum.y <= v.y && v.y <= mMaximum.y &&
    00760                    mMinimum.z <= v.z && v.z <= mMaximum.z;
    00761         }
    00762
    00764         Real distance(const Vector3& v) const
    00765         {
    00766
    00767             if (this->contains(v))
    00768                 return 0;
    00769             else
    00770             {
    00771                 Real maxDist = std::numeric_limits<Real>::min();
    00772
    00773                 if (v.x < mMinimum.x)
    00774                     maxDist = std::max(maxDist, mMinimum.x - v.x);
    00775                 if (v.y < mMinimum.y)
    00776                     maxDist = std::max(maxDist, mMinimum.y - v.y);
    00777                 if (v.z < mMinimum.z)
    00778                     maxDist = std::max(maxDist, mMinimum.z - v.z);
    00779
    00780                 if (v.x > mMaximum.x)
    00781                     maxDist = std::max(maxDist, v.x - mMaximum.x);
    00782                 if (v.y > mMaximum.y)
    00783                     maxDist = std::max(maxDist, v.y - mMaximum.y);
    00784                 if (v.z > mMaximum.z)
    00785                     maxDist = std::max(maxDist, v.z - mMaximum.z);
    00786
    00787                 return maxDist;
    00788             }
    00789         }
    00790
    00793         bool contains(const AxisAlignedBox& other) const
    00794         {
    00795             if (other.isNull() || this->isInfinite())
    00796                 return true;
    00797
    00798             if (this->isNull() || other.isInfinite())
    00799                 return false;
    00800
    00801             return this->mMinimum.x <= other.mMinimum.x &&
    00802                    this->mMinimum.y <= other.mMinimum.y &&
    00803                    this->mMinimum.z <= other.mMinimum.z &&
    00804                    other.mMaximum.x <= this->mMaximum.x &&
    00805                    other.mMaximum.y <= this->mMaximum.y &&
    00806                    other.mMaximum.z <= this->mMaximum.z;
    00807         }
    00808
    00811         bool operator== (const AxisAlignedBox& rhs) const
    00812         {
    00813             if (this->mExtent != rhs.mExtent)
    00814                 return false;
    00815
    00816             if (!this->isFinite())
    00817                 return true;
    00818
    00819             return this->mMinimum == rhs.mMinimum &&
    00820                    this->mMaximum == rhs.mMaximum;
    00821         }
    00822
    00825         bool operator!= (const AxisAlignedBox& rhs) const
    00826         {
    00827             return !(*this == rhs);
    00828         }
    00829
    00830         // special values
    00831         static const AxisAlignedBox BOX_NULL;
    00832         static const AxisAlignedBox BOX_INFINITE;
    00833
    00834
    00835     };
    00836
    00839 } // namespace Ogre
    00840
    00841 #endif

Copyright © 2012 Torus Knot Software Ltd
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.
Last modified Sun Sep 2 2012 07:27:20