---

Plane.h

Go to the documentation of this file.

/************************************************************** ggt-head beg
 *
 * GGT: Generic Graphics Toolkit
 *
 * Original Authors:
 *   Allen Bierbaum
 *
 * -----------------------------------------------------------------
 * File:          $RCSfile: Plane.h,v $
 * Date modified: $Date: 2003/03/03 00:54:05 $
 * Version:       $Revision: 1.13 $
 * -----------------------------------------------------------------
 *
 *********************************************************** ggt-head end */
/*************************************************************** ggt-cpr beg
*
* GGT: The Generic Graphics Toolkit
* Copyright (C) 2001,2002 Allen Bierbaum
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
 ************************************************************ ggt-cpr end */
#ifndef _GMTL_PLANE_H
#define _GMTL_PLANE_H

#include <gmtl/Vec.h>
#include <gmtl/Point.h>
#include <gmtl/VecOps.h>

namespace gmtl
{

template< class DATA_TYPE>
class Plane
{
public:
   Plane()
      : mOffset( 0 )
   {}

   Plane( const Point<DATA_TYPE, 3>& pt1, const Point<DATA_TYPE, 3>& pt2,
          const Point<DATA_TYPE, 3>& pt3)
   {
      Vec<DATA_TYPE, 3> vec12( pt2-pt1 );
      Vec<DATA_TYPE, 3> vec13( pt3-pt1 );

      mNorm = cross( vec12, vec13 );
      normalize( mNorm );

      mOffset = dot( static_cast< Vec<DATA_TYPE, 3> >(pt1), mNorm );  // Graphics Gems I: Page 390
   }

   Plane( const Vec<DATA_TYPE, 3>& norm, const Point<DATA_TYPE, 3>& pt )
      : mNorm( norm )
   {
      mOffset = dot( static_cast< Vec<DATA_TYPE, 3> >(pt), norm );
   }

   Plane( const Vec<DATA_TYPE, 3>& norm, const DATA_TYPE& dPlaneConst )
      : mNorm( norm ), mOffset( dPlaneConst )
   {}

   Plane( const Plane<DATA_TYPE>& plane )
      : mNorm( plane.mNorm ), mOffset( plane.mOffset )
   {}

   const Vec<DATA_TYPE, 3>& getNormal() const
   {
      return mNorm;
   }

   void setNormal( const Vec<DATA_TYPE, 3>& norm )
   {
      mNorm = norm;
   }

   const DATA_TYPE& getOffset() const
   {
      return mOffset;
   }

   void setOffset( const DATA_TYPE& offset )
   {
      mOffset = offset;
   }

public:
   // dot(Pt,mNorm) = mOffset
   Vec<DATA_TYPE, 3> mNorm;

   DATA_TYPE mOffset;
};

typedef Plane<float> Planef;
typedef Plane<double> Planed;

/*
#include <geomdist.h>


// Intersects the plane with a given segment.
// Returns TRUE if there is a hit (within the seg).
// Also returns the distance "down" the segment of the hit in t.
//
// PRE: seg.dir must be normalized
//
int sgPlane::isect(sgSeg& seg, float* t)
{
   // Graphic Gems I: Page 391
   float denom = normal.dot(seg.dir);
   if (SG_IS_ZERO(denom))     // No Hit
   {
      //: So now, it is just dist to plane tested against length
      sgVec3   hit_pt;
      float    hit_dist;      // Dist to hit
      
      hit_dist = findNearestPt(seg.pos, hit_pt);
      *t = hit_dist;       // Since dir is normalized

      if(seg.tValueOnSeg(*t))
         return 1;
      else
         return 0;
   }
   else
   {
      float numer = offset + normal.dot(seg.pos);
      (*t) = -1.0f * (numer/denom);
      
      if(seg.tValueOnSeg(*t))
         return 1;
      else
         return 0;
   }
}

 // Intersects the plane with the line defined
 // by the given segment
 //
 // seg - seg that represents the line to isect
 // t   - the t value of the isect
 //
int sgPlane::isectLine(const sgSeg& seg, float* t)
{
   // GGI: Pg 299
   // Lu = seg.pos;
   // Lv = seg.dir;
   // Jn = normal;
   // Jd = offset;
   
   float denom = normal.dot(seg.dir);
   if(denom == 0.0f)
      return 0;
   else
   {
      *t = - (offset+ normal.dot(seg.pos))/(denom);
      return 1;
   }
}
*/

} // namespace gmtl
#endif

---