Enter your search terms GNU-Darwin Web Submit search form

box.h /* Copyright (C) 1998,1999,2000 by Jorrit Tyberghein Largely rewritten by Ivan Avramovic <ivan@avramovic.com> This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef __CS_BOX_H__ #define __CS_BOX_H__ #include "cstypes.h" // for bool #include "vector2.h" #include "vector3.h" #include "segment.h" class csPlane3; #define CS_BOUNDINGBOX_MAXVALUE 1000000000. #define CS_BOX_CORNER_xy 0 #define CS_BOX_CORNER_xY 1 #define CS_BOX_CORNER_Xy 2 #define CS_BOX_CORNER_XY 3 #define CS_BOX_EDGE_xy_Xy 0 #define CS_BOX_EDGE_Xy_xy 1 #define CS_BOX_EDGE_Xy_XY 2 #define CS_BOX_EDGE_XY_Xy 3 #define CS_BOX_EDGE_XY_xY 4 #define CS_BOX_EDGE_xY_XY 5 #define CS_BOX_EDGE_xY_xy 6 #define CS_BOX_EDGE_xy_xY 7 class csBox2 { private: struct bEdge { uint8 v1, v2; // Indices of vertex in bounding box (CS_BOX_CORNER_...) }; // Index by edge number. Edge e and e+1 with e even are opposite edges. // (CS_BOX_EDGE_...) static bEdge edges[8]; protected: csVector2 minbox; csVector2 maxbox; public: float MinX () const { return minbox.x; } float MinY () const { return minbox.y; } float MaxX () const { return maxbox.x; } float MaxY () const { return maxbox.y; } float Min (int idx) const { return idx ? minbox.y : minbox.x; } float Max (int idx) const { return idx ? maxbox.y : maxbox.x; } const csVector2& Min () const { return minbox; } const csVector2& Max () const { return maxbox; } csVector2 GetCorner (int corner) const; csVector2 GetCenter () const { return (minbox+maxbox)/2; } void SetCenter (const csVector2& c); void SetSize (const csVector2& s); void GetEdgeInfo (int edge, int& v1, int& v2) const { v1 = edges[edge].v1; v2 = edges[edge].v2; } csSegment2 GetEdge (int edge) const { return csSegment2 (GetCorner (edges[edge].v1), GetCorner (edges[edge].v2)); } void GetEdge (int edge, csSegment2& e) const { e.SetStart (GetCorner (edges[edge].v1)); e.SetEnd (GetCorner (edges[edge].v2)); } static bool Intersect (float minx, float miny, float maxx, float maxy, csVector2* poly, int num_poly); static bool Intersect (const csVector2& minbox, const csVector2& maxbox, csVector2* poly, int num_poly) { return Intersect (minbox.x, minbox.y, maxbox.x, maxbox.y, poly, num_poly); } bool Intersect (csVector2* poly, int num_poly) const { return Intersect (minbox, maxbox, poly, num_poly); } bool In (float x, float y) const { if (x < minbox.x || x > maxbox.x) return false; if (y < minbox.y || y > maxbox.y) return false; return true; } bool In (const csVector2& v) const { return In (v.x, v.y); } bool Overlap (const csBox2& box) const { if (maxbox.x < box.minbox.x || minbox.x > box.maxbox.x) return false; if (maxbox.y < box.minbox.y || minbox.y > box.maxbox.y) return false; return true; } bool Contains (const csBox2& box) const { return (box.minbox.x >= minbox.x && box.maxbox.x <= maxbox.x) && (box.minbox.y >= minbox.y && box.maxbox.y <= maxbox.y); } bool Empty () const { if (minbox.x > maxbox.x) return true; if (minbox.y > maxbox.y) return true; return false; } float SquaredOriginDist () const; float SquaredOriginMaxDist () const; void StartBoundingBox () { minbox.x = CS_BOUNDINGBOX_MAXVALUE; minbox.y = CS_BOUNDINGBOX_MAXVALUE; maxbox.x = -CS_BOUNDINGBOX_MAXVALUE; maxbox.y = -CS_BOUNDINGBOX_MAXVALUE; } void StartBoundingBox (const csVector2& v) { minbox = v; maxbox = v; } void StartBoundingBox (float x, float y) { minbox.x = maxbox.x = x; minbox.y = maxbox.y = y; } void AddBoundingVertex (float x, float y) { if (x < minbox.x) minbox.x = x; if (x > maxbox.x) maxbox.x = x; if (y < minbox.y) minbox.y = y; if (y > maxbox.y) maxbox.y = y; } void AddBoundingVertex (const csVector2& v) { AddBoundingVertex (v.x, v.y); } void AddBoundingVertexSmart (float x, float y) { if (x < minbox.x) minbox.x = x; else if (x > maxbox.x) maxbox.x = x; if (y < minbox.y) minbox.y = y; else if (y > maxbox.y) maxbox.y = y; } void AddBoundingVertexSmart (const csVector2& v) { AddBoundingVertexSmart (v.x, v.y); } //----- // Maintenance Note: The csBox2 constructors and Set() appear at this point // in the file, rather than earlier, in order to appease the OpenStep 4.2 // compiler. Specifically, the problem is that the compiler botches code // generation if an unseen method (which is later declared inline) is // called from within another inline method. For instance, if the // constructors were listed at the top of the file, rather than here, the // compiler would see calls to Empty() and StartBoundingBox() before seeing // declarations for them. In such a situation, the buggy compiler // generates a broken object file. The simple work-around of textually // reorganizing the file ensures that the declarations for Empty() and // StartBoundingBox() are seen before they are called. //----- csBox2 () : minbox (CS_BOUNDINGBOX_MAXVALUE, CS_BOUNDINGBOX_MAXVALUE), maxbox (-CS_BOUNDINGBOX_MAXVALUE, -CS_BOUNDINGBOX_MAXVALUE) {} csBox2 (const csVector2& v) : minbox (v.x, v.y), maxbox (v.x, v.y) {} csBox2 (float x1, float y1, float x2, float y2) : minbox (x1, y1), maxbox (x2, y2) { if (Empty ()) StartBoundingBox (); } void Set (const csVector2& bmin, const csVector2& bmax) { minbox = bmin; maxbox = bmax; } void Set (float x1, float y1, float x2, float y2) { if (x1>x2 || y1>y2) StartBoundingBox(); else { minbox.x = x1; minbox.y = y1; maxbox.x = x2; maxbox.y = y2; } } csBox2& operator+= (const csBox2& box); csBox2& operator+= (const csVector2& point); csBox2& operator*= (const csBox2& box); friend csBox2 operator+ (const csBox2& box1, const csBox2& box2); friend csBox2 operator+ (const csBox2& box, const csVector2& point); friend csBox2 operator* (const csBox2& box1, const csBox2& box2); friend bool operator== (const csBox2& box1, const csBox2& box2); friend bool operator!= (const csBox2& box1, const csBox2& box2); friend bool operator< (const csBox2& box1, const csBox2& box2); friend bool operator> (const csBox2& box1, const csBox2& box2); friend bool operator< (const csVector2& point, const csBox2& box); }; #define CS_BOX_CORNER_xyz 0 #define CS_BOX_CORNER_xyZ 1 #define CS_BOX_CORNER_xYz 2 #define CS_BOX_CORNER_xYZ 3 #define CS_BOX_CORNER_Xyz 4 #define CS_BOX_CORNER_XyZ 5 #define CS_BOX_CORNER_XYz 6 #define CS_BOX_CORNER_XYZ 7 #define CS_BOX_SIDE_x 0 #define CS_BOX_SIDE_X 1 #define CS_BOX_SIDE_y 2 #define CS_BOX_SIDE_Y 3 #define CS_BOX_SIDE_z 4 #define CS_BOX_SIDE_Z 5 #define CS_BOX_INSIDE 6 #define CS_BOX_EDGE_Xyz_xyz 0 #define CS_BOX_EDGE_xyz_Xyz 1 #define CS_BOX_EDGE_xyz_xYz 2 #define CS_BOX_EDGE_xYz_xyz 3 #define CS_BOX_EDGE_xYz_XYz 4 #define CS_BOX_EDGE_XYz_xYz 5 #define CS_BOX_EDGE_XYz_Xyz 6 #define CS_BOX_EDGE_Xyz_XYz 7 #define CS_BOX_EDGE_Xyz_XyZ 8 #define CS_BOX_EDGE_XyZ_Xyz 9 #define CS_BOX_EDGE_XyZ_XYZ 10 #define CS_BOX_EDGE_XYZ_XyZ 11 #define CS_BOX_EDGE_XYZ_XYz 12 #define CS_BOX_EDGE_XYz_XYZ 13 #define CS_BOX_EDGE_XYZ_xYZ 14 #define CS_BOX_EDGE_xYZ_XYZ 15 #define CS_BOX_EDGE_xYZ_xYz 16 #define CS_BOX_EDGE_xYz_xYZ 17 #define CS_BOX_EDGE_xYZ_xyZ 18 #define CS_BOX_EDGE_xyZ_xYZ 19 #define CS_BOX_EDGE_xyZ_xyz 20 #define CS_BOX_EDGE_xyz_xyZ 21 #define CS_BOX_EDGE_xyZ_XyZ 22 #define CS_BOX_EDGE_XyZ_xyZ 23 class csBox3 { protected: csVector3 minbox; csVector3 maxbox; struct bEdge { uint8 v1, v2; // Indices of vertex in bounding box (CS_BOX_CORNER_...) uint8 fl, fr; // Indices of left/right faces sharing edge (CS_BOX_SIDE_...) }; typedef uint8 bFace[4]; // Indices of four clock-wise edges (0..23) // Index by edge number. Edge e and e+1 with e even are opposite edges. // (CS_BOX_EDGE_...) static bEdge edges[24]; // Index by CS_BOX_SIDE_? number. static bFace faces[6]; public: float MinX () const { return minbox.x; } float MinY () const { return minbox.y; } float MinZ () const { return minbox.z; } float MaxX () const { return maxbox.x; } float MaxY () const { return maxbox.y; } float MaxZ () const { return maxbox.z; } float Min (int idx) const { return idx == 1 ? minbox.y : idx == 0 ? minbox.x : minbox.z; } float Max (int idx) const { return idx == 1 ? maxbox.y : idx == 0 ? maxbox.x : maxbox.z; } const csVector3& Min () const { return minbox; } const csVector3& Max () const { return maxbox; } csVector3 GetCorner (int corner) const; void GetEdgeInfo (int edge, int& v1, int& v2, int& fleft, int& fright) const { v1 = edges[edge].v1; v2 = edges[edge].v2; fleft = edges[edge].fl; fright = edges[edge].fr; } uint8* GetFaceEdges (int face) const { return faces[face]; } csVector3 GetCenter () const { return (minbox+maxbox)/2; } void SetCenter (const csVector3& c); void SetSize (const csVector3& s); csBox2 GetSide (int side) const; int GetVisibleSides (const csVector3& pos, int* visible_sides) const; static int OtherSide (int side) { return side ^ 1; } csSegment3 GetEdge (int edge) const { return csSegment3 (GetCorner (edges[edge].v1), GetCorner (edges[edge].v2)); } void GetEdge (int edge, csSegment3& e) const { e.SetStart (GetCorner (edges[edge].v1)); e.SetEnd (GetCorner (edges[edge].v2)); } bool In (float x, float y, float z) const { if (x < minbox.x || x > maxbox.x) return false; if (y < minbox.y || y > maxbox.y) return false; if (z < minbox.z || z > maxbox.z) return false; return true; } bool In (const csVector3& v) const { return In (v.x, v.y, v.z); } bool Overlap (const csBox3& box) const { if (maxbox.x < box.minbox.x || minbox.x > box.maxbox.x) return false; if (maxbox.y < box.minbox.y || minbox.y > box.maxbox.y) return false; if (maxbox.z < box.minbox.z || minbox.z > box.maxbox.z) return false; return true; } bool Contains (const csBox3& box) const { return (box.minbox.x >= minbox.x && box.maxbox.x <= maxbox.x) && (box.minbox.y >= minbox.y && box.maxbox.y <= maxbox.y) && (box.minbox.z >= minbox.z && box.maxbox.z <= maxbox.z); } bool Empty () const { if (minbox.x > maxbox.x) return true; if (minbox.y > maxbox.y) return true; if (minbox.z > maxbox.z) return true; return false; } void StartBoundingBox () { minbox.x = CS_BOUNDINGBOX_MAXVALUE; minbox.y = CS_BOUNDINGBOX_MAXVALUE; minbox.z = CS_BOUNDINGBOX_MAXVALUE; maxbox.x = -CS_BOUNDINGBOX_MAXVALUE; maxbox.y = -CS_BOUNDINGBOX_MAXVALUE; maxbox.z = -CS_BOUNDINGBOX_MAXVALUE; } void StartBoundingBox (const csVector3& v) { minbox = v; maxbox = v; } void AddBoundingVertex (float x, float y, float z) { if (x < minbox.x) minbox.x = x; if (x > maxbox.x) maxbox.x = x; if (y < minbox.y) minbox.y = y; if (y > maxbox.y) maxbox.y = y; if (z < minbox.z) minbox.z = z; if (z > maxbox.z) maxbox.z = z; } void AddBoundingVertex (const csVector3& v) { AddBoundingVertex (v.x, v.y, v.z); } void AddBoundingVertexSmart (float x, float y, float z) { if (x < minbox.x) minbox.x = x; else if (x > maxbox.x) maxbox.x = x; if (y < minbox.y) minbox.y = y; else if (y > maxbox.y) maxbox.y = y; if (z < minbox.z) minbox.z = z; else if (z > maxbox.z) maxbox.z = z; } void AddBoundingVertexSmart (const csVector3& v) { AddBoundingVertexSmart (v.x, v.y, v.z); } //----- // Maintenance Note: The csBox3 constructors and Set() appear at this point // in the file, rather than earlier, in order to appease the OpenStep 4.2 // compiler. Specifically, the problem is that the compiler botches code // generation if an unseen method (which is later declared inline) is // called from within another inline method. For instance, if the // constructors were listed at the top of the file, rather than here, the // compiler would see calls to Empty() and StartBoundingBox() before seeing // declarations for them. In such a situation, the buggy compiler // generated a broken object file. The simple work-around of textually // reorganizing the file ensures that the declarations for Empty() and // StartBoundingBox() are seen before they are called. //----- csBox3 () : minbox ( CS_BOUNDINGBOX_MAXVALUE, CS_BOUNDINGBOX_MAXVALUE, CS_BOUNDINGBOX_MAXVALUE), maxbox (-CS_BOUNDINGBOX_MAXVALUE, -CS_BOUNDINGBOX_MAXVALUE, -CS_BOUNDINGBOX_MAXVALUE) {} csBox3 (const csVector3& v) : minbox (v), maxbox (v) { } csBox3 (const csVector3& v1, const csVector3& v2) : minbox (v1), maxbox (v2) { if (Empty ()) StartBoundingBox (); } csBox3 (float x1, float y1, float z1, float x2, float y2, float z2) : minbox (x1, y1, z1), maxbox (x2, y2, z2) { if (Empty ()) StartBoundingBox (); } void Set (const csVector3& bmin, const csVector3& bmax) { minbox = bmin; maxbox = bmax; } void Set (float x1, float y1, float z1, float x2, float y2, float z2) { if (x1>x2 || y1>y2 || z1>z2) StartBoundingBox(); else { minbox.x = x1; minbox.y = y1; minbox.z = z1; maxbox.x = x2; maxbox.y = y2; maxbox.z = z2; } } bool AdjacentX (const csBox3& other) const; bool AdjacentY (const csBox3& other) const; bool AdjacentZ (const csBox3& other) const; int Adjacent (const csBox3& other) const; void GetConvexOutline (const csVector3& pos, csVector3* array, int& num_array, bool bVisible=false) const; bool Between (const csBox3& box1, const csBox3& box2) const; void ManhattanDistance (const csBox3& other, csVector3& dist) const; float SquaredOriginDist () const; float SquaredOriginMaxDist () const; csBox3& operator+= (const csBox3& box); csBox3& operator+= (const csVector3& point); csBox3& operator*= (const csBox3& box); friend csBox3 operator+ (const csBox3& box1, const csBox3& box2); friend csBox3 operator+ (const csBox3& box, const csVector3& point); friend csBox3 operator* (const csBox3& box1, const csBox3& box2); friend bool operator== (const csBox3& box1, const csBox3& box2); friend bool operator!= (const csBox3& box1, const csBox3& box2); friend bool operator< (const csBox3& box1, const csBox3& box2); friend bool operator> (const csBox3& box1, const csBox3& box2); friend bool operator< (const csVector3& point, const csBox3& box); }; #endif // __CS_BOX_H__ Generated for Crystal Space by doxygen 1.2.5 written by Dimitri van Heesch, ©1997-2000