BasicQGL.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"
//-------------------------------------------------------------------------
// BasicQGL.cpp: implementation of the BasicQGL class.
//
//////////////////////////////////////////////////////////////////////


#include <GL/glew.h>
#ifdef WIN32
#include <GL/wglew.h>
#endif

#include "BasicQGL.h"

//#include <GL/glut.h>

#include <GL/glUtil.h>
#include "QtGutzEvent.h"

#include <qmessagebox.h>

#include <iostream>
using namespace std;

//#include <GL/gl.h>

using namespace gutz;

#if defined(Q_CC_MSVC)
#pragma warning(disable:4305) // init: truncation from const double to float
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

BasicQGL::BasicQGL(QWidget *parent, const char *name )
: QGLWidget( parent, name ), 
  _cam(0), _manip(0),
  _mouseDown(false),
  _curMouse(0), _curMove(0),
  _timeOn(false), _time("BasicQGL::draw", 0)
{
   _cam   = new Camera();
   _manip = new Manip();

   initManipulators();
}

BasicQGL::~BasicQGL()
{

}

//=====================================================================
// Initialize GL
//=====================================================================

void BasicQGL::initializeGL ()
{
   glewInit();

   /* Black background and interpolated shading. */
   glClearColor(0.0, 0.0, 0.0, 0.0);
   glShadeModel(GL_SMOOTH);

   /* Set up lighting. mostly for widgets */
   static float ambient[]             = {0.4, 0.4, 0.4, 4.0};
   static float diffuse[]             = {0.5, 1.0, 1.0, 1.0};
   static float front_mat_shininess[] = {60.0};
   static float front_mat_specular[]  = {0.2, 0.2,  0.2,  1.0};
   static float front_mat_diffuse[]   = {0.5, 0.28, 0.38, 1.0};
   static float lmodel_ambient[]      = {0.2, 0.2,  0.2,  1.0};
   static float lmodel_twoside[]      = {GL_FALSE};
   glEnable(GL_LIGHT0);
   glLightfv(GL_LIGHT0, GL_AMBIENT,  ambient);
   glLightfv(GL_LIGHT0, GL_DIFFUSE,  diffuse);
   static float ltpos[] = {25,25,25,1};
   glLightfv(GL_LIGHT0, GL_POSITION, ltpos);
   glLightModelfv(GL_LIGHT_MODEL_AMBIENT,  lmodel_ambient);
   glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside);

   glEnable(GL_LIGHTING);
   glEnable(GL_COLOR_MATERIAL);

   glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, front_mat_shininess);
   glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR,  front_mat_specular);
   glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE,   front_mat_diffuse);

   glEnable(GL_DEPTH_TEST);
   glDepthFunc(GL_LEQUAL);
   glDisable(GL_CULL_FACE);

   //glEnable(GL_LINE_SMOOTH);
   //glLineWidth(3);

   //glWinStats gws;
   //getGLWinStats(gws, true);

   cerr << "gl initialized" << endl;

}


//=====================================================================
// Resize GL
//=====================================================================
void BasicQGL::resizeGL ( int w, int h )
{
   _cam->setScreen(w, h);
   /// had to change this to respect the 
   ///  users settings for perspective/ortho
   //_cam->setPerspective(60);

   glViewport(0, 0, (GLsizei) w, (GLsizei) h);

   glMatrixMode(GL_PROJECTION);
   glLoadMatrixf(_cam->getProjectMatrix().v());

   glMatrixMode(GL_MODELVIEW);

   cerr << " current perspective matrix : " << endl;
   cerr << _cam->getProjectMatrix() << endl;
}

//=====================================================================
//=====================================================================
//                          DRAW
//=====================================================================
//=====================================================================
void BasicQGL::draw()
{

   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

   glMatrixMode(GL_PROJECTION);
   glLoadMatrixf(_cam->getProjectMatrix().m);
   glMatrixMode(GL_MODELVIEW);
   glLoadMatrixf(_cam->getViewMatrix().m);

   glPushMatrix();
   {
      glColor4f(1,0,0,0);
      //glutSolidSphere(10,100,100);
      glBegin(GL_QUADS);
      {
         glVertex3f(-1,-1,0);
         glVertex3f(-1,1,0);
         glVertex3f(1,1,0);
         glVertex3f(1,-1,0);
      }
      glEnd();
   }
   glPopMatrix();       

   /// TODO: remove QT signals for simian events, use gutz::Signal
   drawFinished();
   drawDone();
}

//=====================================================================
// Mouse Press
//=====================================================================
void BasicQGL::mousePressEvent( QMouseEvent * e )
{
   _mouseDown = true;

   _curMouse = qt2GutzMouse(e,_cam,_manip);
   _curMove = new MouseMoveEvent(*_curMouse, _curMouse->getPos());

   _cam->mouse(*_curMouse);
   _manip->mouse(*_curMouse);

   //_cam->event(  e->x(), e->y(), qt2GutzButton(e) | qt2GutzState(e));
   //_manip->event(e->x(), e->y(), qt2GutzButton(e) | qt2GutzState(e));

   update();

   cerr << "The mouse was pressed at " << e->x() << " , " << e->y() 
        << " Global : " << e->globalX() << " , " << e->globalY() << endl;
}

//=====================================================================
// Mouse Double Click
//=====================================================================
void BasicQGL::mouseDoubleClickEvent ( QMouseEvent * e )
{
   _mouseDown = true;

   _curMouse = qt2GutzMouse(e,_cam,_manip);
   _curMove = new MouseMoveEvent(*_curMouse, _curMouse->getPos());

   _cam->mouse(*_curMouse);
   _manip->mouse(*_curMouse);

   //_cam->event(e->x(), e->y(), qt2GutzDblButton(e) | qt2GutzState(e));
   //_manip->event(e->x(), e->y(), qt2GutzDblButton(e) | qt2GutzState(e));

   update();

   //cerr << "The mouse was double clicked" << endl;
}

//=====================================================================
// Mouse Release
//=====================================================================
void BasicQGL::mouseReleaseEvent ( QMouseEvent * e )
{
   _mouseDown = false;

   if(_curMouse)
   {            
     _curMouse->setButtonDown(false);
   }
   if(_cam && _curMouse)    _cam->mouse(*_curMouse);
   if(_manip && _curMouse)  _manip->mouse(*_curMouse);

   if(_curMouse)
     _curMouse->setButton(GUTZ_BUTTON_NONE);

   update();

   cerr << "The mouse was released" << endl;
}

//=====================================================================
// Mouse Move
//=====================================================================
void BasicQGL::mouseMoveEvent( QMouseEvent * e )
{
  if(! _mouseDown ) return;

   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()));

   //if(_cam->updateEvent(e->x(),e->y()))
    if(_cam->move(*_curMove))
    {
      cameraChanged(_cam);
    }
    //if(_manip->updateEvent(e->x(),e->y()))
    if(_manip->move(*_curMove))
    {
      manipChanged(_manip);
    }

   update();

   cerr << "The mouse is moving " << e->x() << " , " << e->y() 
        << " Global : " << e->globalX() << " , " << e->globalY() << endl;
}

//=====================================================================
// Key press
//=====================================================================
void BasicQGL::keyPressEvent ( QKeyEvent * e )
{
   /// Let's be a nice interface and
   /// only use the key if we want it
   e->ignore();

   QString s = "Key event\n";

   handleKeyCmd(e);
   if(e->isAccepted()) return;

   switch(e->key())
   {
   case 4096: //< escape key
      e->accept();
      close();
      break;

   default:
      //QString s = "Key event\n";
      //s += QString(" %1 \n").arg(e->key());
      //QMessageBox::information( this, "simian", s);
      cerr << "Key event : " << e->key() << " = ' " << char(e->ascii()) << " ' " << endl;
      break;
   }
}

//=====================================================================
// Key release
//=====================================================================
void BasicQGL::keyReleaseEvent ( QKeyEvent * e )
{
   //cerr << "Key up    : " << e->key() << " = " << endl;
   //this crashes the program!!!! with anything other than ascii chars (F1, Shift, alt, ctrl...)
   //cerr << e->text() << endl;
}

//=====================================================================
// Key command
//=====================================================================
void BasicQGL::handleKeyCmd( QKeyEvent *e )
{
   KeyCmdSPType cmd = _keyMap[e->ascii()];
   if(cmd)
   {
      cmd->setKeyEvent(e);
      cmd->exec();
      return;
   }
   else
   {
      e->ignore();
   }
}

//=====================================================================
// Init Camera and manip
//=====================================================================
//////////////////////////////////
/// init Camera and Manip
void BasicQGL::initManipulators()
{       

   _cam->setEyePos(vec3f(0,0,2));

   _cam->mapEvent(CAM_ROT,    GUTZ_LEFT_MOUSE | GUTZ_SHIFT, 1);
   _cam->mapEvent(CAM_SWIVEL, GUTZ_LEFT_MOUSE | GUTZ_CTRL, .2);
   //_cam->mapEvent(CAM_DOLLY,  GUTZ_RIGHT_MOUSE, .01);
   _cam->mapEvent(CAM_ZOOM,  GUTZ_RIGHT_MOUSE, .01);

   _cam->mapEvent(CAM_TRANS_XY, GUTZ_MIDDLE_MOUSE, .02);
   _cam->mapEvent(CAM_TRANS_XZ, GUTZ_MIDDLE_MOUSE | GUTZ_SHIFT, .02);
   _cam->mapEvent(CAM_TRANS_ZY, GUTZ_MIDDLE_MOUSE | GUTZ_CTRL, .02);

   _cam->mapEvent(CAM_DOLLY,     GUTZ_UP_ARROW, .2);
   _cam->mapEvent(CAM_DOLLY,     GUTZ_DOWN_ARROW, .2);

   _cam->setTumble(true);

   _manip->mapEvent(GUTZ_LEFT_MOUSE, new RotateManipEvent(1.0f));

   _manip->setCamera(_cam);
   _manip->setTumble(true);

}

//=====================================================================
// Read Frame buffer
//=====================================================================
bool BasicQGL::readFrameBuffer(void *dataPtr, int size, 
                               GLenum format, 
                               GLenum type)
{
  switch(format)
    {
    case GL_RGBA:
    case GL_BGRA_EXT:
      if(size < int(_cam->getScreen().x) * int(_cam->getScreen().y) * 4)
        return true;
      break;
    case GL_RGB:
    case GL_BGR_EXT:
      if(size < int(_cam->getScreen().x) * int(_cam->getScreen().y) * 3)
        return true;
      break;
    default:
      cerr << "BasicQGL::readFrameBuffer(), format not supported " << endl 
           << " - possibly not implemented " << endl;
      return true;
    }

  glReadPixels(0,0,_cam->getScreen().x,_cam->getScreen().y,
               format, type, dataPtr);

  return glErr(cerr, "BasicQGL::readFrameBuffer()");
}

//=====================================================================
// Write Frame buffer
//=====================================================================
bool BasicQGL::writeFrameBuffer(void *dataPtr, int screenx, int screeny,       
                               GLenum format, 
                               GLenum type)
{
  glDrawPixels(screenx, screeny, format, type, dataPtr);

  return glErr(cerr, "BasicQGL::readFrameBuffer()");
}

---

Send questions, comments, and bug reports to: