Public API Reference

csgeom/poly3d.h

Go to the documentation of this file.

/*
    Copyright (C) 1998 by Jorrit Tyberghein

    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_POLY3D_H__
#define __CS_POLY3D_H__

#include "csextern.h"

#include "csgeom/plane3.h"
#include "csgeom/vector3.h"
#include "csutil/dirtyaccessarray.h"

class csPoly2D;

enum
{
  CS_POL_SAME_PLANE = 0,
  CS_POL_FRONT = 1,
  CS_POL_BACK = 2,
  CS_POL_SPLIT_NEEDED = 3
};

class CS_CRYSTALSPACE_EXPORT csPoly3D
{
protected:
  csDirtyAccessArray<csVector3> vertices;

public:
  csPoly3D (size_t start_size = 10);

  csPoly3D (const csPoly3D& copy);

  virtual ~csPoly3D ();

  void MakeEmpty ();

  inline size_t GetVertexCount () const { return vertices.Length (); }

  inline const csVector3* GetVertices () const { return vertices.GetArray (); }

  inline csVector3* GetVertices () { return vertices.GetArray (); }

  inline const csVector3* GetVertex (size_t i) const
  {
    if (i >= vertices.Length ()) return 0;
    return &(vertices.GetArray ()[i]);
  }

  inline csVector3& operator[] (size_t i)
  {
    return vertices[i];
  }

  inline const csVector3& operator[] (size_t i) const
  {
    return vertices[i];
  }

  inline const csVector3* GetFirst () const
  { 
    if (vertices.Length ()<=0) return 0;  
    else return vertices.GetArray ();
  }

  inline const csVector3* GetLast () const
  { 
    if (vertices.Length ()<=0) return 0; 
    else return 
      &(vertices.GetArray ())[vertices.Length ()-1]; 
  }

  bool In (const csVector3& v) const;

  static bool In (csVector3* poly, size_t num_poly, const csVector3& v);

  void MakeRoom (size_t new_max);

  inline void SetVertexCount (size_t n) 
  { 
    MakeRoom (n);
    vertices.SetLength (n); 
  }

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

  size_t AddVertex (float x, float y, float z);

  inline void SetVertices (csVector3 const* v, size_t num)
  {
    MakeRoom (num);
    memcpy (vertices.GetArray (), v, num * sizeof (csVector3));
  }

  bool ProjectXPlane (const csVector3& point, float plane_x,
        csPoly2D* poly2d) const;

  bool ProjectYPlane (const csVector3& point, float plane_y,
        csPoly2D* poly2d) const;

  bool ProjectZPlane (const csVector3& point, float plane_z,
        csPoly2D* poly2d) const;

  inline bool ProjectAxisPlane (const csVector3& point, int plane_nr,
        float plane_pos, csPoly2D* poly2d) const
  {
    switch (plane_nr)
    {
      case CS_AXIS_X: return ProjectXPlane (point, plane_pos, poly2d);
      case CS_AXIS_Y: return ProjectYPlane (point, plane_pos, poly2d);
      case CS_AXIS_Z: return ProjectZPlane (point, plane_pos, poly2d);
    }
    return false;
  }

  static int Classify (const csPlane3& pl,
        const csVector3* vertices, size_t num_vertices);

  inline int Classify (const csPlane3& pl) const
  {
    return Classify (pl, vertices.GetArray (), vertices.Length ());
  }

  int ClassifyX (float x) const;

  int ClassifyY (float y) const;

  int ClassifyZ (float z) const;

  inline int ClassifyAxis (int axis, float where) const
  {
    switch (axis)
    {
      case CS_AXIS_X: return ClassifyX (where);
      case CS_AXIS_Y: return ClassifyY (where);
      case CS_AXIS_Z: return ClassifyZ (where);
    }
    return 0;
  }

  int IsAxisAligned (float& where, float epsilon = SMALL_EPSILON) const;

  int ComputeMainNormalAxis () const;

  void CutToPlane (const csPlane3& split_plane);

  void SplitWithPlane (csPoly3D& front, csPoly3D& back,
        const csPlane3& split_plane) const;

  void SplitWithPlaneX (csPoly3D& front, csPoly3D& back, float x) const;

  void SplitWithPlaneY (csPoly3D& front, csPoly3D& back, float y) const;

  void SplitWithPlaneZ (csPoly3D& front, csPoly3D& back, float z) const;

  static csVector3 ComputeNormal (const csVector3* vertices, size_t num);

  static csVector3 ComputeNormal (const csArray<csVector3>& poly);

  static csVector3 ComputeNormal (int* poly, size_t num, csVector3* vertices);

  inline csVector3 ComputeNormal () const
  {
    return ComputeNormal (vertices.GetArray (), vertices.Length ());
  }

  static csPlane3 ComputePlane (const csVector3* vertices, size_t num);

  static csPlane3 ComputePlane (const csArray<csVector3>& poly);

  static csPlane3 ComputePlane (int* poly, size_t num, csVector3* vertices);

  inline csPlane3 ComputePlane () const
  {
    return ComputePlane (vertices.GetArray (), vertices.Length ());
  }

  float GetArea() const;

  csVector3 GetCenter () const;
};

struct csCompressVertex
{
  size_t orig_idx;
  int x, y, z;
  size_t new_idx;
  bool used;
};

class CS_CRYSTALSPACE_EXPORT csVector3Array : public csPoly3D
{
public:
  csVector3Array (size_t start_size = 10) : csPoly3D (start_size) { }

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

  size_t AddVertexSmart (float x, float y, float z);

  static csCompressVertex* CompressVertices (csVector3* vertices,
        size_t num_vertices, csVector3*& new_vertices, size_t& new_count);

  static csCompressVertex* CompressVertices (csArray<csVector3>& vertices);
};

#endif // __CS_POLY3D_H__

---