---

sglPlane.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: sglPlane.hpp
 *  Created: 2 January 1999
 *  Summary: defines a plane in 3D space for defining polytopes
 *****************************************************************************/

#ifndef __SGL_PLANE_HPP
#define __SGL_PLANE_HPP

#include <assert.h>
#include <sgl.h>
#include <sglVector.hpp>
#include <sglMatrix.hpp>

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

template <class T> class sglPlane;

typedef sglPlane<float>  sglPlanef;
typedef sglPlane<double> sglPlaned;

//----------------------------------------------------------------------------
template <class T>
class sglPlane
{
public:
   sglPlane() {};
   sglPlane(const sglPlane &rhs) :
         m_normal(rhs.m_normal), m_distance(rhs.m_distance) {};

   sglPlane(const sglVec3<T> &n, T d) :
         m_normal(n), m_distance(d) { normalize(); }

   sglPlane(T x, T y, T z, T d) :
         m_normal(x,y,z), m_distance(d) { normalize(); }

   ~sglPlane() {};

#ifndef WIN32
   inline sglPlane& operator=(const sglPlane &rhs)
      {
         if (this != &rhs)
         {
            m_normal   = rhs.m_normal;
            m_distance = rhs.m_distance;
         }
         return *this;
      }
#endif

   template <class S>
   inline sglPlane<T>& operator=(const sglPlane<S> &rhs)
      {
         if (this != (sglPlane<T>*) &rhs)
         {
            m_normal   = rhs.getNormal();
            m_distance = rhs.getDistance();
         }
         return *this;
      }

   template <class S>
   inline void set(const sglVec3<S>& normal, T distance)
      {
         m_normal = normal; m_distance = distance; normalize();
      }
   inline const sglVec3<T>& getNormal() const { return m_normal; }
   inline T getDistance() const { return m_distance; }

   // convert plane equation to "hessian normal" form for fast distance calc. 
   inline void normalize()
      {
         T len = m_normal.normalize();
         m_distance *= (1.0/len);
      }

   // build a plane from 3 points
   // convention is that the points are given in direct (CCW) order
   bool build(const sglVec3<T>& p1,
              const sglVec3<T>& p2,
              const sglVec3<T>& p3);

   // get 3 points that define the plane
   bool getVertices(sglVec3<T>& p1, sglVec3<T>& p2, sglVec3<T>& p3) const;

   // apply a 3x3 transformation
   template <class S>
   inline void mul(const sglPlane<T>& p, const sglMat3<S>& m)
      {
         ::mulTranspose(p.getNormal(), m, m_normal);
         m_distance = p.getDistance();
      }
        
   // apply a 4x4 transformation
   template <class S>
   void mul(const sglPlane<T>& p, const sglMat4<S>& m)
      {
         // find out what the normal is now
         sglVec4<T> normal;
         ::mul(p.getNormal(), (T)0, m, normal);
         T zoom = normal.normalize();

         // What is the transformed distance ?
         sglVec3<T> translation(m[3][0],m[3][1],m[3][2]);
         translation *= (1.0/zoom);
         m_distance = p.getDistance() - (normal[0]*translation[0] +
                                         normal[1]*translation[1] +
                                         normal[2]*translation[2]);
         m_distance *= zoom;
         m_normal.set(normal[0], normal[1], normal[2]);
      }

   // apply a translation only
   void translate(const sglPlane<T>& p, T x, T y, T z)
      {
         m_normal = p.getNormal();

         m_distance = p.getDistance() - (m_normal[0]*x +
                                         m_normal[1]*y +
                                         m_normal[2]*z);
      }

   // apply a scale only VERIFY
   void scale(const sglPlane<T>& p, T scale)
      {
         m_normal = p.getNormal();
         m_distance = p.getDistance()*scale;
      }

   // apply a rotation only
   template <class S>
   void rotate(const sglPlane<T>& p, const sglMat4<S>& m)
      {
         sglVec4<T> normal;
         ::mul(p.getNormal(), (T)0, m, normal);
         T zoom = normal.normalize();

         m_distance = p.getDistance()*zoom;
         m_normal.set(normal[0], normal[1], normal[2]);
      }
   template <class S>
   void rotate(const sglPlane<T>& p, const sglMat3<S>& m)
      {
         sglVec3<T> normal;
         ::mul(p.getNormal(), m, normal);
         T zoom = normal.normalize();

         m_distance = p.getDistance()*zoom;
         m_normal = normal;
      }

   // compute the signed distance of a vertex
   template <class S>
   inline float signedDistance(const sglVec3<S>& p) const
      {
         return m_normal.dot(p) + m_distance;
      }

   friend ostream& operator<<(ostream& ostrm, const sglPlane<T>& p)
      {
         return (ostrm << "[" << p.getNormal() << ", "
                       << p.getDistance() << "]");
      }

private:
   sglVec3<T> m_normal;
   T          m_distance;
};

//----------------------------------------------------------------------------
//    Summary: 
// Parameters: 
//    Returns: 
//----------------------------------------------------------------------------
template <class T>
inline bool sglPlane<T>::build(const sglVec3<T>& p1,
                               const sglVec3<T>& p2,
                               const sglVec3<T>& p3)
{
   sglVec3<T> v1,v2;
   v1.sub(p1,p2);
   v2.sub(p3,p2);

   m_normal.cross(v1,v2);
   float d = m_normal.normalize();
   if (d == 0.f)
      return false;

   // p2 is on the plane
   m_distance = -(m_normal.dot(p2));

   return true;
}

//----------------------------------------------------------------------------
//    Summary: 
// Parameters: 
//    Returns: 
//----------------------------------------------------------------------------
template <class T>
inline bool sglPlane<T>::getVertices(sglVec3<T>& pnt1,
                                     sglVec3<T>& pnt2,
                                     sglVec3<T>& pnt3) const
{
   // find a starting point
   sglVec3<T> p1,p2,p3;

   int index = 0;
   float max = SGL_ABS(m_normal[index]);
   if (SGL_ABS(m_normal[1]) > max)
   {
      index = 1;
      max = SGL_ABS(m_normal[index]);
   }
   if (SGL_ABS(m_normal[2]) > max)
   {
      index = 2;
   }

   p2.set(((index == 0) ? (-m_distance/m_normal[0]) : 0),
          ((index == 1) ? (-m_distance/m_normal[1]) : 0),
          ((index == 2) ? (-m_distance/m_normal[2]) : 0));

   // search for two vectors
   sglVec3<T> temp(((index == 0) ? 0 : 1),
                   ((index == 1) ? 0 : 1),
                   ((index == 2) ? 0 : 1));

   p1.cross(m_normal,temp);
   p3.cross(m_normal,p1);

   temp.cross(p1,p3);
        
   p1 += p2;
   p3 += p2;

   // check for consistency
   sglPlane<T> testplane;
   testplane.build(p1,p2,p3);

   sglVec3<T> n = testplane.getNormal();
   if (n[0]*m_normal[0] < 0)
   {
      pnt1 = p3;
      pnt2 = p2;
      pnt3 = p1;
   }
   else
   {
      pnt1 = p1;
      pnt2 = p2;
      pnt3 = p3;
   }
   return true;
}

#endif

---