VolRenBase.cpp

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"
//-------------------------------------------------------------------------

//volrenbase.h

#include "VolRenBase.h"
#include <volrenalg/VolRenAlgBase.h>
#include <textureGlift.h>
#include <volume/VolytopeStd.h>
#include <GL/glUtil.h>


#ifdef WIN32
#include <windows.h>
#endif

#include <GL/gl.h>

#include <iostream>

using namespace std;
using namespace gutz;
using namespace glift;

#define VRB_MAX_VERTS 9

///////////////////////////////////////////////////////////////////////////
// Construct
///////////////////////////////////////////////////////////////////////////
VolRenBase::VolRenBase()
: _currentAlg(0), 
_vsBuff(0),
_v(new Volume())
{

   //VolSamples *vs = new VolSamples(500000);

   _vsv.push_back(new VolSamples(500000));
   _vsv.push_back(new VolSamples(500000));
   _vsv.push_back(new VolSamples(500000));

   init();
}

VolRenBase::~VolRenBase()
{
   _currentAlg = 0;
}

///////////////////////////////////////////////////////////////////////////
// initialize
///////////////////////////////////////////////////////////////////////////
void VolRenBase::init()
{
   if(!_currentAlg)
   {
      _currentAlg = new VolRenAlgBase();
   }
   _currentAlg->init();

   if(!_currentSlicer)
   {
      _currentSlicer = new VolSlicer();
   }

}

///////////////////////////////////////////////////////////////////////////
// draw the volume
///////////////////////////////////////////////////////////////////////////

void VolRenBase::drawDef(const gutz::RenderEvent &re)
{
   const CameraSP cam  = re.getCamera();
   const ManipSP manip = re.getManip();

   /// generate the slice axis
   _sliceDir = genSliceAxis(0, vec3f((cam->getViewMatrix() * manip->getMatrix()).trans()));

   /// tell the algorithm which way it is going
   _currentAlg->setSliceAxis(_sliceDir);
   //give the rendering algorithm some clues on how to render
   _currentAlg->setLightVec(_ltv);
   _currentAlg->enableLight(_lightOn);
   _currentAlg->enableLTHA(_lthaOn);

   /// construct the model view matrix
   mat4f mv = cam->getViewMatrix() * manip->getMatrix();

   /// get the sorted volytopes
   VolytopeVec vt = _v->volys.sortFromPoint(mv.inv() * gutz::vec4f_w);  

   //get ready to render
   glPushMatrix();
   {
      //use the default model matrix
      glMultMatrixf(manip->getWorldTransform().m);

      // swap brick order if back to front
      int inc = 1;
      int start = 0;
      int end  = vt.size();
      if(_sliceDir.dot(vec3f_neg_z) > 0.0f)
      {
         inc = -1;
         start = vt.size()-1;
         end = -1;
      }

      for(int i=start; i!=end; i+=inc)
      {
         _vt = vt[i];
         if(_vt.isNull()) continue;

         arrayw1v3f vo = _vt->getVerts();     
         arrayw1v3f tx = _vt->getTcoords();

         //make sure to apply volume model matrix
         glMultMatrixf(_vt->getMatrix().m);

         _currentAlg->setVolytope(_vt);

         /////////////////////////////////
         //slice up the volume's domain
         preSlice(re);
         _currentSlicer->slice(mv, _vt, _vsv[_vsBuff], _sliceDir);
         postSlice(re);
         ////////////////////////////////

         ////////////////////////////////
         //inform the algorithm that it will be rendering
         _currentAlg->bind();
         { 
            //let the algorithm draw it
            _currentAlg->drawTris(_vsv[_vsBuff]);

         }
         ////////////////////////////////
         //inform the algorithm that it is done
         _currentAlg->release();
      }
   }
   glPopMatrix();

   glErr(cerr, "VolRenBase:end-draw()");
}

///////////////////////////////////////////////////////////////////////////
// center
///////////////////////////////////////////////////////////////////////////
gutz::vec3f VolRenBase::getCenter(const gutz::CameraEvent &ce) const
{
   if(_v) 
   {
      return ce.getCamera()->getViewMatrix() * 
             ce.getManip()->getMatrix() * 
             _v->volys.getCenter();
   }
   return gutz::vec3f_max;
}


///////////////////////////////////////////////////////////////////////////
// Set the current rendering algorithm
///////////////////////////////////////////////////////////////////////////
void VolRenBase::setAlg(VolRenAlgBase *vrab)
{ 
   _currentAlg = vrab; 
}

void VolRenBase::setSlicer(VolSlicer *vslice)
{
   _currentSlicer = vslice;
}

void VolRenBase::err(char *when, float v, char *where)
{
#ifdef _DEBUG
   cout << "VolRenBase:" << when;
   if(where)
      cout << " - " << where;
   cout << "  " << v;
   cout << endl;
#endif
}

---

Send questions, comments, and bug reports to: