---

sglTriStruct.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: sglTriStruct.hpp
 *   Author: Scott McMillan
 *  Created: 17 July 1997
 *  Summary: triStruct objects
 *****************************************************************************/

#ifndef __SGL_TRI_STRUCT_HPP
#define __SGL_TRI_STRUCT_HPP

#include <sgldb.h>
#include <list>
#include <sglVertStruct.hpp>
#include <sglOStream.hpp>

//============================================================================

template <class T>
class sglTriStruct;

template <class T>
class sglTriList : public list< sglTriStruct<T>* > {};


//============================================================================
template <class T>
class SGLDB_DLL_API sglTriStruct
{
public:
   int index;

   T v[3];

   bool used;

   unsigned int adjcount;

public:
   typedef typename sglTriList<T>::iterator list_iterator;

   list_iterator adj[3];

   bool isDegenerate() { return ((v[0].vi == v[1].vi) ||
                                 (v[0].vi == v[2].vi) ||
                                 (v[1].vi == v[2].vi)); }

   bool isMember(T *vert) { return (*vert == v[0] || 
                                    *vert == v[1] || 
                                    *vert == v[2]); }

   T* findSameLocation(T *vert) { if (vert->vi == v[0].vi) return &v[0];
                                  if (vert->vi == v[1].vi) return &v[1];
                                  if (vert->vi == v[2].vi) return &v[2];
                                  return NULL; }

   list_iterator minadj();

   static T* notCommon(sglTriStruct *tri, sglTriStruct *tri2);

   unsigned int hash(unsigned int hashsize);

   bool isEqual(sglTriStruct *tri2);
};

//----------------------------------------------------------------------------
template <class T>
inline ostream& operator<<(ostream& ostrm, const sglTriStruct<T>& tri)
{
   ostrm << endl << "sglTriStruct address " << hex << &tri << dec << endl;
   ostrm << "   index: " << tri.index << endl;
   ostrm << "   vertex0 address: " << hex << &(tri.v[0])
         << dec << tri.v[0] << endl;
   ostrm << "   vertex1 address: " << hex << &(tri.v[1])
         << dec << tri.v[1] << endl;
   ostrm << "   vertex2 address: " << hex << &(tri.v[2])
         << dec << tri.v[2] << endl;
   ostrm << "   used: " << tri.used << endl;
   ostrm << "   adjcount: " << tri.adjcount << endl;
   ostrm << "   adjtris: " << hex;
   if (tri.adj[0] != 0)
      ostrm << *(tri.adj[0]);
   else
      ostrm << "null";
   ostrm << " ";
   if (tri.adj[1] != 0)
      ostrm << *(tri.adj[1]);
   else
      ostrm << "null";
   ostrm << " ";
   if (tri.adj[2] != 0)
      ostrm << *(tri.adj[2]);
   else
      ostrm << "null";
   ostrm << endl;
   return ostrm;
}

//----------------------------------------------------------------------------
template <class T>
inline T* sglTriStruct<T>::notCommon(sglTriStruct<T> *tri, 
                              sglTriStruct<T> *tri2)
{
   for (unsigned int i = 0; i < 3; i++)
   {
      if (!tri2->isMember(&(tri->v[i])))
         return &(tri->v[i]);
   }
   return NULL;
}


//----------------------------------------------------------------------------
template <class T>
inline sglTriStruct<T>::list_iterator sglTriStruct<T>::minadj()
{
   unsigned int min0, min1;

   switch (adjcount)
   {
      case 0:
         return 0;
      case 1:
         if (adj[0] != 0)
            return adj[0];
         else if (adj[1] != 0)
            return adj[1];
         else
            return adj[2];
      case 2:
         if (adj[0] != 0)
         {
            min0 = 0;
            if (adj[1] != 0)
               min1 = 1;
            else
               min1 = 2;
         }
         else
         {
            min0 = 1;
            min1 = 2;
         }
         if ((*(adj[min0]))->adjcount <= (*(adj[min1]))->adjcount)
            return adj[min0];
         else
            return adj[min1];
      case 3:
      default:
         if ((*(adj[0]))->adjcount <= (*(adj[1]))->adjcount)
            min0 = 0;
         else
            min0 = 1;
         min1 = 2;
         if ((*(adj[min0]))->adjcount <= (*(adj[min1]))->adjcount)
            return adj[min0];
         else
            return adj[min1];
   }
}

//----------------------------------------------------------------------------
template <class T>
inline unsigned int sglTriStruct<T>::hash(unsigned int hashsize)
{
   unsigned long val = v[0].hash() * v[1].hash() * v[2].hash();
   val = val & 0x7fffffff;
   return val % hashsize;
}

//----------------------------------------------------------------------------
template <class T>
inline bool sglTriStruct<T>::isEqual(sglTriStruct<T> *tri2)
{
   unsigned int i,j, cnt;

   cnt=0;
   for (i=0; i<3; i++)
   {
      for (j=0; j<3; j++)
      {
         if (v[i] == tri2->v[j]) cnt++;
      }
   }

   if (cnt != 3) return FALSE;

   return TRUE;
}


#endif

---