csgeom/box.h Source File (Crystal Space 2.0 Public API Reference)

| ## Public API Reference

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

csgeom/box.h
Go to the documentation of this file.

    00001 /*
    00002     Copyright (C) 1998-2002 by Jorrit Tyberghein
    00003     Largely rewritten by Ivan Avramovic <ivan@avramovic.com>
    00004
    00005     This library is free software; you can redistribute it and/or
    00006     modify it under the terms of the GNU Library General Public
    00007     License as published by the Free Software Foundation; either
    00008     version 2 of the License, or (at your option) any later version.
    00009
    00010     This library is distributed in the hope that it will be useful,
    00011     but WITHOUT ANY WARRANTY; without even the implied warranty of
    00012     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    00013     Library General Public License for more details.
    00014
    00015     You should have received a copy of the GNU Library General Public
    00016     License along with this library; if not, write to the Free
    00017     Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
    00018 */
    00019
    00020 #ifndef __CS_BOX_H__
    00021 #define __CS_BOX_H__
    00022
    00030 #include "csextern.h"
    00031 #include "cstypes.h"    // for bool
    00032
    00033 #include "csgeom/csrect.h"
    00034 #include "csgeom/math.h"
    00035 #include "csgeom/matrix4.h"
    00036 #include "csgeom/vector2.h"
    00037 #include "csgeom/vector3.h"
    00038 #include "csgeom/segment.h"
    00039
    00040 #include "csutil/array.h"
    00041
    00042 class csPoly2D;
    00043 class csString;
    00044 class csTransform;
    00045
    00050 #define CS_BOUNDINGBOX_MAXVALUE 1000000000.
    00051
    00055 enum
    00056 {
    00058   CS_BOX_CORNER_xy = 0,
    00060   CS_BOX_CORNER_xY = 1,
    00062   CS_BOX_CORNER_Xy = 2,
    00064   CS_BOX_CORNER_XY = 3,
    00066   CS_BOX_CENTER2 = 4
    00067 };
    00074 enum
    00075 {
    00077   CS_BOX_EDGE_xy_Xy = 0,
    00079   CS_BOX_EDGE_Xy_xy = 1,
    00081   CS_BOX_EDGE_Xy_XY = 2,
    00083   CS_BOX_EDGE_XY_Xy = 3,
    00085   CS_BOX_EDGE_XY_xY = 4,
    00087   CS_BOX_EDGE_xY_XY = 5,
    00089   CS_BOX_EDGE_xY_xy = 6,
    00091   CS_BOX_EDGE_xy_xY = 7
    00092 };
    00102 class CS_CRYSTALSPACE_EXPORT csBox2
    00103 {
    00104 private:
    00105   struct bEdge
    00106   {
    00107     uint8 v1, v2; // Indices of vertex in bounding box (CS_BOX_CORNER_...)
    00108   };
    00109   // Index by edge number. Edge e and e+1 with e even are opposite edges.
    00110   // (CS_BOX_EDGE_...)
    00111   static const bEdge edges[8];
    00112
    00113 protected:
    00115   csVector2 minbox;
    00117   csVector2 maxbox;
    00118
    00119 public:
    00121   inline float MinX () const { return minbox.x; }
    00123   inline float MinY () const { return minbox.y; }
    00125   inline float MaxX () const { return maxbox.x; }
    00127   inline float MaxY () const { return maxbox.y; }
    00129   inline float Min (int idx) const { return idx ? minbox.y : minbox.x; }
    00131   inline float Max (int idx) const { return idx ? maxbox.y : maxbox.x; }
    00133   inline const csVector2& Min () const { return minbox; }
    00135   inline const csVector2& Max () const { return maxbox; }
    00137   inline float Area () const { return (MaxX()-MinX())*(MaxY()-MinY()); }
    00138
    00147   csVector2 GetCorner (int corner) const;
    00148
    00152   inline csVector2 GetCenter () const { return (minbox+maxbox)/2; }
    00153
    00158   void SetCenter (const csVector2& c);
    00159
    00163   void SetSize (const csVector2& s);
    00164
    00169   inline void GetEdgeInfo (int edge, int& v1, int& v2) const
    00170   {
    00171     v1 = edges[edge].v1;
    00172     v2 = edges[edge].v2;
    00173   }
    00174
    00179   inline csSegment2 GetEdge (int edge) const
    00180   {
    00181     return csSegment2 (GetCorner (edges[edge].v1), GetCorner (edges[edge].v2));
    00182   }
    00183
    00188   inline void GetEdge (int edge, csSegment2& e) const
    00189   {
    00190     e.SetStart (GetCorner (edges[edge].v1));
    00191     e.SetEnd (GetCorner (edges[edge].v2));
    00192   }
    00193
    00200   static bool Intersect (float minx, float miny, float maxx, float maxy,
    00201     csVector2* poly, int num_poly);
    00202
    00209   static inline bool Intersect (const csVector2& minbox, const csVector2& maxbox,
    00210     csVector2* poly, int num_poly)
    00211   {
    00212     return Intersect (minbox.x, minbox.y, maxbox.x, maxbox.y, poly, num_poly);
    00213   }
    00214
    00221   inline bool Intersect (csVector2* poly, int num_poly) const
    00222   {
    00223     return Intersect (minbox, maxbox, poly, num_poly);
    00224   }
    00225
    00227   inline bool In (float x, float y) const
    00228   {
    00229     if (x < minbox.x || x > maxbox.x) return false;
    00230     if (y < minbox.y || y > maxbox.y) return false;
    00231     return true;
    00232   }
    00233
    00235   inline bool In (const csVector2& v) const
    00236   {
    00237     return In (v.x, v.y);
    00238   }
    00239
    00241   inline bool Overlap (const csBox2& box) const
    00242   {
    00243     if (maxbox.x < box.minbox.x || minbox.x > box.maxbox.x) return false;
    00244     if (maxbox.y < box.minbox.y || minbox.y > box.maxbox.y) return false;
    00245     return true;
    00246   }
    00247
    00249   inline bool Contains (const csBox2& box) const
    00250   {
    00251     return (box.minbox.x >= minbox.x && box.maxbox.x <= maxbox.x) &&
    00252            (box.minbox.y >= minbox.y && box.maxbox.y <= maxbox.y);
    00253   }
    00254
    00256   inline bool Empty () const
    00257   {
    00258     if (minbox.x > maxbox.x) return true;
    00259     if (minbox.y > maxbox.y) return true;
    00260     return false;
    00261   }
    00262
    00268   float SquaredOriginDist () const;
    00269
    00275   float SquaredOriginMaxDist () const;
    00276
    00282   float SquaredPosDist (const csVector2& pos) const;
    00283
    00289   float SquaredPosMaxDist (const csVector2& pos) const;
    00290
    00292   inline void StartBoundingBox ()
    00293   {
    00294     minbox.x =  CS_BOUNDINGBOX_MAXVALUE;  minbox.y =  CS_BOUNDINGBOX_MAXVALUE;
    00295     maxbox.x = -CS_BOUNDINGBOX_MAXVALUE;  maxbox.y = -CS_BOUNDINGBOX_MAXVALUE;
    00296   }
    00297
    00299   inline void StartBoundingBox (const csVector2& v)
    00300   {
    00301     minbox = v;
    00302     maxbox = v;
    00303   }
    00304
    00306   inline void StartBoundingBox (float x, float y)
    00307   {
    00308     minbox.x = maxbox.x = x;
    00309     minbox.y = maxbox.y = y;
    00310   }
    00311
    00313   inline void AddBoundingVertex (float x, float y)
    00314   {
    00315     if (x < minbox.x) minbox.x = x;  if (x > maxbox.x) maxbox.x = x;
    00316     if (y < minbox.y) minbox.y = y;  if (y > maxbox.y) maxbox.y = y;
    00317   }
    00318
    00320   inline void AddBoundingVertex (const csVector2& v)
    00321   {
    00322     AddBoundingVertex (v.x, v.y);
    00323   }
    00324
    00330   inline void AddBoundingVertexSmart (float x, float y)
    00331   {
    00332     if (x < minbox.x) minbox.x = x; else if (x > maxbox.x) maxbox.x = x;
    00333     if (y < minbox.y) minbox.y = y; else if (y > maxbox.y) maxbox.y = y;
    00334   }
    00335
    00341   inline void AddBoundingVertexSmart (const csVector2& v)
    00342   {
    00343     AddBoundingVertexSmart (v.x, v.y);
    00344   }
    00345
    00350   inline bool AddBoundingVertexTest (float x, float y)
    00351   {
    00352     bool rc = false;
    00353     if (x < minbox.x) { minbox.x = x; rc = true; }
    00354     if (x > maxbox.x) { maxbox.x = x; rc = true; }
    00355     if (y < minbox.y) { minbox.y = y; rc = true; }
    00356     if (y > maxbox.y) { maxbox.y = y; rc = true; }
    00357     return rc;
    00358   }
    00359
    00364   inline bool AddBoundingVertexTest (const csVector2& v)
    00365   {
    00366     return AddBoundingVertexTest (v.x, v.y);
    00367   }
    00368
    00375   inline bool AddBoundingVertexSmartTest (float x, float y)
    00376   {
    00377     bool rc = false;
    00378     if (x < minbox.x) { minbox.x = x; rc = true; }
    00379     else if (x > maxbox.x) { maxbox.x = x; rc = true; }
    00380     if (y < minbox.y) { minbox.y = y; rc = true; }
    00381     else if (y > maxbox.y) { maxbox.y = y; rc = true; }
    00382     return rc;
    00383   }
    00384
    00391   inline bool AddBoundingVertexSmartTest (const csVector2& v)
    00392   {
    00393     return AddBoundingVertexSmartTest (v.x, v.y);
    00394   }
    00395
    00397   csBox2 () : minbox (CS_BOUNDINGBOX_MAXVALUE, CS_BOUNDINGBOX_MAXVALUE),
    00398              maxbox (-CS_BOUNDINGBOX_MAXVALUE, -CS_BOUNDINGBOX_MAXVALUE)
    00399   {}
    00400
    00402   csBox2 (const csVector2& v) : minbox (v.x, v.y), maxbox (v.x, v.y)
    00403   {}
    00404
    00406   csBox2 (float x1, float y1, float x2, float y2) :
    00407     minbox (x1, y1), maxbox (x2, y2)
    00408   { if (Empty ()) StartBoundingBox (); }
    00409
    00411   csBox2 (const csRect& r) : minbox (r.xmin, r.ymin), maxbox (r.xmax, r.ymax)
    00412   { }
    00413
    00415   inline void Set (const csVector2& bmin, const csVector2& bmax)
    00416   {
    00417     minbox = bmin;
    00418     maxbox = bmax;
    00419   }
    00420
    00422   inline void Set (float x1, float y1, float x2, float y2)
    00423   {
    00424     if (x1>x2 || y1>y2) StartBoundingBox();
    00425     else { minbox.x = x1;  minbox.y = y1;  maxbox.x = x2;  maxbox.y = y2; }
    00426   }
    00427
    00429   inline void SetMin (int idx, float val)
    00430   {
    00431     if (idx == 1) minbox.y = val;
    00432     else minbox.x = val;
    00433   }
    00434
    00436   inline void SetMax (int idx, float val)
    00437   {
    00438     if (idx == 1) maxbox.y = val;
    00439     else maxbox.x = val;
    00440   }
    00441
    00446   csString Description() const;
    00447
    00449   csBox2& operator+= (const csBox2& box);
    00451   csBox2& operator+= (const csVector2& point);
    00453   csBox2& operator*= (const csBox2& box);
    00455   bool TestIntersect (const csBox2& box) const;
    00456
    00458   friend CS_CRYSTALSPACE_EXPORT csBox2 operator+ (const csBox2& box1,
    00459     const csBox2& box2);
    00461   friend CS_CRYSTALSPACE_EXPORT csBox2 operator+ (const csBox2& box,
    00462     const csVector2& point);
    00464   friend CS_CRYSTALSPACE_EXPORT csBox2 operator* (const csBox2& box1,
    00465     const csBox2& box2);
    00466
    00468   friend CS_CRYSTALSPACE_EXPORT bool operator== (const csBox2& box1,
    00469     const csBox2& box2);
    00471   friend CS_CRYSTALSPACE_EXPORT bool operator!= (const csBox2& box1,
    00472     const csBox2& box2);
    00474   friend CS_CRYSTALSPACE_EXPORT bool operator< (const csBox2& box1,
    00475     const csBox2& box2);
    00477   friend CS_CRYSTALSPACE_EXPORT bool operator> (const csBox2& box1,
    00478     const csBox2& box2);
    00480   friend CS_CRYSTALSPACE_EXPORT bool operator< (const csVector2& point,
    00481     const csBox2& box);
    00482 };
    00483
    00488 enum
    00489 {
    00491   CS_BOX_CORNER_xyz = 0,
    00493   CS_BOX_CORNER_xyZ = 1,
    00495   CS_BOX_CORNER_xYz = 2,
    00497   CS_BOX_CORNER_xYZ = 3,
    00499   CS_BOX_CORNER_Xyz = 4,
    00501   CS_BOX_CORNER_XyZ = 5,
    00503   CS_BOX_CORNER_XYz = 6,
    00505   CS_BOX_CORNER_XYZ = 7,
    00507   CS_BOX_CENTER3 = 8
    00508 };
    00515 enum
    00516 {
    00518   CS_BOX_SIDE_x = 0,
    00520   CS_BOX_SIDE_X = 1,
    00522   CS_BOX_SIDE_y = 2,
    00524   CS_BOX_SIDE_Y = 3,
    00526   CS_BOX_SIDE_z = 4,
    00528   CS_BOX_SIDE_Z = 5,
    00530   CS_BOX_INSIDE = 6
    00531 };
    00538 enum
    00539 {
    00541   CS_BOX_EDGE_Xyz_xyz = 0,
    00543   CS_BOX_EDGE_xyz_Xyz = 1,
    00545   CS_BOX_EDGE_xyz_xYz = 2,
    00547   CS_BOX_EDGE_xYz_xyz = 3,
    00549   CS_BOX_EDGE_xYz_XYz = 4,
    00551   CS_BOX_EDGE_XYz_xYz = 5,
    00553   CS_BOX_EDGE_XYz_Xyz = 6,
    00555   CS_BOX_EDGE_Xyz_XYz = 7,
    00557   CS_BOX_EDGE_Xyz_XyZ = 8,
    00559   CS_BOX_EDGE_XyZ_Xyz = 9,
    00561   CS_BOX_EDGE_XyZ_XYZ = 10,
    00563   CS_BOX_EDGE_XYZ_XyZ = 11,
    00565   CS_BOX_EDGE_XYZ_XYz = 12,
    00567   CS_BOX_EDGE_XYz_XYZ = 13,
    00569   CS_BOX_EDGE_XYZ_xYZ = 14,
    00571   CS_BOX_EDGE_xYZ_XYZ = 15,
    00573   CS_BOX_EDGE_xYZ_xYz = 16,
    00575   CS_BOX_EDGE_xYz_xYZ = 17,
    00577   CS_BOX_EDGE_xYZ_xyZ = 18,
    00579   CS_BOX_EDGE_xyZ_xYZ = 19,
    00581   CS_BOX_EDGE_xyZ_xyz = 20,
    00583   CS_BOX_EDGE_xyz_xyZ = 21,
    00585   CS_BOX_EDGE_xyZ_XyZ = 22,
    00587   CS_BOX_EDGE_XyZ_xyZ = 23
    00588 };
    00598 class CS_CRYSTALSPACE_EXPORT csBox3
    00599 {
    00600 protected:
    00602   csVector3 minbox;
    00604   csVector3 maxbox;
    00608   struct bEdge
    00609   {
    00610     uint8 v1, v2; // Indices of vertex in bounding box (CS_BOX_CORNER_...)
    00611     uint8 fl, fr; // Indices of left/right faces sharing edge (CS_BOX_SIDE_...)
    00612   };
    00614   typedef uint8 bFace[4];
    00619   static const bEdge edges[24];
    00621   static const bFace faces[6];
    00623   struct Outline
    00624   {
    00625     int num;
    00626     int vertices[8];
    00627     int num_sides;
    00628     int sides[3];
    00629   };
    00631   static const Outline outlines[27];
    00632 public:
    00634   inline float MinX () const { return minbox.x; }
    00636   inline float MinY () const { return minbox.y; }
    00638   inline float MinZ () const { return minbox.z; }
    00640   inline float MaxX () const { return maxbox.x; }
    00642   inline float MaxY () const { return maxbox.y; }
    00644   inline float MaxZ () const { return maxbox.z; }
    00646   inline float Min (size_t idx) const
    00647   { return minbox[idx]; }
    00649   inline float Max (size_t idx) const
    00650   { return maxbox[idx]; }
    00652   inline const csVector3& Min () const { return minbox; }
    00654   inline const csVector3& Max () const { return maxbox; }
    00656   inline float Volume () const
    00657   { return (MaxX()-MinX())*(MaxY()-MinY())*(MaxZ()-MinZ()); }
    00659   inline float Area () const
    00660   {
    00661     float x = MaxX()-MinX();
    00662     float y = MaxY()-MinY();
    00663     float z = MaxZ()-MinZ();
    00664     return 2.0f*(x*y + x*z + y*z);
    00665   }
    00666
    00670   bool IsNaN () const
    00671   {
    00672     if (CS::IsNaN (minbox.x)) return true;
    00673     if (CS::IsNaN (minbox.y)) return true;
    00674     if (CS::IsNaN (minbox.z)) return true;
    00675     if (CS::IsNaN (maxbox.x)) return true;
    00676     if (CS::IsNaN (maxbox.y)) return true;
    00677     if (CS::IsNaN (maxbox.z)) return true;
    00678     return false;
    00679   }
    00680
    00690   csVector3 GetCorner (int corner) const;
    00691
    00697   inline void GetEdgeInfo (int edge, int& v1, int& v2, int& fleft, int& fright) const
    00698   {
    00699     v1 = edges[edge].v1;
    00700     v2 = edges[edge].v2;
    00701     fleft = edges[edge].fl;
    00702     fright = edges[edge].fr;
    00703   }
    00704
    00709   inline const uint8* GetFaceEdges (int face) const
    00710   {
    00711     return faces[face];
    00712   }
    00713
    00717   inline csVector3 GetCenter () const { return (minbox+maxbox)/2; }
    00718
    00723   void SetCenter (const csVector3& c);
    00724
    00728   void SetSize (const csVector3& s);
    00729
    00733   inline csVector3 GetSize () const { return (maxbox-minbox); }
    00734
    00739   csBox2 GetSide (int side) const;
    00740
    00746   void GetAxisPlane (int side, int& axis, float& where) const;
    00747
    00754   int GetVisibleSides (const csVector3& pos, int* visible_sides) const;
    00755
    00760   static inline int OtherSide (int side)
    00761   {
    00762     return side ^ 1;
    00763   }
    00764
    00770   inline csSegment3 GetEdge (int edge) const
    00771   {
    00772     return csSegment3 (GetCorner (edges[edge].v1), GetCorner (edges[edge].v2));
    00773   }
    00774
    00780   inline void GetEdge (int edge, csSegment3& e) const
    00781   {
    00782     e.SetStart (GetCorner (edges[edge].v1));
    00783     e.SetEnd (GetCorner (edges[edge].v2));
    00784   }
    00785
    00787   inline bool In (float x, float y, float z) const
    00788   {
    00789     if (x < minbox.x || x > maxbox.x) return false;
    00790     if (y < minbox.y || y > maxbox.y) return false;
    00791     if (z < minbox.z || z > maxbox.z) return false;
    00792     return true;
    00793   }
    00794
    00796   inline bool In (const csVector3& v) const
    00797   {
    00798     return In (v.x, v.y, v.z);
    00799   }
    00800
    00802   inline bool Overlap (const csBox3& box) const
    00803   {
    00804     if (maxbox.x < box.minbox.x || minbox.x > box.maxbox.x) return false;
    00805     if (maxbox.y < box.minbox.y || minbox.y > box.maxbox.y) return false;
    00806     if (maxbox.z < box.minbox.z || minbox.z > box.maxbox.z) return false;
    00807     return true;
    00808   }
    00809
    00811   inline bool Contains (const csBox3& box) const
    00812   {
    00813     return (box.minbox.x >= minbox.x && box.maxbox.x <= maxbox.x) &&
    00814            (box.minbox.y >= minbox.y && box.maxbox.y <= maxbox.y) &&
    00815            (box.minbox.z >= minbox.z && box.maxbox.z <= maxbox.z);
    00816   }
    00817
    00819   inline bool Empty () const
    00820   {
    00821     if (minbox.x > maxbox.x) return true;
    00822     if (minbox.y > maxbox.y) return true;
    00823     if (minbox.z > maxbox.z) return true;
    00824     return false;
    00825   }
    00826
    00828   inline void StartBoundingBox ()
    00829   {
    00830     minbox.x =  CS_BOUNDINGBOX_MAXVALUE;
    00831     minbox.y =  CS_BOUNDINGBOX_MAXVALUE;
    00832     minbox.z =  CS_BOUNDINGBOX_MAXVALUE;
    00833     maxbox.x = -CS_BOUNDINGBOX_MAXVALUE;
    00834     maxbox.y = -CS_BOUNDINGBOX_MAXVALUE;
    00835     maxbox.z = -CS_BOUNDINGBOX_MAXVALUE;
    00836   }
    00837
    00839   inline void StartBoundingBox (const csVector3& v)
    00840   {
    00841     minbox = v; maxbox = v;
    00842   }
    00843
    00845   inline void AddBoundingVertex (float x, float y, float z)
    00846   {
    00847     if (x < minbox.x) minbox.x = x; if (x > maxbox.x) maxbox.x = x;
    00848     if (y < minbox.y) minbox.y = y; if (y > maxbox.y) maxbox.y = y;
    00849     if (z < minbox.z) minbox.z = z; if (z > maxbox.z) maxbox.z = z;
    00850   }
    00851
    00853   inline void AddBoundingVertex (const csVector3& v)
    00854   {
    00855     AddBoundingVertex (v.x, v.y, v.z);
    00856   }
    00857
    00863   inline void AddBoundingVertexSmart (float x, float y, float z)
    00864   {
    00865     if (x < minbox.x) minbox.x = x; else if (x > maxbox.x) maxbox.x = x;
    00866     if (y < minbox.y) minbox.y = y; else if (y > maxbox.y) maxbox.y = y;
    00867     if (z < minbox.z) minbox.z = z; else if (z > maxbox.z) maxbox.z = z;
    00868   }
    00869
    00875   inline void AddBoundingVertexSmart (const csVector3& v)
    00876   {
    00877     AddBoundingVertexSmart (v.x, v.y, v.z);
    00878   }
    00879
    00884   inline bool AddBoundingVertexTest (float x, float y, float z)
    00885   {
    00886     bool rc = false;
    00887     if (x < minbox.x) { minbox.x = x; rc = true; }
    00888     if (x > maxbox.x) { maxbox.x = x; rc = true; }
    00889     if (y < minbox.y) { minbox.y = y; rc = true; }
    00890     if (y > maxbox.y) { maxbox.y = y; rc = true; }
    00891     if (z < minbox.z) { minbox.z = z; rc = true; }
    00892     if (z > maxbox.z) { maxbox.z = z; rc = true; }
    00893     return rc;
    00894   }
    00895
    00900   inline bool AddBoundingVertexTest (const csVector3& v)
    00901   {
    00902     return AddBoundingVertexTest (v.x, v.y, v.z);
    00903   }
    00904
    00911   inline bool AddBoundingVertexSmartTest (float x, float y, float z)
    00912   {
    00913     bool rc = false;
    00914     if (x < minbox.x) { minbox.x = x; rc = true; }
    00915     else if (x > maxbox.x) { maxbox.x = x; rc = true; }
    00916     if (y < minbox.y) { minbox.y = y; rc = true; }
    00917     else if (y > maxbox.y) { maxbox.y = y; rc = true; }
    00918     if (z < minbox.z) { minbox.z = z; rc = true; }
    00919     else if (z > maxbox.z) { maxbox.z = z; rc = true; }
    00920     return rc;
    00921   }
    00922
    00929   inline bool AddBoundingVertexSmartTest (const csVector3& v)
    00930   {
    00931     return AddBoundingVertexSmartTest (v.x, v.y, v.z);
    00932   }
    00933
    00937   inline void AddBoundingBox (const csBox3& box)
    00938   {
    00939     minbox.x = csMin(minbox.x, box.minbox.x);
    00940     minbox.y = csMin(minbox.y, box.minbox.y);
    00941     minbox.z = csMin(minbox.z, box.minbox.z);
    00942
    00943     maxbox.x = csMax(maxbox.x, box.maxbox.x);
    00944     maxbox.y = csMax(maxbox.y, box.maxbox.y);
    00945     maxbox.z = csMax(maxbox.z, box.maxbox.z);
    00946   }
    00947
    00949   csBox3 () :
    00950     minbox ( CS_BOUNDINGBOX_MAXVALUE,
    00951              CS_BOUNDINGBOX_MAXVALUE,
    00952              CS_BOUNDINGBOX_MAXVALUE),
    00953     maxbox (-CS_BOUNDINGBOX_MAXVALUE,
    00954             -CS_BOUNDINGBOX_MAXVALUE,
    00955             -CS_BOUNDINGBOX_MAXVALUE) {}
    00956
    00958   csBox3 (const csVector3& v) : minbox (v), maxbox (v)
    00959   { }
    00960
    00962   csBox3 (const csVector3& v1, const csVector3& v2) :
    00963         minbox (v1), maxbox (v2)
    00964   { if (Empty ()) StartBoundingBox (); }
    00965
    00967   csBox3 (float x1, float y1, float z1, float x2, float y2, float z2) :
    00968     minbox (x1, y1, z1), maxbox (x2, y2, z2)
    00969   { if (Empty ()) StartBoundingBox (); }
    00970
    00972   inline void Set (const csVector3& bmin, const csVector3& bmax)
    00973   {
    00974     minbox = bmin;
    00975     maxbox = bmax;
    00976   }
    00977
    00979   inline void Set (float x1, float y1, float z1, float x2, float y2, float z2)
    00980   {
    00981     if (x1>x2 || y1>y2 || z1>z2) StartBoundingBox();
    00982     else
    00983     {
    00984       minbox.x = x1; minbox.y = y1; minbox.z = z1;
    00985       maxbox.x = x2; maxbox.y = y2; maxbox.z = z2;
    00986     }
    00987   }
    00988
    00990   inline void SetMin (size_t idx, float val)
    00991   {
    00992     minbox[idx] = val;
    00993   }
    00994
    00996   inline void SetMax (size_t idx, float val)
    00997   {
    00998     maxbox[idx] = val;
    00999   }
    01000
    01002   inline float GetMin (size_t idx)
    01003   {
    01004     return minbox[idx];
    01005   }
    01006
    01008   inline float GetMax (size_t idx)
    01009   {
    01010     return maxbox[idx];
    01011   }
    01012
    01017   csString Description() const;
    01018
    01022   inline void Split (int axis, float where, csBox3& bl, csBox3& br) const
    01023   {
    01024     switch (axis)
    01025     {
    01026       case CS_AXIS_X:
    01027         bl.Set (minbox.x, minbox.y, minbox.z,
    01028                 where,    maxbox.y, maxbox.z);
    01029         br.Set (where,    minbox.y, minbox.z,
    01030                 maxbox.x, maxbox.y, maxbox.z);
    01031         break;
    01032       case CS_AXIS_Y:
    01033         bl.Set (minbox.x, minbox.y, minbox.z,
    01034                 maxbox.x, where,    maxbox.z);
    01035         br.Set (minbox.x, where,    minbox.z,
    01036                 maxbox.x, maxbox.y, maxbox.z);
    01037         break;
    01038       case CS_AXIS_Z:
    01039         bl.Set (minbox.x, minbox.y, minbox.z,
    01040                 maxbox.x, maxbox.y, where);
    01041         br.Set (minbox.x, minbox.y, where,
    01042                 maxbox.x, maxbox.y, maxbox.z);
    01043         break;
    01044     }
    01045   }
    01046
    01053   inline int TestSplit (int axis, float where) const
    01054   {
    01055     if (maxbox[axis] < where) return -1;
    01056     if (minbox[axis] > where) return 1;
    01057     return 0;
    01058   }
    01059
    01063   bool AdjacentX (const csBox3& other, float epsilon = SMALL_EPSILON) const;
    01064
    01068   bool AdjacentY (const csBox3& other, float epsilon = SMALL_EPSILON) const;
    01069
    01073   bool AdjacentZ (const csBox3& other, float epsilon = SMALL_EPSILON) const;
    01074
    01082   int Adjacent (const csBox3& other, float epsilon = SMALL_EPSILON) const;
    01083
    01090   int CalculatePointSegment (const csVector3& pos) const;
    01091
    01100   void GetConvexOutline (const csVector3& pos,
    01101         csVector3* array, int& num_array, bool bVisible=false) const;
    01102
    01106   bool Between (const csBox3& box1, const csBox3& box2) const;
    01107
    01112   void ManhattanDistance (const csBox3& other, csVector3& dist) const;
    01113
    01118   float SquaredOriginDist () const;
    01119
    01125   float SquaredOriginMaxDist () const;
    01126
    01131   float SquaredPosDist (const csVector3& pos) const;
    01132
    01138   float SquaredPosMaxDist (const csVector3& pos) const;
    01139
    01151   bool ProjectBox (const csTransform& trans, float fov, float sx, float sy,
    01152         csBox2& sbox, float& min_z, float& max_z) const;
    01153
    01165   bool ProjectBox (const csTransform& trans, const CS::Math::Matrix4& proj,
    01166         csBox2& sbox, float& min_z, float& max_z, int screenWidth,
    01167         int screenHeight) const;
    01168
    01178   bool ProjectOutline (const csTransform& trans, float fov, float sx, float sy,
    01179         csPoly2D& poly, float& min_z, float& max_z) const;
    01180
    01188   bool ProjectOutline (const csVector3& origin,
    01189         int axis, float where, csArray<csVector2>& poly) const;
    01190
    01196   bool ProjectOutline (const csVector3& origin,
    01197         int axis, float where, csPoly2D& poly) const;
    01198
    01211   bool ProjectBoxAndOutline (const csTransform& trans, float fov,
    01212         float sx, float sy, csBox2& sbox, csPoly2D& poly,
    01213         float& min_z, float& max_z) const;
    01214
    01216   csBox3& operator+= (const csBox3& box);
    01218   csBox3& operator+= (const csVector3& point);
    01220   csBox3& operator*= (const csBox3& box);
    01222   bool TestIntersect (const csBox3& box) const;
    01223
    01225   friend CS_CRYSTALSPACE_EXPORT csBox3 operator+ (const csBox3& box1,
    01226     const csBox3& box2);
    01228   friend CS_CRYSTALSPACE_EXPORT csBox3 operator+ (const csBox3& box,
    01229     const csVector3& point);
    01231   friend CS_CRYSTALSPACE_EXPORT csBox3 operator* (const csBox3& box1,
    01232     const csBox3& box2);
    01233
    01235   friend CS_CRYSTALSPACE_EXPORT bool operator== (const csBox3& box1,
    01236     const csBox3& box2);
    01238   friend CS_CRYSTALSPACE_EXPORT bool operator!= (const csBox3& box1,
    01239     const csBox3& box2);
    01241   friend CS_CRYSTALSPACE_EXPORT bool operator< (const csBox3& box1,
    01242     const csBox3& box2);
    01244   friend CS_CRYSTALSPACE_EXPORT bool operator> (const csBox3& box1,
    01245     const csBox3& box2);
    01247   friend CS_CRYSTALSPACE_EXPORT bool operator< (const csVector3& point,
    01248     const csBox3& box);
    01249 };
    01250
    01253 #endif // __CS_BOX_H__