Public API Reference

csgeom/frustum.h

Go to the documentation of this file.

/*
  Copyright (C) 1998-2001 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_FRUSTRUM_H__
#define __CS_FRUSTRUM_H__

#include "csextern.h"

#include "cstypes.h"
#include "csgeom/vector3.h"

class csPlane3;
template<class T>
class csPtr;
class csTransform;

enum
{
  CS_FRUST_OUTSIDE = 0,
  CS_FRUST_INSIDE = 1,
  CS_FRUST_COVERED = 2,
  CS_FRUST_PARTIAL = 3
};
enum csClipType
{
  CS_CLIPINFO_ORIGINAL = 0,
  CS_CLIPINFO_ONEDGE = 1,
  CS_CLIPINFO_INSIDE = 2
};

struct CS_CRYSTALSPACE_EXPORT csClipInfo
{

  csClipType type; // One of CS_CLIPINFO_???
  union
  {
    struct { int idx; } original;
    struct { int i1, i2; float r; } onedge;
    struct { csClipInfo* ci1, * ci2; float r; } inside;
  };

  csClipInfo () : type (CS_CLIPINFO_ORIGINAL) { }
  void Clear ();
  ~csClipInfo () { Clear (); }

  inline void Copy (csClipInfo& other)
  {
    if (&other == this) return;
    Clear ();
    type = other.type;
    if (type == CS_CLIPINFO_INSIDE)
    {
      inside.r = other.inside.r;
      inside.ci1 = new csClipInfo ();
      inside.ci1->Copy (*other.inside.ci1);
      inside.ci2 = new csClipInfo ();
      inside.ci2->Copy (*other.inside.ci2);
    }
    else if (type == CS_CLIPINFO_ORIGINAL)
      original.idx = other.original.idx;
    else
      onedge = other.onedge;
  }

  inline void Move (csClipInfo& other)
  {
    if (&other == this) return;
    Clear ();
    type = other.type;
    if (type == CS_CLIPINFO_INSIDE)
      inside = other.inside;
    else if (type == CS_CLIPINFO_ORIGINAL)
      original.idx = other.original.idx;
    else
      onedge = other.onedge;
    other.type = CS_CLIPINFO_ORIGINAL;
  }

  inline void Dump (int indent)
  {
    char ind[255];
    int i;
    for (i = 0 ; i < indent ; i++) ind[i] = ' ';
    ind[i] = 0;
    switch (type)
    {
      case CS_CLIPINFO_ORIGINAL:
        printf ("%s ORIGINAL idx=%d\n", ind, original.idx);
        break;
      case CS_CLIPINFO_ONEDGE:
        printf ("%s ONEDGE i1=%d i2=%d r=%g\n", ind, onedge.i1, onedge.i2,
          onedge.r);
        break;
      case CS_CLIPINFO_INSIDE:
        printf ("%s INSIDE r=%g\n", ind, inside.r);
        inside.ci1->Dump (indent+2);
        inside.ci2->Dump (indent+2);
        break;
    }
    fflush (stdout);
  }
};

class CS_CRYSTALSPACE_EXPORT csFrustum
{
private:
  csVector3 origin;

  csVector3* vertices;
  int num_vertices;
  int max_vertices;

  csPlane3* backplane;

  bool wide;

  bool mirrored;

  int ref_count;

  void Clear ();

  void ExtendVertexArray (int num);

public:

  csFrustum (const csVector3& o) :
    origin (o), vertices (0), num_vertices (0), max_vertices (0),
    backplane (0), wide (false), mirrored (false), ref_count (1)
  { }

  csFrustum (const csVector3& o, csVector3* verts, int num_verts,
        csPlane3* backp = 0);

  csFrustum (const csVector3& o, int num_verts,
        csPlane3* backp = 0);

  csFrustum (const csFrustum &copy);

  virtual ~csFrustum ();

  inline void SetOrigin (const csVector3& o) { origin = o; }

  inline csVector3& GetOrigin () { return origin; }

  inline const csVector3& GetOrigin () const { return origin; }

  inline void SetMirrored (bool m) { mirrored = m; }

  inline bool IsMirrored () const { return mirrored; }

  void SetBackPlane (const csPlane3& plane);

  inline csPlane3* GetBackPlane () const { return backplane; }

  void RemoveBackPlane ();

  void AddVertex (const csVector3& v);

  inline int GetVertexCount () const { return num_vertices; }

  inline csVector3& GetVertex (int idx)
  {
    CS_ASSERT (idx >= 0 && idx < num_vertices);
    return vertices[idx];
  }

  inline const csVector3& GetVertex (int idx) const
  {
    CS_ASSERT (idx >= 0 && idx < num_vertices);
    return vertices[idx];
  }

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

  void Transform (csTransform* trans);

  void ClipToPlane (csVector3& v1, csVector3& v2);

  static void ClipToPlane (csVector3* vertices, int& num_vertices,
    csClipInfo* clipinfo, const csVector3& v1, const csVector3& v2);

  static void ClipToPlane (csVector3* vertices, int& num_vertices,
    csClipInfo* clipinfo, const csPlane3& plane);

  void ClipPolyToPlane (csPlane3* plane);

  csPtr<csFrustum> Intersect (const csFrustum& other) const;

  csPtr<csFrustum> Intersect (csVector3* poly, int num) const;

  static csPtr<csFrustum> Intersect (
    const csVector3& frust_origin, csVector3* frust, int num_frust,
    csVector3* poly, int num);

  static csPtr<csFrustum> Intersect (
    const csVector3& frust_origin, csVector3* frust, int num_frust,
    const csVector3& v1, const csVector3& v2, const csVector3& v3);

  static int Classify (csVector3* frustum, int num_frust,
    csVector3* poly, int num_poly);

  static int BatchClassify (csVector3* frustum, csVector3* frustumNormals,
        int num_frust, csVector3* poly, int num_poly);

  bool Contains (const csVector3& point);

  static bool Contains (csVector3* frustum, int num_frust,
    const csVector3& point);

  static bool Contains (csVector3* frustum, int num_frust,
    const csPlane3& plane, const csVector3& point);

  inline bool IsEmpty () const { return !wide && vertices == 0; }

  inline bool IsInfinite () const { return wide && vertices == 0 && backplane == 0; }

  inline bool IsWide () const { return wide && vertices == 0; }

  void MakeInfinite ();

  void MakeEmpty ();

  inline void IncRef () { ref_count++; }
  inline void DecRef () { if (ref_count == 1) delete this; else ref_count--; }
  inline int GetRefCount () { return ref_count; }
};

#endif // __CS_FRUSTRUM_H__

---