opbox.h

Go to the documentation of this file.

/*
    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 "opvector3.h"


class csPlane3;

#define CS_BOUNDINGBOX_MAXVALUE 1000000000.


#define BOX_CORNER_xyz 0
#define BOX_CORNER_xyZ 1
#define BOX_CORNER_xYz 2
#define BOX_CORNER_xYZ 3
#define BOX_CORNER_Xyz 4
#define BOX_CORNER_XyZ 5
#define BOX_CORNER_XYz 6
#define BOX_CORNER_XYZ 7

#define BOX_SIDE_x 0
#define BOX_SIDE_X 1
#define BOX_SIDE_y 2
#define BOX_SIDE_Y 3
#define BOX_SIDE_z 4
#define BOX_SIDE_Z 5
#define BOX_INSIDE 6

#define BOX_EDGE_Xyz_xyz 0
#define BOX_EDGE_xyz_Xyz 1
#define BOX_EDGE_xyz_xYz 2
#define BOX_EDGE_xYz_xyz 3
#define BOX_EDGE_xYz_XYz 4
#define BOX_EDGE_XYz_xYz 5
#define BOX_EDGE_XYz_Xyz 6
#define BOX_EDGE_Xyz_XYz 7
#define BOX_EDGE_Xyz_XyZ 8
#define BOX_EDGE_XyZ_Xyz 9
#define BOX_EDGE_XyZ_XYZ 10
#define BOX_EDGE_XYZ_XyZ 11
#define BOX_EDGE_XYZ_XYz 12
#define BOX_EDGE_XYz_XYZ 13
#define BOX_EDGE_XYZ_xYZ 14
#define BOX_EDGE_xYZ_XYZ 15
#define BOX_EDGE_xYZ_xYz 16
#define BOX_EDGE_xYz_xYZ 17
#define BOX_EDGE_xYZ_xyZ 18
#define BOX_EDGE_xyZ_xYZ 19
#define BOX_EDGE_xyZ_xyz 20
#define BOX_EDGE_xyz_xyZ 21
#define BOX_EDGE_xyZ_XyZ 22
#define BOX_EDGE_XyZ_xyZ 23

class csBox3
{
protected:
  csVector3 minbox;
  csVector3 maxbox;

  struct bEdge
  {
    uint8 v1, v2; // Indices of vertex in bounding box (BOX_CORNER_...)
    uint8 fl, fr; // Indices of left/right faces sharing edge (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.
  // (BOX_EDGE_...)
  static bEdge edges[24];
  // Index by 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 csVector3((minbox.x+maxbox.x)/2, (minbox.y+maxbox.y)/2, (minbox.z+maxbox.z)/2); }

  void SetCenter (const csVector3& c);

  void SetSize (const csVector3& s);

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

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

  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__