polygonIndirect.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1999 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: polyInd.h,v $ $Revision: 1.19 $ $State: Exp $
*********************************************************************/

#ifndef polygonIndirect_H_
#define polygonIndirect_H_

#include "gdb/gdbDefines.h"
#include "gdb/basePolygon.h"
#include "gdb/surfaceManager.h"
#include "gdb/vertexManager.h"
#include <assert.h>
#include "geometry/homogeneousTransformMatrix.h"

// forward declarations
class DtVertexManager;
class DtSurfaceManager;
class DtMemoryManager;

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

class DT_DLL_gdb DtPolygonIndirect : public DtBasePolygon
{
public:

   // constructor with number of vertices, array of ints (vertex IDs)
   // a vertex manager, a surface manager and a surface ID;
   // uses DtMemoryManager to allocate vertex index array.
   // NOTE:  Does not take ownership of the array of vertex indices
   // specified - copies them into its own memory managed list.
   DtPolygonIndirect(unsigned int numVertices, 
                     DtVertexManager* vertMgr, 
                     DtVertexID* vertexIDs,
                     DtSurfaceManager* surfMgr, 
                     DtSurfaceID surfID, 
                     DtMemoryManager* memMgr);

   // destructor
   virtual ~DtPolygonIndirect();

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

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

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

   // get the i-th vertex of the polygon
   virtual bool getVertex(DtPoint& retVal, unsigned int i) const;
   const DtPoint& getVertex(unsigned int i) const;

   // set the i-th vertex of the polygon
   virtual bool setVertex(unsigned int localIndex, DtVertexID vertexID);

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

   // set the surface associated with the polygon
   // 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);

   // Set the surface of the polygon with the specified surface.
   // \note Checks to see if the same surface has already been added, so there
   // is no need to eliminate duplicate surfaces after calling this function.
   virtual bool setSurface(const DtSurface& newSurface);

   // get the vertex/surface/memory manager associated with the polygon
   virtual const DtVertexManager* vertexManager() const;
   virtual const DtSurfaceManager* surfaceManager() const;
   virtual const DtMemoryManager* memoryManager() 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 either modify internal state, create 
   // instances of the class that are not fully formed, or
   // expose implementation details of the class that may change 
   // in future releases.
   // They do NOT enforce the invariants of the class.

   // default constructor
   DtPolygonIndirect();

   // constructor with number of vertices
   DtPolygonIndirect(unsigned int numVertices, DtMemoryManager* memMgr);

   // constructor with number of vertices, vertex manager and
   // surface manager to index into; uses DtMemoryManager to allocate 
   // index array.
   DtPolygonIndirect(unsigned int numVertices, 
                     DtVertexManager* vertMgr, 
                     DtSurfaceManager* surfMgr, 
                     DtMemoryManager* memMgr);

   // set the vertex manager, surface manager, memory manager
   // and vertex ID list associated with the polygon
   virtual  void setVertexManager(DtVertexManager* vertMgr);
   virtual  void setSurfaceManager(DtSurfaceManager* surfMgr);

   // Sets the memory manager.  The polygon does *not* take ownership of the 
   // memory manager - it just references it.  
   // @note The memMgr parameter should not be a 0 pointer.  The invariant
   // specifies that the memory manager always be valid, and if it is not, the
   // behavior is @b undefined.
   virtual  void setMemoryManager(DtMemoryManager* memMgr);

   // get i-th vertex ID of the polygon
   // returns false if localIndex is not a valid index into the
   // list of vertex IDs
   virtual bool getVertexID(DtVertexID& id, unsigned int localIndex) const;
   // get the i-th vertex ID of the polygon.
   // Requires that i be a valid vertex index.
   virtual int getVertexID(unsigned int localIndex) const;

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

   // get the index list associated with the polygon
   virtual const DtVertexID* indexList() const;

   // determine if all the vertices have been specified
   virtual bool isFull() const; 

   // add a vertex to the polygon.  Returns the index into the polygon's
   // local list of vertexIDs associated with the newly added vertex ID.
   virtual int addVertex(DtVertexID vertexID);

   // specify the maximum size of the polygon; initializes the index
   // array to the specified size; 
   virtual void setNumberOfVertices(unsigned int n);

   virtual int sizeInBytes() const;

protected:
   bool testInvariant() const;

   virtual void init();

protected:
   DtMemoryManager*     myMemoryManager;  
   DtVertexManager*     myVertexManager;
   DtVertexID*          myIndexList;   // an array of size mySize to hold the indices.
   unsigned int         myVertexCount; //number of vertices specified thus far.
   DtSurfaceManager*    mySurfaceManager;
   DtSurfaceID          mySurfaceID;
};

//returns the type of gdb node
inline DtGdbNode::DtGdbNodeType DtPolygonIndirect::type() const
{
   return DtGdbNode::POLYGON_INDIRECT;
}

// get the vertex manager associated with the polygon
inline const DtVertexManager* DtPolygonIndirect::vertexManager() const
{
   assert(testInvariant());
   return myVertexManager;
}

// set the vertex manager associated with the polygon
inline void DtPolygonIndirect::setVertexManager(DtVertexManager* vertMgr)
{
   assert(vertMgr);
   myVertexManager = vertMgr;
}

// get the surface manager associated with the polygon
inline const DtSurfaceManager* DtPolygonIndirect::surfaceManager() const
{
   assert(testInvariant());
   return mySurfaceManager;
}

// set the surface manager associated with the polygon
inline void DtPolygonIndirect::setSurfaceManager(DtSurfaceManager* surfMgr)
{
   assert(surfMgr);
   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);
}

// get the memory manager associated with the polygon
inline const DtMemoryManager* DtPolygonIndirect::memoryManager() const
{
   assert(testInvariant());
   return myMemoryManager;
}

inline void DtPolygonIndirect::setMemoryManager(DtMemoryManager* memMgr)
{
   assert(memMgr);
   myMemoryManager = memMgr;
}

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

inline const DtPoint& DtPolygonIndirect::getVertex(unsigned int localIndex) const
{
   DtVertexID vertexID = myIndexList[localIndex];
   return myVertexManager->vertex(vertexID);
}

#endif