Public API Reference

csgeom/math3d.h

Go to the documentation of this file.

/*
    Copyright (C) 1998-2005 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_MATH3D_H__
#define __CS_MATH3D_H__

#include "csextern.h"

#include "csgeom/box.h"
#include "csgeom/frustum.h"
#include "csgeom/plane3.h"
#include "csgeom/segment.h"
#include "csgeom/vector3.h"
#include "csutil/ref.h"
#include "csutil/scf_implementation.h"

#include "iutil/dbghelp.h"

struct iString;
class csPlane2;
class csPoly3D;

class CS_CRYSTALSPACE_EXPORT csMath3
{
public:
  static int WhichSide3D (const csVector3& p,
                          const csVector3& v1, const csVector3& v2)
  {
//    float s = p * (v1%v2);  (original expression: expanded to the below:)
    float s = p.x*(v1.y*v2.z-v1.z*v2.y) + p.y*(v1.z*v2.x-v1.x*v2.z) +
              p.z*(v1.x*v2.y-v1.y*v2.x);
    if (s < 0) return 1;
    else if (s > 0) return -1;
    else return 0;
  }

  static bool Visible (const csVector3& p, const csVector3& t1,
                       const csVector3& t2, const csVector3& t3);

  static bool Visible (const csVector3& p, const csPlane3& pl)
  { return pl.Classify (p) <= 0; }

  static void Between (const csVector3& v1, const csVector3& v2, csVector3& v,
                       float pct, float wid);

  static void SetMinMax (const csVector3& v,
                         csVector3& min, csVector3& max)
  {
    if (v.x > max.x) max.x = v.x; else if (v.x < min.x ) min.x = v.x;
    if (v.y > max.y) max.y = v.y; else if (v.y < min.y ) min.y = v.y;
    if (v.z > max.z) max.z = v.z; else if (v.z < min.z ) min.z = v.z;
  }

  inline static float DoubleArea3 (const csVector3 &a, const csVector3 &b,
                             const csVector3 &c)
  {
    csVector3 v1 = b - a;
    csVector3 v2 = c - a;
    return (v1 % v2).Norm ();
  }

  inline static float Direction3 (const csVector3 &a, const csVector3 &b,
                             const csVector3 &c)
  {
    csVector3 v1 = b - a;
    csVector3 v2 = c - a;
    return ((v1.y * v2.z + v1.z * v2.x + v1.x * v2.y) -
            (v1.y * v2.x + v1.x * v2.z + v1.z * v2.y));
  }

  inline static void CalcNormal (csVector3& norm,     const csVector3& v1,
                                 const csVector3& v2, const csVector3& v3)
  {
    norm = (v1-v2)%(v1-v3);
  }

  static void CalcNormal (csVector3& norm,
                          const csVector3& v, const csVector3& u)
  { norm = u%v; /* NOT v%u - vertexes are defined clockwise */ }

  static void CalcPlane (const csVector3& v1, const csVector3& v2,
         const csVector3& v3, csVector3& normal, float& D)
  {
    CalcNormal (normal, v1, v2, v3);
    D = - (normal * v1);
  }

  static bool PlanesEqual (const csPlane3& p1, const csPlane3& p2)
  {
    return ( ( p1.norm - p2.norm) < (float).001 ) &&
             (  ABS (p1.DD-p2.DD) < (float).001 );
  }

  static bool PlanesClose (const csPlane3& p1, const csPlane3& p2);

  static int OuterPlanes (const csBox3& box1, const csBox3& box2,
    csPlane3* planes);

  static int FindObserverSides (const csBox3& box1, const csBox3& box2,
        int* sides);

  static void SpherePosition (float angle_xz, float angle_vert,
        csVector3& pos);
};

class CS_CRYSTALSPACE_EXPORT csSquaredDist
{
public:
  static float PointPoint (const csVector3& p1, const csVector3& p2)
  {
    csVector3 d = (p1-p2);
    return d*d;
  }

  static float PointLine (const csVector3& p,
                          const csVector3& l1, const csVector3& l2);

  static float PointPlane (const csVector3& p, const csPlane3& plane)
  { float r = plane.Classify (p);  return r * r; }

  static float PointPoly (const csVector3& p, csVector3 *V, int n,
                          const csPlane3& plane, float sqdist = -1);
};

class CS_CRYSTALSPACE_EXPORT csIntersect3
{
private:
  static bool BoxPlaneInternal (const csVector3& normal,
        const csVector3& vert, const csVector3& boxhalfsize);

public:
  static bool PlanePolygon (const csPlane3& plane, csPoly3D* poly,
        csSegment3& segment);

  static int SegmentFrustum (csPlane3* planes, int num_planes,
        csSegment3& seg);

  static bool SegmentTriangle (const csSegment3& seg,
        const csVector3& tr1,
        const csVector3& tr2, const csVector3& tr3,
        csVector3& isect);

  static bool SegmentPolygon (const csSegment3& seg, const csPoly3D& poly,
        const csPlane3& poly_plane, csVector3& isect);

  static bool SegmentPlanes (
     const csVector3& u, const csVector3& v,
     const csPlane3* planes, int length,
     csVector3& isect, float& dist);

  static bool SegmentPlane (
    const csVector3& u, const csVector3& v,
    const csVector3& normal, const csVector3& a, // plane
    csVector3& isect, float& dist);              // intersection point

  static bool SegmentPlane (
    const csVector3& u, const csVector3& v,
    const csPlane3& p,                     // plane Ax+By+Cz+D=0
    csVector3& isect,                     // intersection point
    float& dist);                       // distance from u to isect

  static bool ThreePlanes (const csPlane3& p1, const csPlane3& p2,
        const csPlane3& p3, csVector3& isect);

  static bool PlaneXPlane (const csPlane3& p1, float x2, csPlane2& isect);

  static bool PlaneYPlane (const csPlane3& p1, float y2, csPlane2& isect);

  static bool PlaneZPlane (const csPlane3& p1, float z2, csPlane2& isect);

  static bool PlaneAxisPlane (const csPlane3& p1, int nr, float pos,
        csPlane2& isect)
  {
    switch (nr)
    {
      case 0: return PlaneXPlane (p1, pos, isect);
      case 1: return PlaneYPlane (p1, pos, isect);
      case 2: return PlaneZPlane (p1, pos, isect);
    }
    return false;
  }

  static float SegmentZ0Plane (
    const csVector3& v1, const csVector3& v2,
    csVector3& isect);                    // intersection point

  static float SegmentZ0Plane (
    const csSegment3& uv,
    csVector3& isect)                    // intersection point
  {
    return SegmentZ0Plane (uv.Start (), uv.End (), isect);
  }

  static float SegmentXPlane (
    const csVector3& u, const csVector3& v,
    float xval,
    csVector3& isect);                    // intersection point

  static float SegmentXPlane (
    const csSegment3& uv,
    float xval,
    csVector3& isect)                     // intersection point
  {
    return SegmentXPlane (uv.Start (), uv.End (), xval, isect);
  }

  static float SegmentYPlane (
    const csVector3& u, const csVector3& v,
    float yval,      // plane y = yval
    csVector3& isect);                    // intersection point

  static float SegmentYPlane (
    const csSegment3& uv,
    float yval,      // plane y = yval
    csVector3& isect)                     // intersection point
  {
    return SegmentYPlane (uv.Start (), uv.End (), yval, isect);
  }

  static float SegmentZPlane (
    const csVector3& u, const csVector3& v,
    float zval,      // plane z = zval
    csVector3& isect);                    // intersection point

  static float SegmentZPlane (
    const csSegment3& uv,
    float zval,      // plane z = zval
    csVector3& isect)                     // intersection point
  {
    return SegmentZPlane (uv.Start (), uv.End (), zval, isect);
  }

  static float SegmentAxisPlane (const csVector3& u, const csVector3& v,
        int nr, float pos, csVector3& isect)
  {
    switch (nr)
    {
      case 0: return SegmentXPlane (u, v, pos, isect);
      case 1: return SegmentYPlane (u, v, pos, isect);
      case 2: return SegmentZPlane (u, v, pos, isect);
    }
    return 0.0;
  }

  static float SegmentXFrustum (
    const csVector3& u, const csVector3& v, float A, csVector3& isect);

  static float SegmentXFrustum (
    const csSegment3& uv, float A, csVector3& isect)
  {
    return SegmentXFrustum (uv.Start (), uv.End (), A, isect);
  }

  static float SegmentYFrustum (
    const csVector3& u, const csVector3& v, float B, csVector3& isect);

  static float SegmentYFrustum (
    const csSegment3& uv, float B, csVector3& isect)
  {
    return SegmentYFrustum (uv.Start (), uv.End (), B, isect);
  }

  static int BoxSegment (const csBox3& box, const csSegment3& segment,
        csVector3& isect, float* pr = 0);

  static bool BoxFrustum (const csBox3& box, csPlane3* frustum,
        uint32 inClipMask, uint32& outClipMask);

  static bool BoxFrustum (const csBox3& box, const csFrustum* frustum);

  static bool BoxSphere (const csBox3& box, const csVector3& center,
                  float sqradius);

  static bool BoxPlane (const csBox3& box, const csPlane3& plane);

  static bool BoxPlane (const csBox3& box, const csVector3& normal,
        const csVector3& vert);

  static bool BoxTriangle (const csBox3& box,
        const csVector3& tri0, const csVector3& tri1, const csVector3& tri2);

  static bool BoxBox (const csBox3& box1, const csBox3& box2)
  {
    return box1.TestIntersect (box2);
  }

  static csPtr<csFrustum> FrustumFrustum (const csFrustum& f1,
        const csFrustum& f2)
  {
    return f1.Intersect (f2);
  }

  static csPtr<csFrustum> FrustumFrustum (const csFrustum& f1,
        csVector3* poly, int num)
  {
    return f1.Intersect (poly, num);
  }

  static bool TriangleTriangle (const csVector3 tri1[3],
                         const csVector3 tri2[3]);

  static bool TriangleTriangle (const csVector3 tri1[3],
                         const csVector3 tri2[3],
                         csSegment3& isectline, bool& coplanar);
};

class CS_CRYSTALSPACE_EXPORT csGeomDebugHelper :
  public scfImplementation1<csGeomDebugHelper, iDebugHelper>
{
public:
  csGeomDebugHelper ();
  virtual ~csGeomDebugHelper ();

  virtual int GetSupportedTests () const
  {
    return CS_DBGHELP_UNITTEST;
  }
  virtual csPtr<iString> UnitTest ();
  virtual csPtr<iString> StateTest ()
  {
    return 0;
  }
  virtual csTicks Benchmark (int /*num_iterations*/)
  {
    return 0;
  }
  virtual csPtr<iString> Dump ()
  {
    return 0;
  }
  virtual void Dump (iGraphics3D* /*g3d*/)
  {
  }
  virtual bool DebugCommand (const char*)
  {
    return false;
  }
};

#endif // __CS_MATH3D_H__

---