---

sglSegment.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: sglSegment.hpp
 *  Created: 17 November 1998
 *  Summary: 
 *****************************************************************************/

#ifndef __SGL_SEGMENT_HPP
#define __SGL_SEGMENT_HPP

#include <sgl.h>
#include <GL/gl.h>
#include <sglVec3.hpp>
#include <sglVec4.hpp>
#include <sglMat4.hpp>

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

template <class T> class sglSegment;

typedef sglSegment<float>  sglSegmentf;
typedef sglSegment<double> sglSegmentd;

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

template <class T>
class sglSegment
{
public:
   sglSegment() {}; // no initialization

   // this constructor assumes dir is already normalized
   sglSegment(const sglVec3<T> &pos, const sglVec3<T> &dir, T len)
         : m_pos(pos), m_dir(dir), m_len(len) {};

   // build a segment that starts at p1 and ends at p2
   sglSegment(const sglVec3<T> &p1,  const sglVec3<T> &p2)
         : m_pos(p1)
      {
         m_dir = p2;
         m_dir -= p1;
         m_len = m_dir.normalize();
      }

   // copy a segment
   sglSegment(const sglSegment<T> &seg)
         : m_pos(seg.getPos()),
           m_dir(seg.getDir()),
           m_len(seg.getLen())
           
      {
      }

   ~sglSegment() {};

   inline sglSegment &operator=(const sglSegment<T> seg)
      {
         if (this != &seg)
         {
            m_pos = seg.getPos();
            m_dir = seg.getDir();
            m_len = seg.getLen();
         }
         return *this;
      }


   void setPos(const sglVec3<T> &pos) { m_pos = pos; }
   void setDir(const sglVec3<T> &dir) { m_dir = dir; }  // dir must be normed
   void setLen(T len) { m_len = len; }

   const sglVec3<T>& getPos() const { return m_pos; }
   const sglVec3<T>& getDir() const { return m_dir; }
   T getLen() const { return m_len; }

   sglVec3<T> getEndPoint() const
      {
         return (sglVec3<T>(m_pos[0] + m_len*m_dir[0],
                            m_pos[1] + m_len*m_dir[1],
                            m_pos[2] + m_len*m_dir[2]));
      }

   void clip(const sglSegment<T>& seg, T d1, T d2)
      {
         if (d2 < d1)
         {
            m_dir = seg.getDir();
            m_dir *= -1;

            m_pos = m_dir;
            m_pos *= d1;
            m_pos = seg.getPos();

            m_len = d1 - d2;
         }
         else
         {
            m_dir = seg.getDir();

            m_pos = m_dir;
            m_pos *= d1;
            m_pos += seg.getPos();

            m_len = d2 - d1;
         }
      }

   void makePts(const sglVec3<T> &p1,  const sglVec3<T> &p2)
      {
         m_pos = p1;
         m_dir = p2;
         m_dir -= p1;
         m_len = m_dir.normalize();
      }

   // angles and radians
   void makePolar(const sglVec3<T> &pos, double heading, double pitch, T len)
      {
         m_pos = pos;
         m_len = len;
         m_dir.set(-sin(heading)*cos(pitch),
                   cos(heading)*cos(pitch),
                   sin(pitch));
      }

   // ---------------------------------------------------------
   // Transformations
   template <class S>
   void mul(const sglMat4<S> &mat)
      {
         sglVec4<T> pos, dir;
         ::mul(m_pos, (T)1.0, mat, pos);
         ::mul(m_dir, (T)0.0, mat, dir);
         m_pos.set(pos[0], pos[1], pos[2]);
         m_dir.set(dir[0], dir[1], dir[2]);
      }

   template <class S>
   void translate(S x, S y, S z)
      {
         m_pos[0] += x;
         m_pos[1] += y;
         m_pos[2] += z;
      }

   template <class S>
   void scale(S scale)
      {
         m_pos[0] *= scale;
         m_pos[1] *= scale;
         m_pos[2] *= scale;
         m_len *= scale;
      }

   // ---------------------------------------------------------
   // Informational output
   void drawImmediate() const;

#if defined(TEMPLATE_OSTREAM_HACK)
   template <class S> 
   friend ostream &operator<<(ostream &ostrm, const sglSegment<S> &segment);
#else
   friend ostream &operator<<(ostream &ostrm, const sglSegment<T> &segment)
      {
         return (ostrm << "segment [ origin = " << segment.m_pos
                 << ", dir = " << segment.m_dir
                 << ", length = " << segment.m_len << "]");
      }
#endif

protected:
   sglVec3<T>  m_pos;
   sglVec3<T>  m_dir;  // normalized
   T m_len;
};

//----------------------------------------------------------------------------
#if defined(TEMPLATE_OSTREAM_HACK)
template <class T>
inline ostream &operator<<(ostream &ostrm, const sglSegment<T> &segment)
{
    return (ostrm << "segment [ origin = " << segment.m_pos
            << ", dir = " << segment.m_dir
            << ", length = " << segment.m_len << "]");
}
#endif

//----------------------------------------------------------------------------
template <class T>
inline void sglSegment<T>::drawImmediate() const
{
   glBegin(GL_LINES);
   glVertex3f(m_pos[0], m_pos[1], m_pos[2]);
   glVertex3f(m_pos[0] + m_len*m_dir[0],
              m_pos[1] + m_len*m_dir[1],
              m_pos[2] + m_len*m_dir[2]);
   glEnd();
}

#endif

---