---

sglPolytope.hpp

/*****************************************************************************
 * SGL: A Scene Graph Library
 *
 * Copyright (C) 1997-2001  Scott McMillan   All Rights Reserved.
 *
 * 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.
 *****************************************************************************
 *     File: sglPolytope.hpp
 *  Created: 2 January 1999
 *  Summary: A polytope is a convex 3D object delimited by plane equations.
 *           The inside of the polytope is given by the positive side of the
 *           plane equation by convention
 *****************************************************************************/

#ifndef __SGL_POLYTOPE_HPP
#define __SGL_POLYTOPE_HPP

#include <sgl.h>
#include <sglPlane.hpp>

#define SGL_MAX_PLANE_PER_POLYTOPE 6

// ---------------------------------------------------------------------------
// A polytope is a convex 3D object delimited by plane equations.  The inside
// of the polytope is given by the positive side of the plane equation by
// convention
// ---------------------------------------------------------------------------

//----------------------------------------------------------------------------
// convenience types:
//    template class 'should' only be float or double

template <class T> class sglPolytope;

typedef sglPolytope<float>  sglPolytopef;
typedef sglPolytope<double> sglPolytoped;

//----------------------------------------------------------------------------

template <class T>
class sglPolytope
{
public:
   sglPolytope() : m_num_planes(0) {};

   template <class S>
   sglPolytope(const sglPolytope<S> &rhs)
      {
         m_num_planes = rhs.getNumPlanes();
         for (unsigned int i=0; i<m_num_planes; i++)
            m_plane[i] = rhs.getPlane(i);
      }

   virtual ~sglPolytope() {};  // should this clean up the list?

   template <class S>
   sglPolytope &operator=(const sglPolytope<S> &rhs)
      {
         if (this != (sglPolytope<T>*)&rhs)
         {
            m_num_planes = rhs.getNumPlanes();
            for (unsigned int i=0; i<m_num_planes; i++)
               m_plane[i] = rhs.getPlane(i);
         }
         return *this;
      }

   inline unsigned int getNumPlanes(void) const
      {
         return m_num_planes;
      }
   inline const sglPlane<T> &getPlane(unsigned int i) const
      {
         return m_plane[i];
      }
   void addPlane(sglPlane<T> &plane)
      {
         if (m_num_planes < SGL_MAX_PLANE_PER_POLYTOPE)
            m_plane[m_num_planes++] = plane;
      }

   // apply a 3x3 transform
   template <class S>
   inline void mul(const sglPolytope<T>& p, const sglMat3<S>& m)
      {
         for (unsigned int i=0; i<p.getNumPlanes(); i++)
            m_plane[i].mul(p.getPlane(i),m);

         m_num_planes = p.getNumPlanes();
      }

   // apply a 4x4 transform
   template <class S>
   inline void mul(const sglPolytope<T>& p, const sglMat4<S>& m)
      {
         for (unsigned int i=0; i< p.getNumPlanes(); i++)
            m_plane[i].mul(p.getPlane(i),m);

         m_num_planes = p.getNumPlanes();
      }

   // apply a translation
   inline void translate(const sglPolytope<T>& p, T x, T y, T z)
      {
         for (unsigned int i=0; i<p.getNumPlanes(); i++)
            m_plane[i].translate(p.getPlane(i), x, y, z);

         m_num_planes = p.getNumPlanes();
      }

   // apply a scale
   inline void scale(const sglPolytope<T>& p, T scale)
      {
         for (unsigned int i=0; i<p.getNumPlanes(); i++)
            m_plane[i].scale(p.getPlane(i), scale);

         m_num_planes = p.getNumPlanes();
      }

   // apply a rotation
   template <class S>
   inline void rotate(const sglPolytope<T>& p, const sglMat4<S>& m)
      {
         for (unsigned int i=0; i< p.getNumPlanes(); i++)
            m_plane[i].rotate(p.getPlane(i),m);

         m_num_planes = p.getNumPlanes();
      }
   template <class S>
   inline void rotate(const sglPolytope<T>& p, const sglMat3<S>& m)
      {
         for (unsigned int i=0; i< p.getNumPlanes(); i++)
            m_plane[i].rotate(p.getPlane(i),m);

         m_num_planes = p.getNumPlanes();
      }

   friend ostream& operator<<(ostream& ostrm, const sglPolytope<T>& p)
      {
         ostrm << "[" << p.getNumPlanes() << " planes, ";

         for (unsigned int i=0; i<p.getNumPlanes(); ++i)
         {
            ostrm << " plane " << i << ": " << p.getPlane(i) << ",";
         }
         return ostrm;
      }

protected:
   // replace this with a vector of sglPlanes
   unsigned int m_num_planes;
   sglPlane<T> m_plane[SGL_MAX_PLANE_PER_POLYTOPE];
};

#endif

---