include/GLWindow.h

Go to the documentation of this file.

#ifndef __GL_WINDOW_H__
#define __GL_WINDOW_H__

//-----------------------------------------------------------
//-----------------------------------------------------------

#include <ngl/Camera.h>
#include <ngl/Colour.h>
#include <ngl/Light.h>
#include <ngl/Material.h>
#include <ngl/TransformStack.h>
#include <ngl/Vector.h>

#include "FluidEngine.h"

// must be declared last
#include <QtOpenGL>

class GLWindow : public QGLWidget
{
Q_OBJECT

public:

  enum FieldToRender{
                      VELOCITY,
                      PRESSURE,
                      TEMPERATURE,
                      DENSITY
                    };

  enum BackgroundType{
                      LIGHT,
                      DARK
                     };

  GLWindow(
           QWidget *_parent
          );
  ~GLWindow();

public slots:
  void setIsoLevel(
                    float _isoLevel
                  );

  void setSamplingChannel(
                          int _channelIndex
                         );

  void setMeshingMethod(
                        int _method
                       );

  void toggleSimulation();

  void toggleMesh(
                  bool _displayMesh
                 );

  void setMeshField(
                    int _meshField
                   );

  void toggleObstacles(
                        bool _displayObstacles
                      );

  void setObstacleGeometry(
                            int _geoIndex
                          );

  void toggleGridPlane(
                        bool _displayGridPlane
                      );

  void toggleContainer(
                        bool _displayContainer
                      );

  void toggleLightIcon(
                        bool _displayLightIcon
                      );

  void setLightPosition(
                        float _posX,
                        float _posY,
                        float _posZ
                       );

  void setLightAttenuation(
                            float _constant,
                            float _linear,
                            float _quadratic
                          );

  void setLightColour(
                      float _r,
                      float _g,
                      float _b
                     );

  void setLightSpecColour(
                          float _r,
                          float _g,
                          float _b
                         );

  void toggleSlice(
                    bool _displaySlice
                  );

  void setSliceField(
                      int _sliceField
                    );

  void setSliceOpacity(
                        double _opacity
                      );

  void setSlicePos(
                    int _slicePos
                  );

  void setBGType(
                  int _bgType
                );

  void setMeshColour(
                      float _r,
                      float _g,
                      float _b
                    );

  void setMeshMaterial(
                        int _materialIndex
                      );

  inline void setCellSize(
                          double _cellSize
                         )
                         {
                          m_fluidEngine->setCellSize(_cellSize);
                         }

  inline void setSplatRadius(
                              double _splatRadius
                            )
                            {
                              m_fluidEngine->setSplatRadius(_splatRadius);
                            }

  inline void setAmbientTemperature(
                                    double _ambientTemperature
                                   )
                                   {
                                     m_fluidEngine->setAmbientTemperature(_ambientTemperature);
                                   }

  inline void setImpulseTemperature(
                                    double _impulseTemperature
                                   )
                                   {
                                    m_fluidEngine->setImpulseTemperature(_impulseTemperature);
                                   }

  inline void setImpulseDensity(
                                double _impulseDensity
                               )
                               {
                                m_fluidEngine->setImpulseDensity(_impulseDensity);
                               }

  inline void setImpulsePosition(
                                  double _posX,
                                  double _posY,
                                  double _posZ
                                )
                                {
                                  m_fluidEngine->setImpulsePosition(_posX, _posY, _posZ);
                                }

  inline void setPoissonIterations(
                                    int _numPoissonIterations
                                  )
                                  {
                                    m_fluidEngine->setPoissonIterations(_numPoissonIterations);
                                  }

  inline void setTimestep(
                          double _timestep
                         )
                         {
                           m_fluidEngine->setTimestep(_timestep);
                         }

  inline void setBuoyancyLift(
                              double _buoyancyLift
                             )
                             {
                              m_fluidEngine->setBuoyancyLift(_buoyancyLift);
                             }

  inline void setGasWeight(
                            double _gasWeight
                          )
                          {
                            m_fluidEngine->setGasWeight(_gasWeight);
                          }

  inline void setBuoyancyDirection(
                                    float _dirX,
                                    float _dirY,
                                    float _dirZ
                                  )
                                  {
                                    m_fluidEngine->setBuoyancyDirection(_dirX, _dirY, _dirZ);
                                    updateGL();
                                  }

  inline void togglePeriodicNoise(
                                  bool _enablePeriodicNoise
                                 )
                                 {
                                  m_fluidEngine->togglePeriodicNoise(_enablePeriodicNoise);
                                  updateGL();
                                 }

  inline void setNoiseVariance(
                                float _noiseVarianceX,
                                float _noiseVarianceY,
                                float _noiseVarianceZ
                              )
                              {
                                m_fluidEngine->setNoiseVariance(
                                                                _noiseVarianceX,
                                                                _noiseVarianceY,
                                                                _noiseVarianceZ
                                                               );
                                updateGL();
                              }
  inline void setNoiseDrivingFunc(
                                  int _funcIndexX,
                                  int _funcIndexY,
                                  int _funcIndexZ
                                 )
                                 {
                                  m_fluidEngine->setNoiseDrivingFunc(
                                                                      _funcIndexX,
                                                                      _funcIndexY,
                                                                      _funcIndexZ
                                                                    );
                                 }


  inline void setTemperatureDissipation(
                                        double _temperatureDissipation
                                       )
                                       {
                                         m_fluidEngine->setTemperatureDissipation(_temperatureDissipation);
                                       }

  inline void setDensityDissipation(
                                    double _densityDissipation
                                   )
                                   {
                                     m_fluidEngine->setDensityDissipation(_densityDissipation);
                                   }

  inline void setVelocityDissipation(
                                      double _velocityDissipation
                                    )
                                    {
                                      m_fluidEngine->setVelocityDissipation(_velocityDissipation);
                                    }

private:
  int m_spinXFace;
  int m_spinYFace;
  bool m_cameraOrbit;
  bool m_cameraPan;

  int m_origX;
  int m_origY;
  int m_origXPos;
  int m_origYPos;

  ngl::Camera* m_camera;

  ngl::TransformStack m_transformStack;

  ngl::Material* m_meshMaterial;
  ngl::Light* m_light;
  ngl::Vector* m_lightIconPos;
  ngl::Colour* m_lightIconColour;


  FluidEngine* m_fluidEngine;

  int m_simRes;

  bool m_simulate;

  bool m_displayMesh;
  bool m_displayObstacles;
  bool m_displaySlice;
  bool m_displayGridPlane;
  bool m_displayContainer;
  bool m_displayLightIcon;

  FieldToRender m_sliceField;

  FieldToRender m_meshField;

  BackgroundType m_bgType;

protected:
  void initializeGL();

  void resizeGL(
                const int _w,
                const int _h
               );
  void paintGL();

private:
  //------------------------------ MOUSE INTERACTION EVENTS -----------------------------------
  void mouseMoveEvent(
                       QMouseEvent * _event
                      );

  void mousePressEvent(
                        QMouseEvent *_event
                       );

  void mouseReleaseEvent(
                          QMouseEvent *_event
                        );
  void wheelEvent(
                   QWheelEvent *_event
                  );

  //------------------------------ END MOUSE INTERACTION EVENTS -------------------------------

  void timerEvent(
                    QTimerEvent *_event
                  );
};

#endif // __GL_WINDOW_H__