BasicQGL.h

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.h: interface for the BasicQGL class.
//
//////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////
/// This class serves mostly as a demonstration of QT gl rendering, 
///    but it is also usefull as a base class if you don't want
///    to implement all of the required functions from scratch.

#pragma warning(disable:4786) //disable stl identifier too long warnings
#pragma warning(disable:4530) //disable iostream unwind semantics warning 

#if !defined(AFX_BASICQGL_H__B4067E20_999B_49AA_95E2_9DDD340AC225__INCLUDED_)
#define AFX_BASICQGL_H__B4067E20_999B_49AA_95E2_9DDD340AC225__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include <qgl.h>
#include <signalGutz.h>
#include <eventGutz.h>
#include <graphicsGutz.h>
#include <commandQt/commandQt.h>
#include <perf/Timer.h>

#include <iostream>

//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
/// Basic QGL class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////

class BasicQGL : public QGLWidget  
{
   Q_OBJECT
public:
   BasicQGL(QWidget *parent=0, const char *name=0 );
   virtual ~BasicQGL();

   virtual void update() { updateGL(); }

   //////////////////////////////////////////////////////
   ///@name Camera/Manip Set/Get
   ///@{
   virtual gutz::CameraSP  getCamera() const          { return _cam; }
   virtual void            setCamera(gutz::CameraSP c){ _cam = c; update(); }
   virtual gutz::ManipSP   getManip() const           { return _manip; }
   virtual void            setManip(gutz::ManipSP m)  { _manip = m; update(); }
   ///@}
   //////////////////////////////////////////////////////

   ////////////////////////////////////////
   ///@name Performance Timer on/off
   ///@{
   void         perfTimerOn(bool onoff)    { _timeOn = onoff; _time.start();}
   bool         perfTimerOn() const        { return _timeOn;}
   ///@}
   ////////////////////////////////////////

   ////////////////////////////////////////
   ///@name Redraw Timer (event callback timer)
   ///@{

   /// Stop (all) timers
   virtual void endTimer()             { killTimers(); }
   /// Start the render timer, updates every ms_time miliseconds
   virtual void setTimer(int ms_time)  { startTimer(ms_time); }

   ///@}
   /////////////////////////////////////////

   //////////////////////////////////////////////////////
   // A quick and dirty command "callback" for keys
   // You can subclass from the next line:
   //  class myKeyCmd : public BasicQGL::KeyCmdType ...
   //  all you need is a "void exec()" function.
   typedef KeyCmdQt<BasicQGL>           KeyCmdType;
   typedef gutz::SmartPtr< KeyCmdType > KeyCmdSPType;
   void setKeyCmd(char key, KeyCmdType *cmd) 
        {_keyMap[key] = KeyCmdSPType(cmd);}

   
   ////////////////////////////////////////////////////////
   ///@name Framebuffer Readback/Write & size:
   ///@{

   //// Get the Render Surface size (Frame buffer)
   gutz::vec2ui getScreenDims() const { return _cam->getScreen(); }

   /// pre intialized data buffer, with size elements, desired format
   /// for read, false = success, true = failure
   bool readFrameBuffer(void *dataPtr, int size, 
                        GLenum format = GL_RGBA, 
                        GLenum type   = GL_UNSIGNED_BYTE);

   bool writeFrameBuffer(void *dataPtr, int x, int y, 
                         GLenum format = GL_RGBA,
                         GLenum type   = GL_UNSIGNED_BYTE);
   ///@}
   ////////////////////////////////////////////////////////

   ////////////////////////////////////////////////////////
   ///@name gutz::Signals
   ///@{
   
   /// signal: drawDone(), called after the draw event completes.
   gutz::Signal<> drawDone;

   ///@}
   ////////////////////////////////////////////////////////
   

 signals:
   /// These are about to be depricated... moving to gutz::Signal
   void                  cameraChanged(gutz::CameraSP c);
   /// These are about to be depricated... moving to gutz::Signal
   void                  manipChanged(gutz::ManipSP m);
   /// These are about to be depricated... moving to gutz::Signal
   /// signal called after complete raw
   void                  drawFinished();

protected:

   //////////////////////////////////////////////////////
   //Mouse "Callbacks"
   virtual void mouseMoveEvent( QMouseEvent * e);
   virtual void mousePressEvent( QMouseEvent * e);
   virtual void mouseReleaseEvent ( QMouseEvent * e );
   virtual void mouseDoubleClickEvent ( QMouseEvent * e );

   //////////////////////////////////////////////////////
   //Key board "Callbacks"
   virtual void keyPressEvent ( QKeyEvent * e );
   virtual void keyReleaseEvent ( QKeyEvent * e );
   virtual void handleKeyCmd( QKeyEvent *e );

   //////////////////////////////////////////////////////
   //Basic GL setup and rendering "callbacks"
   virtual void initializeGL ();
   virtual void resizeGL ( int width, int height );
   virtual void paintGL () {draw();}

   virtual void timerEvent( QTimerEvent * ) 
   { 
     if(!_mouseDown)
     {
         _cam->tumble(1);
         _manip->tumble(1);
         update(); 
     }
   }

protected:

   //////////////////////////////////////////////////////
   /// overide this draw function
   virtual void draw();

   //////////////////////////////////
   /// init Camera and Manip
   virtual void initManipulators();

   gutz::CameraSP _cam;
   gutz::ManipSP  _manip;

   bool _mouseDown;  //< needed for tumbling

   //////////////////////////////////
   /// A quick and dirty keyboard
   /// command/callback helper :)
   typedef std::map<char, KeyCmdSPType , ltchar> KeyMapType;
   KeyMapType  _keyMap;

   Timer  _time;   ///< performance timer
   bool   _timeOn; ///< performance timer on?

private:
   gutz::MouseEventSP      _curMouse;
   gutz::MouseMoveEventSP  _curMove;
};

#endif // !defined(AFX_BASICQGL_H__B4067E20_999B_49AA_95E2_9DDD340AC225__INCLUDED_)

---

Send questions, comments, and bug reports to: