triangleIndirect.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2000 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: triInd.h,v $ $Revision: 1.25 $ $State: Exp $
*********************************************************************/

#ifndef triangleIndirect_H_
#define triangleIndirect_H_

#include "gdb/gdbDefines.h"
#include "gdb/baseTriangle.h"
#include "gdb/vertexManager.h"
#include "gdb/surfaceManager.h"
#include "geometry/point.h"

#include <vlutil/vlPrint.h>
#include <assert.h>

// forward declarations
class DtSurfaceManager;
class DtPolygonIndirect;


// class DtTriangleIndirect:
//
// DtTriangleIndirect allows for the specification of the
// vertices of a polygon as indices into a vertex Manager.

class DT_DLL_gdb DtTriangleIndirect : public DtBaseTriangle
{
public:

   // constructor using a polygon indirect.
   DtTriangleIndirect(const DtPolygonIndirect* const poly);

   // constructor with vertex IDs, vertex manager, surface manager, 
   // and surface ID 
   DtTriangleIndirect(DtVertexManager* const vertManager, 
                      const DtVertexID vertID0, 
                      const DtVertexID vertID1, 
                      const DtVertexID vertID2, 
                      DtSurfaceManager* const surfMgr,
                      const DtSurfaceID surfID);

   // destructor
   virtual ~DtTriangleIndirect();

   // copy constructor
   DtTriangleIndirect(const DtTriangleIndirect& orig);

   // assignment operator
   DtTriangleIndirect& operator=(const DtTriangleIndirect& orig);

   // computes the intersection of chord with polygon; returns
   // intersection point.
   virtual bool intersect(const DtChord& chord, 
                                DtPoint& intersectionPoint, 
                                double& t) const;

   // Since this class only overrides one of the intersection functions, 
   // specify that its using the base classes to prevent hiding.
   using DtBaseTriangle::intersect;
   using DtBaseTriangle::intersectBundle;
   using DtBaseTriangle::allIntersectsAlongChordBundle;
   
   // returns extent of the triangle
   inline DtExtent extent() const;

   // vertex accessors
   inline DtPoint& vertex0();
   inline const DtPoint& vertex0() const;

   inline DtPoint& vertex1();
   inline const DtPoint& vertex1() const;
   
   inline DtPoint& vertex2();
   inline const DtPoint& vertex2() const;

   virtual bool getVertex(DtPoint& retVal, unsigned int localIndex) const;
   const DtPoint& getVertex(unsigned int localIndex) const;

   // Requires index be a valid localIndex into the list of vertex IDs.
   virtual DtVertexID getVertexID(unsigned int localIndex) const;

   virtual void setVertex(unsigned int localIndex, DtVertexID vertexID);

   // get the surface associated with the triangle
   virtual bool getSurface(DtSurface& s) const;
   const DtSurface& getSurface() const;

   // get the surface ID associated with the triangle
   virtual DtSurfaceID getSurfaceID() const;

   // set the surface associated with the triangle
   // If the ID is a valid surface ID, then it sets the 
   // surface and returns true.  If the ID is invalid,
   // the it returns false and does NOT set the surface.
   virtual bool setSurface(DtSurfaceID surfaceID);

   // Sets the surface of the associated triangle.  
   // \return A boolean indicating whether or not the surface could be set.
   // \note \b Implementation \b detail! - Does not add the surface if it already 
   // exists in the surface manager.
   virtual bool setSurface(const DtSurface& newSurface);

   // get the vertex Manager associated with the polygon
   inline virtual DtVertexManager* const vertexManager() const;

   // get a pointer to the the surface Manager associated with the triangle
   inline virtual DtSurfaceManager* const surfaceManager() const;

   // debugging aid function
   virtual void dump(int indentLevel) const;

   // Applies the specified transform to its vertices.  If the flag 
   // is true, will create new vertices instead of modifying existing 
   // ones.  Returns false if the transformation fails for any reason.
   virtual bool applyTransform(const DtHomogeneousTransformMatrix& matrix,
                               bool createNewVertices);

// Unsafe public functions: These functions expose the internals of 
// the object.They are unsafe in that, should the implementation change,
// these functions are not guaranteed to stay the same.  Any use of these 
// functions assumes the risk they will be broken by future changes to the 
// internals of this class

   // default constructor
   DtTriangleIndirect();

   // constructor with vertex indices and vertex manager to
   // index into
   DtTriangleIndirect(DtVertexManager* vertMgr,
                      const DtVertexID ind0, 
                      const DtVertexID ind1, 
                      const DtVertexID ind2);

   // returns type of gdb node
   virtual DtGdbNode::DtGdbNodeType type() const;

   // set the vertex Manager associated with the polygon
   // Requires that the specified vertex manager is not 0.
   virtual void setVertexManager(DtVertexManager* const vertManager);

   // set the pointer to the surface Manager associated with the triangle
   // Requires that the specified surface manager is not 0.
   virtual void setSurfaceManager(DtSurfaceManager* const surfManager);

   virtual int sizeInBytes() const;

protected:

   virtual bool testInvariant() const;

   DtSurfaceID          mySurfaceID;
   DtSurfaceManager*    mySurfaceManager;
   DtVertexManager*     myVertexManager;
   DtVertexID           myVertexIDs[3];   // an array of size 3 to hold the indices.
};

// Functions below do NOT test for invariancy
// and may corrupt the triangle if not used properly
inline DtPoint& DtTriangleIndirect::vertex0()
{
   return myVertexManager->vertex(myVertexIDs[0]);
}

inline const DtPoint& DtTriangleIndirect::vertex0() const
{
   return myVertexManager->vertex(myVertexIDs[0]);
}


inline DtPoint& DtTriangleIndirect::vertex1()
{
   return myVertexManager->vertex(myVertexIDs[1]);
}

inline const DtPoint& DtTriangleIndirect::vertex1() const
{
   return myVertexManager->vertex(myVertexIDs[1]);
}


inline DtPoint& DtTriangleIndirect::vertex2()
{
   return myVertexManager->vertex(myVertexIDs[2]);
}

inline const DtPoint& DtTriangleIndirect::vertex2() const
{
   return myVertexManager->vertex(myVertexIDs[2]);
}

inline DtExtent DtTriangleIndirect::extent() const
{
   DtExtent expandedExtent(vertex0(), vertex1());
   expandedExtent.expandToInclude(vertex2());
   return expandedExtent;
}

inline DtVertexManager* const DtTriangleIndirect::vertexManager() const
{
   return myVertexManager;
}


inline DtSurfaceManager* const DtTriangleIndirect::surfaceManager() const
{
   return mySurfaceManager;
}


inline DtGdbNode::DtGdbNodeType DtTriangleIndirect::type() const
{
   return DtGdbNode::TRIANGLE_INDIRECT;
}

inline DtVertexID DtTriangleIndirect::getVertexID(unsigned int index) const
{
   assert(index <= 2); 
   return myVertexIDs[index];
}

inline const DtPoint& DtTriangleIndirect::getVertex(unsigned int localIndex) const
{
   return myVertexManager->vertex(myVertexIDs[localIndex]);
}

inline DtSurfaceID DtTriangleIndirect::getSurfaceID() const
{
   return mySurfaceID;
}

inline void DtTriangleIndirect::setSurfaceManager(DtSurfaceManager* surfMgr)
{
   assert(surfMgr != 0);
   mySurfaceManager = surfMgr;
   // every polygon is created with a surface type of 0
   // as soon as there is a surface manager, add 1 to the polygon count of this
   // surface
   mySurfaceManager->updateSurfaceTerrainElementMap(mySurfaceID, 1);
}

inline void DtTriangleIndirect::setVertexManager(DtVertexManager* vertManager)
{
   assert(vertManager != 0);
   myVertexManager = vertManager;
}

inline void DtTriangleIndirect::setVertex(unsigned int localIndex, DtVertexID vertexIndex)
{
   assert(localIndex <= 2);
   assert(myVertexManager->isValidID(vertexIndex));
   if (localIndex <= 2)
   {
      myVertexIDs[localIndex] = vertexIndex;
   }
   else
   {
      DtWarn("Warning:  DtTriangleIndirect::setVertex -- "
             "bad localIndex %d\n", localIndex);
   }
}

inline const DtSurface& DtTriangleIndirect::getSurface() const
{
   return mySurfaceManager->surface(mySurfaceID);
}

#endif