vee_qt.h

Go to the documentation of this file.

/* -*- C++ -*- */

/* COPYRIGHT
 *
 * This file is part of the Visual Effects Engine - VEE
 *
 * Read the "VEE-LICENSE" file for the license.
 *
 * Authors & Copyright:   
 *
 * Tommi Ilmonen, Tuukka Heikura, Marko Myllymaa and 
 * Janne Kontkanen 2001-2004
 *
 * Additional copyrights: Tekes 2003-2004
 *
 * firstname.lastname@hut.fi
 *
 */

#ifndef _VEE_QT_H_
#define _VEE_QT_H_

#include <vee_has_values.h>
#include <vee_image.h>
#include <vee_scene.h>
#include <vee_vector3.h>
// #include <vee_qt_widget.h>
#include <vee_time.h>

#include <qgl.h>
#include <qmenubar.h>
#include <qobject.h>
//#include <qtimer.h>
#include <qevent.h>
#include <qapplication.h>

#include <GL/gl.h>
#include <GL/glu.h>

#include <vector>

class GEE_Geometry;
class GEE_Engine;
class GEE_GlDisplayLists;
class GEE_GlMaterialBank;
class GEE_GlRenderer;
class GEE_HistoryAnimation;
class GEE_World;

class VEE_GlRenderer;
class VEE_GlTexture2DBank;
class VEE_ValueWindow;

class VEE_Qt;

class QBoxLayout;
class QImage;

enum VEE_GlRendererType {
  VEE_GL_PLAIN,
  VEE_GL_SL,
  VEE_GL_CG
};


class VEE_QtHidden : public QGLWidget, public VEE_HasValues
{
  Q_OBJECT
public:

  friend class VEE_Qt;
  
  enum UpdateType {
    UPDATE_USUAL,
    UPDATE_PSEUDO_THREADED,
    UPDATE_THREADED,
    UPDATE_SIZEOF
  };
  
  VEE_QtHidden(VEE_Qt * host,
         VEE_SceneBox *box, QWidget *parent=0, 
         const char *name=0,
         VEE_GlRendererType type = VEE_GL_SL);
  virtual ~VEE_QtHidden();

  bool displaySolids() const;

  GEE_Engine * geeEngine() { return m_geeEngine; }

  GEE_GlMaterialBank * geeMaterials() { return m_geeMaterials; }

  void setAutoRewind(bool autorewind);
  void useHistoryAnimation(bool use);


public slots:
  virtual void reFresh();

signals:
  void status(float,int);

protected:

  void updateGlCamera();
  
  void mouseMoveEvent(QMouseEvent *m);
  void mousePressEvent(QMouseEvent *m);

  virtual void enterEvent ( QEvent * );

  virtual void initializeGL();
  virtual void resizeGL( int w, int h );
  virtual void paintGL();

  virtual void preRender();

  virtual void veeRender(bool clear = true);

  void storeFrameToFile();


  void grab(QImage *);

  VEE_Vector3 m_camPos;
  VEE_Vector3 m_camRot;
  VEE_Vector3 m_camAim;
  VEE_Vector3 m_camUp;

  VEE_GlRenderer *m_veeGl;

  GEE_GlMaterialBank     *m_geeMaterials;
  GEE_GlRenderer         *m_geeGl;
  GEE_GlDisplayLists     *m_geeLists;
  GEE_Engine             *m_geeEngine;
  GEE_HistoryAnimation   *m_geeHistoryAnimation;

  VEE_Time m_checkFpsTime;
  VEE_Time m_lastFrameTime;
  float    m_lastFrameDuration;
  uint     m_lastFrameCheckFrames;
  
  float m_fixedRate;
  float m_playSpeed;
  uint  m_frames;
  bool  m_showFps;
  bool  m_visualUpdate;
  bool  m_calculusUpdate;
  bool  m_showBoxes;
  bool  m_pause;
  bool  m_showNObj;
  
  uint m_splitAt;
  uint m_collapseAt;
  uint m_maximumRecursion;

  uint m_overSample;
  VEE_SceneBox *m_scene;

  VEE_Qt  *m_host;

  class Internal;
  Internal * m_internal;
};


class VEE_Qt : public QWidget, public VEE_HasValues
{
  Q_OBJECT        // must include this if you use Qt signals/slots
public:
  VEE_Qt( VEE_SceneBox *box,
    VEE_GlRendererType type = VEE_GL_SL, 
    QWidget *parent=0, 
    const char *name=0 , 
    bool createGlWidget = true);
  virtual ~VEE_Qt();

  virtual bool setValue(const char *, VEE_Value *);

  void setFrameRate(float rate) { m_glWidget->m_fixedRate = rate; }

  void setTreeThresholds(uint collapseAt, uint splitAt)
  { m_glWidget->m_collapseAt = collapseAt; m_glWidget->m_splitAt = splitAt; }

  uint frames() const { return  m_glWidget->m_frames; }
  VEE_GlRenderer *renderer() { return m_glWidget->m_veeGl; }

  void setGlWidget(VEE_QtHidden *);
  VEE_QtHidden * getGlWidget() { return m_glWidget; }

  void setFrameFile(const char *);
  void setScreenShotCount(int);
  void setScreenShotOverSample(int);

  QMenuBar *menuBar() { return m_menu; }

  void resizeGlWidget(int w, int h)
  { if(m_glWidget) m_glWidget->resize(w, h); }

  float lastFrameDuration() const { return m_glWidget->m_lastFrameDuration;}

  static void initImageIO();

  int addKeyPoint(const VEE_Vector3 & loc, float azi, float ele);
  int addKeyPoint2(float x, float y, float z, float azi, float ele)
  { return addKeyPoint(VEE_Vector3(x, y, z), azi, ele); }

  void setValueWindow(VEE_ValueWindow *vw) { m_valueWindow = vw; }

  static void loadTextureDir(VEE_GlTexture2DBank *store,
           const QString &dirname);
  
public slots:

  void keyPressEvent(QKeyEvent *k);

  void toggleNObj();
  void togglePause();
  void toggleVisualUpdate();
  void toggleCalculusUpdate();
  void toggleShowBoxes();
  void toggleBlend();
  void togglePolygonMode();
  void toggleForceMode();
  void toggleForceBoxMode();
  void toggleTextureMode();
  void toggleAlign();
  void toggleTails();
  void toggleSolids();
  void toggleHistory();
  void toggleShaders();

  void holdTime();
  
  void useQuadTextures();
  void useTriTextures();
  void usePoints();
  void useLines();
  void useNothing();

  void showStatus(float,int);

  void nofade();
  void fadeLittle();
  void fadeMore();
  void fadeExtreme();

  void resizeGlWidget(const QString &);

  void screenshot();
  void screenshotLarge();
  void movieBegin();
  void movieEnd();

  void paramsVisible();

  void white();
  void black();
  void gray();
  void blue();

  void newBlend();
  void additive();
  void subtractive();
  void usual();

  void setRenderOrder(const QString &);
  void setUpdateType(const QString &);

  void bgColorDialog();

  void addKeyPoint();
  void selectKeyPoint(const QString &);
  void selectKeyPoint2(int);

  void selectLights(const QString &);

  void rewind();

  void undo();
  void redo();

  void saveGeeAs();
  void loadGee();
  void mergeGee();
  void fitGee();

  void setAcceleration(const QString &);

  void updateCameraAnimationsMenu();
  void setCameraAnimation(const QString &);
protected:

  void deliverBgColor(const VEE_Rgba & );

  VEE_QtHidden *m_glWidget;

  QMenuBar *m_menu;

  QBoxLayout * m_layout;

  class Internal;
  Internal *m_internal;

  VEE_ValueWindow * m_valueWindow;
};



class VEE_ImageIOQt : public VEE_ImageIO
{
public:
  VEE_ImageIOQt() {}
  virtual ~VEE_ImageIOQt() {}

  virtual bool read(VEE_Image *image, const char *filename, 
        int w, int h, int chans);
  virtual bool write(VEE_Image *image, const char *filename);
  
  
};

#endif // _VEE_QT_H_

---