Volytope.h

Go to the documentation of this file.

//------------------------------------------------------------------------
//
//   Joe Kniss
//     9-20-02
//                   ________    ____   ___ 
//                  |        \  /    | /  /
//                  +---+     \/     |/  /
//                  +--+|  |\    /|     < 
//                  |  ||  | \  / |  |\  \ 
//                  |      |  \/  |  | \  \ 
//                   \_____|      |__|  \__\
//                       Copyright  2002 
//                      Joe Michael Kniss
//                   <<< jmk@cs.utah.edu >>>
//               "All Your Base are Belong to Us"
//-------------------------------------------------------------------------

//Volytope.h

// Container class for a convex polytope, which is the basic
//  primitive for volume rendering

#ifndef __VOLYTOPE_DOT_H
#define __VOLYTOPE_DOT_H

#include <mathGutz.h>
#include <arrayGutz.h>
#include <list>
#include <vector>
#include <textureGlift.h>
#include <smartptr.h>
#include <volume/VolField.h>
#include <simBase/simBase.h>



////////////////////////////////////////////////////////////////////////////////
/// Volytope
////////////////////////////////////////////////////////////////////////////////

class Volytope : 
   public gutz::Counted, 
   public SimBase 
{
public:
   /////////////////////////////////////////
   /// this is to make this flexible, but
   /// not a template: change these to change whole class
   typedef gutz::vec3f      V_TYPE;   /// Vertex type
   typedef gutz::vec3f      TC_TYPE;  /// Texture Coordinate type
   typedef glift::SingleTex TX_TYPE;  /// Texture type
   typedef gutz::vec2i      E_TYPE;   /// Edge type
   /////////////////////////////////////////

   Volytope(unsigned int nElements = 5000, 
      unsigned int nTcoords = 1,
      unsigned int nPrims = 1000);

   virtual ~Volytope();

   Volytope(const Volytope &v) { Volytope::operator =(v); }
   void operator=(const Volytope &v);

   ////////////////////////////////////////////////////////////////////
   /// set some data, load a field into the volytope
   virtual void loadField(VolFieldSP f, unsigned int brickNum=0) = 0;

   /////////////////////////////////////////////
   typedef gutz::arrayWrap1<V_TYPE>  VA_RTYPE; // return type for verts array
   typedef gutz::arrayOwn1<V_TYPE>   VA_ITYPE; // internal vertex array type
   typedef gutz::arrayWrap1<TC_TYPE> TA_RTYPE; // return type for TCoord array
   typedef gutz::arrayOwn1<TC_TYPE>  TA_ITYPE; // internal TCoord array type
   typedef gutz::arrayWrap1<E_TYPE>  EA_RTYPE; // return type for edge array 
   typedef gutz::arrayOwn1<E_TYPE>   EA_ITYPE; // internal edge array type
   /////////////////////////////////////////////

   virtual void setData(VA_RTYPE   *verts,
      TA_RTYPE   *tcoords,
      EA_RTYPE   *edges);


   /// Generate Verts
   virtual VA_RTYPE  genVerts(int nVerts);
   /// get verts
   const VA_RTYPE    getVerts() const   {return VA_RTYPE(*_verts);} 
   VA_RTYPE          getVerts()         {return VA_RTYPE(*_verts);}


   /// number of texture coordinates must match the
   /// number of verticies, thus "tNum" is the
   /// texture number, not the number of coordinates
   virtual TA_RTYPE  genTcoords(int tNum = 0);       
   /// get tcoords
   const TA_RTYPE    getTcoords(unsigned int tNum = 0) const; 
   TA_RTYPE          getTcoords(unsigned int tNum = 0);       

   /// Generate edges
   virtual EA_RTYPE  genEdges(int nEdges);      
   /// get edges
   const EA_RTYPE    getEdges() const   {return EA_RTYPE(*_edges);}
   EA_RTYPE          getEdges()         {return EA_RTYPE(*_edges);}

   ////////////////////////////////////////////////////////////////////
   /// texture info
   int                               numTextures()      {return _textures.size();}
   std::vector< gutz::SmartPtr<TX_TYPE> >  getTextures()      {return _textures;}
   gutz::SmartPtr<TX_TYPE>                 getTexture(int i)  {if(_textures[i]) return _textures[i]; return 0;}
   gutz::SmartPtr<TX_TYPE>                 removeTexture(int i);
   void                              clearTextures();
   void                              addTexture(glift::SingleTex *tex);

   ////////////////////////////////////////////////////////////////////
   /// get the volume matrix
   gutz::mat4f     getMatrix() const        {return _xform;}
   void            setMatrix(gutz::mat4f m) {_xform = m;}

   ////////////////////////////////////////////////////////////////////
   /// bounding box
   /// update bounding box and center
   virtual void        setSizes();
   virtual gutz::vec3f getBoxMax() const {return _max;}
   virtual gutz::vec3f getBoxMin() const {return _min;}
   gutz::vec3f         getCenter() const {return _center;}

   ////////////////////////////////////////////////////////////////////
   /// Transformations 
   virtual void scale(gutz::vec3f scale);
   virtual void translate(gutz::vec3f trans);

   ////////////////////////////////////////////////////////////////////
   /// sorting utilities
   /// sets the PointDist to the distance from the point to the 
   /// nearest vertex of the volytope.  getPointDist() is designed to
   /// be a very fast call for sorting purposes
   void  setPointDist(gutz::vec3f pt);
   float getPointDist() const { return _dist; }

protected:
   Volytope(std::string name):SimBase(),_edges(0),_verts(0){}

   /// save volytope information into a nrro object
   virtual void writeState(NrroSP n) {derr("writeState(), function not implemented");}
   virtual void readState(NrroSP n)  {derr("readState(), function not implemented");}

   EA_ITYPE *_edges;
   VA_ITYPE *_verts;
   std::vector<TA_ITYPE*> _tcoords;

   std::vector< gutz::SmartPtr<TX_TYPE> > _textures;

   gutz::mat4f                    _xform;
   gutz::vec3f                    _center;
   gutz::vec3f                    _min;
   gutz::vec3f                    _max;
   float                          _dist;
};

typedef gutz::SmartPtr<Volytope> VolytopeSP;

////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/// VolytopeVec
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

class VolytopeVec : 
   public std::vector<VolytopeSP>, //< is a Vector
   public SimBase
{
public:
   VolytopeVec():SimBase(),_scale(1.0f,1.0f,1.0f) {}
   virtual ~VolytopeVec(){}
   /// using default copy and assignment operators

   ///////////////////////////////////////////////////
   ///@name Volytope management
   ///@{
   void          setVoly(VolytopeSP v, int i=0) {operator[](i) = v; }
   VolytopeSP    getVoly(int i=0) const         {return operator[](i);}
   void          addVoly(VolytopeSP &v)         {push_back(v);}
   ///@}

   ///////////////////////////////////////////////////
   ///@name Fields
   ///@{
   void          setField(VolFieldSP f);
   ///@}

   ///////////////////////////////////////////////////
   ///@name bounding boxes and sizes
   ///@{
   gutz::vec3f   getBoxMax() const;
   gutz::vec3f   getBoxMin() const;
   gutz::vec3f   getSize()             {return getBoxMax() - getBoxMin();}
   /// sets the maximum dimension to "size"
   void          setSize(float size);
   /// the scaling that returns the volytopes to their orginal size
   /// if you resized the volytopes this is the scale vector that undoes it.
   gutz::vec3f   getScale() const { return _scale; }
   ///@}

   ////////////////////////////////////////////////////
   ///@name transformations
   ///@{
   void          scale(gutz::vec3f scl);
   void          translate(gutz::vec3f trans);
   ///@}

   /// center the volytopes around their center of mass
   void          center();

   ////////////////////////////////////////////////////
   /// Sorting
   /// distance from a point, this only works if your
   /// volytopes are uniformly subdivided cubes
   VolytopeVec sortFromPoint(gutz::vec3f pt);

   ////////////////////////////////////////////////////
   /// get the center of all volytopes in this collection
   gutz::vec3f getCenter() const
   {
      gutz::vec3f min = getBoxMin();
      return min + (getBoxMax() - getBoxMin())/2.0f;
   }

protected:

   gutz::vec3f _scale;
};

typedef VolytopeVec::iterator VolytopeVecIter;
typedef VolytopeVec::reverse_iterator VolytopeVecRIter;

#endif

---

Send questions, comments, and bug reports to: