RenderableQGL.cpp

Go to the documentation of this file.

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

///////////////////////////////////////////////////////////////////////////
/// A BasicQGL that knows about renderables.



#include <iostream>
#include <vector>
#include <limits>
#include <algorithm>
#include <qwidget.h>
#include <GL/Pick.h>
#include "QtGutzEvent.h"
#include "RenderableQGL.h"


using namespace std;
using namespace gutz;

RenderableQGL::RenderableQGL(QWidget *parent, const char *name)
: BasicQGL(parent, name), 
  _picking(false),
  _picked(0)
{

   _cam = new Camera();
   _manip = new Manip(_cam);

   initManipulators();

   cerr << " event map = " << endl;
   _cam->serialEventMap(cerr, std::string("  "));
   cerr << endl;

   _time.silent();
}

RenderableQGL::~RenderableQGL() 
{

}

///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/// draw;
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////

void RenderableQGL::draw()
{
   cerr << " drawing " << endl;
   static int ave = 0;

   if(_timeOn && !(ave%10)){
      _time.start();
   }
   ++ave;

   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

   /// if picking, the projection matrix can't be messed with.
   /// We reset it every pass, so the pick uses the last 
   /// projection matrix we set.
   if(!_picking) 
   {
      glMatrixMode(GL_PROJECTION);
      glLoadMatrixf(_cam->getProjectMatrix().m);
   }
   glMatrixMode(GL_MODELVIEW);
   glLoadMatrixf(_cam->getViewMatrix().m);

   glPushMatrix();
   {
      glColor4f(1,1,1,1);
      drawRenderables();
   }
   glPopMatrix();

   if(_timeOn && !(ave%10))
   {
      glFinish();
      double t = _time.et();
      cout << " time = " << t/10.0 << endl;
   }

   ///TODO: remove QT signals for simian events use gutz::signal
   drawFinished();
   drawDone();
   cerr << " draw done " << endl;
}


/////////////////////////////////////////////////////////
/// call this one to simply cycle through the renderables
void RenderableQGL::drawRenderables()
{
   RenderableVecIter rli = _rens.begin();
   gutz::RenderEvent re(_cam,_manip,_picking);

   while(rli != _rens.end())
   {
      (*rli)->draw(re);
      ++rli;
   } 
}

///////////////////////////////////////////////////////////////////////////
/// Mousing
///////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////
/// Mouse move
///////////////////////////////////////////////////////////////////////////
/// TODO: nuke debug statements, or make them part of a proper base class
void RenderableQGL::mouseMoveEvent( QMouseEvent * e)
{
  
   if(_picked)
   {
      /// some error checking, so we might have a chance of working :)
      ///  TODO: nuke this, at some point decide that you are doing the right thing.
      if(!_curMove)
      {
         cerr << "RenderableQGL::mouseMoveEvent(), no move defined " << endl;
         if(!_curMouse)
         {
            cerr << "RenderableQGL::mouseMoveEvent(), no mouse defined " << endl;
            _curMouse = qt2GutzMouse(e,_cam,_manip);
         }
         _curMove = new MouseMoveEvent(*_curMouse, vec3f(e->x(), e->y(),_curMouse->z()));
      }

      /// update the current move event's  position
      _curMove->setPos(vec3f(e->x(), e->y(), _curMouse->z()));

      /// see if the pick wanted the move
      if(_picked->move(*_curMove))
      {
         update();
         return; /// did, so return
      }
      else
      {
         _picked = 0; /// didn't so un pick it 
      }
   }

   /// if we made it his far, the pick didn't exist or didn't want
   ///  the event, so just do the standard move.
   BasicQGL::mouseMoveEvent(e);
}

///////////////////////////////////////////////////////////////////////////
/// Mouse down
///////////////////////////////////////////////////////////////////////////
void RenderableQGL::mousePressEvent( QMouseEvent * e)
{
   _curMouse = qt2GutzMouse(e,_cam,_manip);
   /// see if we picked something
   if( pickGL(_curMouse) ) /// something got picked
   {
      if(_picked) /// make sure picked actually got set
      {
         _curMove = new MouseMoveEvent(*_curMouse, vec3f(e->x(), e->y(), _curMouse->z()));
         /// see if the pick wants the event
         if(_picked->mouse(*_curMouse)) 
         {
            update();
            return; /// did want the event, so it was forwarded
         }
         else
         {
            _picked = 0; /// didn't want the event, so.. unpick
         }
      }
   }

   /// revert to standard mouse events if nothing was picked, or 
   ///  the pick didn't want the event.
   BasicQGL::mousePressEvent(e);
}

///////////////////////////////////////////////////////////////////////////
/// Mouse up
///////////////////////////////////////////////////////////////////////////
void RenderableQGL::mouseReleaseEvent ( QMouseEvent * e )
{
   if(_picked)
   {
      _curMouse = qt2GutzMouse(e,_cam,_manip);
      _curMouse->setButtonDown(false);
      _picked->mouse(*_curMouse);
   }   
   _curMouse->setButton(GUTZ_BUTTON_NONE);
   /// make sure everyone knows that the mouse is up
   BasicQGL::mouseReleaseEvent(e);
}

///////////////////////////////////////////////////////////////////////////
/// Mouse double down
///////////////////////////////////////////////////////////////////////////
void RenderableQGL::mouseDoubleClickEvent ( QMouseEvent * e )
{
   BasicQGL::mouseDoubleClickEvent(e);
}

///////////////////////////////////////////////////////////////////////////
/// Picking
///////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////
/// pick (GL style) a renderable or widget
///   returns true if something was picked, false otherwize
///   also sets the picked object...
///   TODO: unify renderables and widgets...
bool RenderableQGL::pickGL(MouseEventSP me)
{
   Pick p;

   p.startPickGL(me->x(),height()-me->y()-1,4);
   {
      /// draw!!!
      _picking = true;
      {
         draw();
      }
      _picking = false;
   }
   PickInfoVec pinfo = p.endPickGL();

   /// check if we picked something, and if we might 
   /// have the signature for a "Renderable" pick,
   ///  (ie. at least 2 names on the stack),
   /// TODO: should check each pick and accept the first one that
   ///  is a "Renderable" pick, ie skip over other geometry,
   ///  such as the volume, that is over the widget (for instance)
   if( (pinfo.size() > 0) && (pinfo[0].dataSize >= 2) && pinfo[0].data )
   {
      /// get the guy who wants to be picked
      if(!castPick(pinfo[0].data[0],pinfo[0].data[1]))
         return false;
      /// set the pick data, but strip off the 
      ///  id and pointer
      me->setPickData(&(pinfo[0].data[2]), pinfo[0].dataSize-2);
      /// set the "z" position of pick
      me->setZ(pinfo[0].z1);
      return true;;
   }
   else
   {
      _picked = 0;
      cerr << " picked nothing " << endl;
   }

   return false;
}

bool RenderableQGL::castPick(unsigned int name, unsigned int ptr)
{
   if(name == RENDERABLE_NAME)
   {
      //cerr << " got a renderable " << ptr << endl;
      _picked = (Renderable *)ptr;
      //cerr << "  --- " << typeid(*_picked).name() << endl;
      //cerr << " done with cast " << endl;
      return true;
   }
   else
   {
      cerr << "RenderableQGL::castPick(), didn't match name " << endl;
      _picked = 0;
      return false;
   }
   return false;
}

///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/// renderable management
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////


void RenderableQGL::addRenderable(Renderable *r) 
{
   _rens.push_back(r); 
   //update();
}

Renderable *RenderableQGL::getRenderable(unsigned int i)
{
   if(i < (_rens.size()-1)) 
      return _rens[i]; 
   else 
      return 0;
}

void RenderableQGL::delRenderable(unsigned int idx)
{

   RenderableVecIter rvi = _rens.begin();

   for(unsigned int i=0; i<idx; ++i)
   {
      ++rvi;
   }

   if(rvi != _rens.end())
   {
      _rens.erase(rvi);
   }
}

void RenderableQGL::delRenderable(Renderable *r)
{
   RenderableVecIter ri = std::find(_rens.begin(), _rens.end(), RenderableSP(r));
   if(ri != _rens.end())
   {
      _rens.erase(ri);
   }
}

RenderableVec RenderableQGL::getRenderables() const
{
   return _rens;
}

void RenderableQGL::setRenderables(RenderableVec &v)
{
   _rens = v;
}

---

Send questions, comments, and bug reports to: