Public API Reference

csgeom/box.h

Go to the documentation of this file.

/*
    Copyright (C) 1998-2002 by Jorrit Tyberghein
    Largely rewritten by Ivan Avramovic <[email protected]>

    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 "csextern.h"
#include "cstypes.h"    // for bool

#include "csgeom/csrect.h"
#include "csgeom/math.h"
#include "csgeom/vector2.h"
#include "csgeom/vector3.h"
#include "csgeom/segment.h"

#include "csutil/array.h"

class csPoly2D;
class csString;
class csTransform;

#define CS_BOUNDINGBOX_MAXVALUE 1000000000.

enum 
{
  CS_BOX_CORNER_xy = 0,
  CS_BOX_CORNER_xY = 1,
  CS_BOX_CORNER_Xy = 2,
  CS_BOX_CORNER_XY = 3,
  CS_BOX_CENTER2 = 4
};
enum 
{
  CS_BOX_EDGE_xy_Xy = 0,
  CS_BOX_EDGE_Xy_xy = 1,
  CS_BOX_EDGE_Xy_XY = 2,
  CS_BOX_EDGE_XY_Xy = 3,
  CS_BOX_EDGE_XY_xY = 4,
  CS_BOX_EDGE_xY_XY = 5,
  CS_BOX_EDGE_xY_xy = 6,
  CS_BOX_EDGE_xy_xY = 7
};
class CS_CRYSTALSPACE_EXPORT 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 const bEdge edges[8];

protected:
  csVector2 minbox;
  csVector2 maxbox;

public:
  inline float MinX () const { return minbox.x; }
  inline float MinY () const { return minbox.y; }
  inline float MaxX () const { return maxbox.x; }
  inline float MaxY () const { return maxbox.y; }
  inline float Min (int idx) const { return idx ? minbox.y : minbox.x; }
  inline float Max (int idx) const { return idx ? maxbox.y : maxbox.x; }
  inline const csVector2& Min () const { return minbox; }
  inline const csVector2& Max () const { return maxbox; }
  inline float Area () const { return (MaxX()-MinX())*(MaxY()-MinY()); }

  csVector2 GetCorner (int corner) const;

  inline csVector2 GetCenter () const { return (minbox+maxbox)/2; }

  void SetCenter (const csVector2& c);

  void SetSize (const csVector2& s);

  inline void GetEdgeInfo (int edge, int& v1, int& v2) const
  {
    v1 = edges[edge].v1;
    v2 = edges[edge].v2;
  }

  inline csSegment2 GetEdge (int edge) const
  {
    return csSegment2 (GetCorner (edges[edge].v1), GetCorner (edges[edge].v2));
  }

  inline 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 inline 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);
  }

  inline bool Intersect (csVector2* poly, int num_poly) const
  {
    return Intersect (minbox, maxbox, poly, num_poly);
  }

  inline 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;
  }

  inline bool In (const csVector2& v) const
  {
    return In (v.x, v.y);
  }

  inline 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;
  }

  inline 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);
  }

  inline 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;

  float SquaredPosDist (const csVector2& pos) const;

  float SquaredPosMaxDist (const csVector2& pos) const;

  inline void StartBoundingBox ()
  {
    minbox.x =  CS_BOUNDINGBOX_MAXVALUE;  minbox.y =  CS_BOUNDINGBOX_MAXVALUE;
    maxbox.x = -CS_BOUNDINGBOX_MAXVALUE;  maxbox.y = -CS_BOUNDINGBOX_MAXVALUE;
  }

  inline void StartBoundingBox (const csVector2& v)
  {
    minbox = v;
    maxbox = v;
  }

  inline void StartBoundingBox (float x, float y)
  {
    minbox.x = maxbox.x = x;
    minbox.y = maxbox.y = y;
  }

  inline 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;
  }

  inline void AddBoundingVertex (const csVector2& v)
  {
    AddBoundingVertex (v.x, v.y);
  }

  inline 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;
  }

  inline void AddBoundingVertexSmart (const csVector2& v)
  {
    AddBoundingVertexSmart (v.x, v.y);
  }

  inline bool AddBoundingVertexTest (float x, float y)
  {
    bool rc = false;
    if (x < minbox.x) { minbox.x = x; rc = true; }
    if (x > maxbox.x) { maxbox.x = x; rc = true; }
    if (y < minbox.y) { minbox.y = y; rc = true; }
    if (y > maxbox.y) { maxbox.y = y; rc = true; }
    return rc;
  }

  inline bool AddBoundingVertexTest (const csVector2& v)
  {
    return AddBoundingVertexTest (v.x, v.y);
  }

  inline bool AddBoundingVertexSmartTest (float x, float y)
  {
    bool rc = false;
    if (x < minbox.x) { minbox.x = x; rc = true; }
    else if (x > maxbox.x) { maxbox.x = x; rc = true; }
    if (y < minbox.y) { minbox.y = y; rc = true; }
    else if (y > maxbox.y) { maxbox.y = y; rc = true; }
    return rc;
  }

  inline bool AddBoundingVertexSmartTest (const csVector2& v)
  {
    return AddBoundingVertexSmartTest (v.x, v.y);
  }

  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 (); }

  csBox2 (const csRect& r) : minbox (r.xmin, r.ymin), maxbox (r.xmax, r.ymax)
  { }
  
  inline void Set (const csVector2& bmin, const csVector2& bmax)
  {
    minbox = bmin;
    maxbox = bmax;
  }

  inline 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; }
  }

  inline void SetMin (int idx, float val)
  {
    if (idx == 1) minbox.y = val;
    else minbox.x = val;
  }

  inline void SetMax (int idx, float val)
  {
    if (idx == 1) maxbox.y = val;
    else maxbox.x = val;
  }

  csString Description() const;

  csBox2& operator+= (const csBox2& box);
  csBox2& operator+= (const csVector2& point);
  csBox2& operator*= (const csBox2& box);
  bool TestIntersect (const csBox2& box) const;

  friend CS_CRYSTALSPACE_EXPORT csBox2 operator+ (const csBox2& box1, 
    const csBox2& box2);
  friend CS_CRYSTALSPACE_EXPORT csBox2 operator+ (const csBox2& box, 
    const csVector2& point);
  friend CS_CRYSTALSPACE_EXPORT csBox2 operator* (const csBox2& box1, 
    const csBox2& box2);

  friend CS_CRYSTALSPACE_EXPORT bool operator== (const csBox2& box1, 
    const csBox2& box2);
  friend CS_CRYSTALSPACE_EXPORT bool operator!= (const csBox2& box1, 
    const csBox2& box2);
  friend CS_CRYSTALSPACE_EXPORT bool operator< (const csBox2& box1, 
    const csBox2& box2);
  friend CS_CRYSTALSPACE_EXPORT bool operator> (const csBox2& box1, 
    const csBox2& box2);
  friend CS_CRYSTALSPACE_EXPORT bool operator< (const csVector2& point, 
    const csBox2& box);
};

enum
{
  CS_BOX_CORNER_xyz = 0,
  CS_BOX_CORNER_xyZ = 1,
  CS_BOX_CORNER_xYz = 2,
  CS_BOX_CORNER_xYZ = 3,
  CS_BOX_CORNER_Xyz = 4,
  CS_BOX_CORNER_XyZ = 5,
  CS_BOX_CORNER_XYz = 6,
  CS_BOX_CORNER_XYZ = 7,
  CS_BOX_CENTER3 = 8
};
enum
{
  CS_BOX_SIDE_x = 0,
  CS_BOX_SIDE_X = 1,
  CS_BOX_SIDE_y = 2,
  CS_BOX_SIDE_Y = 3,
  CS_BOX_SIDE_z = 4,
  CS_BOX_SIDE_Z = 5,
  CS_BOX_INSIDE = 6
};
enum
{
  CS_BOX_EDGE_Xyz_xyz = 0,
  CS_BOX_EDGE_xyz_Xyz = 1,
  CS_BOX_EDGE_xyz_xYz = 2,
  CS_BOX_EDGE_xYz_xyz = 3,
  CS_BOX_EDGE_xYz_XYz = 4,
  CS_BOX_EDGE_XYz_xYz = 5,
  CS_BOX_EDGE_XYz_Xyz = 6,
  CS_BOX_EDGE_Xyz_XYz = 7,
  CS_BOX_EDGE_Xyz_XyZ = 8,
  CS_BOX_EDGE_XyZ_Xyz = 9,
  CS_BOX_EDGE_XyZ_XYZ = 10,
  CS_BOX_EDGE_XYZ_XyZ = 11,
  CS_BOX_EDGE_XYZ_XYz = 12,
  CS_BOX_EDGE_XYz_XYZ = 13,
  CS_BOX_EDGE_XYZ_xYZ = 14,
  CS_BOX_EDGE_xYZ_XYZ = 15,
  CS_BOX_EDGE_xYZ_xYz = 16,
  CS_BOX_EDGE_xYz_xYZ = 17,
  CS_BOX_EDGE_xYZ_xyZ = 18,
  CS_BOX_EDGE_xyZ_xYZ = 19,
  CS_BOX_EDGE_xyZ_xyz = 20,
  CS_BOX_EDGE_xyz_xyZ = 21,
  CS_BOX_EDGE_xyZ_XyZ = 22,
  CS_BOX_EDGE_XyZ_xyZ = 23
};
class CS_CRYSTALSPACE_EXPORT 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];       
  static const bEdge edges[24];
  static const bFace faces[6];
  struct Outline
  {
    int num;
    int vertices[8];
    int num_sides;
    int sides[3];
  };
  static const Outline outlines[27];
public:
  inline float MinX () const { return minbox.x; }
  inline float MinY () const { return minbox.y; }
  inline float MinZ () const { return minbox.z; }
  inline float MaxX () const { return maxbox.x; }
  inline float MaxY () const { return maxbox.y; }
  inline float MaxZ () const { return maxbox.z; }
  inline float Min (int idx) const
  { return minbox[idx]; }
  inline float Max (int idx) const
  { return maxbox[idx]; }
  inline const csVector3& Min () const { return minbox; }
  inline const csVector3& Max () const { return maxbox; }
  inline float Volume () const
  { return (MaxX()-MinX())*(MaxY()-MinY())*(MaxZ()-MinZ()); }
  inline float Area () const
  {
    float x = MaxX()-MinX();
    float y = MaxY()-MinY();
    float z = MaxZ()-MinZ();
    return 2.0f*(x*y + x*z + y*z);
  }

  csVector3 GetCorner (int corner) const;

  inline 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;
  }

  inline const uint8* GetFaceEdges (int face) const
  {
    return faces[face];
  }

  inline csVector3 GetCenter () const { return (minbox+maxbox)/2; }

  void SetCenter (const csVector3& c);

  void SetSize (const csVector3& s);

  inline csVector3 GetSize () const { return (maxbox-minbox); }

  csBox2 GetSide (int side) const;

  void GetAxisPlane (int side, int& axis, float& where) const;

  int GetVisibleSides (const csVector3& pos, int* visible_sides) const;

  static inline int OtherSide (int side)
  {
    return side ^ 1;
  }

  inline csSegment3 GetEdge (int edge) const
  {
    return csSegment3 (GetCorner (edges[edge].v1), GetCorner (edges[edge].v2));
  }

  inline void GetEdge (int edge, csSegment3& e) const
  {
    e.SetStart (GetCorner (edges[edge].v1));
    e.SetEnd (GetCorner (edges[edge].v2));
  }

  inline 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;
  }

  inline bool In (const csVector3& v) const
  {
    return In (v.x, v.y, v.z);
  }

  inline 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;
  }

  inline 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);
  }

  inline 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;
  }

  inline 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;
  }

  inline void StartBoundingBox (const csVector3& v)
  {
    minbox = v; maxbox = v;
  }

  inline 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;
  }

  inline void AddBoundingVertex (const csVector3& v)
  {
    AddBoundingVertex (v.x, v.y, v.z);
  }

  inline 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;
  }

  inline void AddBoundingVertexSmart (const csVector3& v)
  {
    AddBoundingVertexSmart (v.x, v.y, v.z);
  }

  inline bool AddBoundingVertexTest (float x, float y, float z)
  {
    bool rc = false;
    if (x < minbox.x) { minbox.x = x; rc = true; }
    if (x > maxbox.x) { maxbox.x = x; rc = true; }
    if (y < minbox.y) { minbox.y = y; rc = true; }
    if (y > maxbox.y) { maxbox.y = y; rc = true; }
    if (z < minbox.z) { minbox.z = z; rc = true; }
    if (z > maxbox.z) { maxbox.z = z; rc = true; }
    return rc;
  }

  inline bool AddBoundingVertexTest (const csVector3& v)
  {
    return AddBoundingVertexTest (v.x, v.y, v.z);
  }

  inline bool AddBoundingVertexSmartTest (float x, float y, float z)
  {
    bool rc = false;
    if (x < minbox.x) { minbox.x = x; rc = true; }
    else if (x > maxbox.x) { maxbox.x = x; rc = true; }
    if (y < minbox.y) { minbox.y = y; rc = true; }
    else if (y > maxbox.y) { maxbox.y = y; rc = true; }
    if (z < minbox.z) { minbox.z = z; rc = true; }
    else if (z > maxbox.z) { maxbox.z = z; rc = true; }
    return rc;
  }

  inline bool AddBoundingVertexSmartTest (const csVector3& v)
  {
    return AddBoundingVertexSmartTest (v.x, v.y, v.z);
  }

  inline void AddBoundingBox (const csBox3& box)
  {
    minbox.x = csMin(minbox.x, box.minbox.x);
    minbox.y = csMin(minbox.y, box.minbox.y);
    minbox.z = csMin(minbox.z, box.minbox.z);

    maxbox.x = csMax(maxbox.x, box.maxbox.x);
    maxbox.y = csMax(maxbox.y, box.maxbox.y);
    maxbox.z = csMax(maxbox.z, box.maxbox.z);
  }

  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 (); }

  inline void Set (const csVector3& bmin, const csVector3& bmax)
  {
    minbox = bmin;
    maxbox = bmax;
  }

  inline 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;
    }
  }

  inline void SetMin (int idx, float val)
  {
    if (idx == 1) minbox.y = val;
    else if (idx == 0) minbox.x = val;
    else minbox.z = val;
  }

  inline void SetMax (int idx, float val)
  {
    if (idx == 1) maxbox.y = val;
    else if (idx == 0) maxbox.x = val;
    else maxbox.z = val;
  }

  csString Description() const;

  inline void Split (int axis, float where, csBox3& bl, csBox3& br) const
  {
    switch (axis)
    {
      case CS_AXIS_X:
        bl.Set (minbox.x, minbox.y, minbox.z,
                where,    maxbox.y, maxbox.z);
        br.Set (where,    minbox.y, minbox.z,
                maxbox.x, maxbox.y, maxbox.z);
        break;
      case CS_AXIS_Y:
        bl.Set (minbox.x, minbox.y, minbox.z,
                maxbox.x, where,    maxbox.z);
        br.Set (minbox.x, where,    minbox.z,
                maxbox.x, maxbox.y, maxbox.z);
        break;
      case CS_AXIS_Z:
        bl.Set (minbox.x, minbox.y, minbox.z,
                maxbox.x, maxbox.y, where);
        br.Set (minbox.x, minbox.y, where,
                maxbox.x, maxbox.y, maxbox.z);
        break;
    }
  }

  inline int TestSplit (int axis, float where) const
  {
    if (maxbox[axis] < where) return -1;
    if (minbox[axis] > where) return 1;
    return 0;
  }

  bool AdjacentX (const csBox3& other, float epsilon = SMALL_EPSILON) const;

  bool AdjacentY (const csBox3& other, float epsilon = SMALL_EPSILON) const;

  bool AdjacentZ (const csBox3& other, float epsilon = SMALL_EPSILON) const;

  int Adjacent (const csBox3& other, float epsilon = SMALL_EPSILON) const;

  int CalculatePointSegment (const csVector3& pos) 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;

  float SquaredPosDist (const csVector3& pos) const;

  float SquaredPosMaxDist (const csVector3& pos) const;

  bool ProjectBox (const csTransform& trans, float fov, float sx, float sy,
        csBox2& sbox, float& min_z, float& max_z) const;

  bool ProjectOutline (const csTransform& trans, float fov, float sx, float sy,
        csPoly2D& poly, float& min_z, float& max_z) const;

  bool ProjectOutline (const csVector3& origin,
        int axis, float where, csArray<csVector2>& poly) const;

  bool ProjectOutline (const csVector3& origin,
        int axis, float where, csPoly2D& poly) const;

  bool ProjectBoxAndOutline (const csTransform& trans, float fov,
        float sx, float sy, csBox2& sbox, csPoly2D& poly,
        float& min_z, float& max_z) const;

  csBox3& operator+= (const csBox3& box);
  csBox3& operator+= (const csVector3& point);
  csBox3& operator*= (const csBox3& box);
  bool TestIntersect (const csBox3& box) const;

  friend CS_CRYSTALSPACE_EXPORT csBox3 operator+ (const csBox3& box1, 
    const csBox3& box2);
  friend CS_CRYSTALSPACE_EXPORT csBox3 operator+ (const csBox3& box, 
    const csVector3& point);
  friend CS_CRYSTALSPACE_EXPORT csBox3 operator* (const csBox3& box1, 
    const csBox3& box2);

  friend CS_CRYSTALSPACE_EXPORT bool operator== (const csBox3& box1, 
    const csBox3& box2);
  friend CS_CRYSTALSPACE_EXPORT bool operator!= (const csBox3& box1, 
    const csBox3& box2);
  friend CS_CRYSTALSPACE_EXPORT bool operator< (const csBox3& box1, 
    const csBox3& box2);
  friend CS_CRYSTALSPACE_EXPORT bool operator> (const csBox3& box1, 
    const csBox3& box2);
  friend CS_CRYSTALSPACE_EXPORT bool operator< (const csVector3& point, 
    const csBox3& box);
};

#endif // __CS_BOX_H__

---