GLWindow.h

Go to the documentation of this file.

#ifndef __GL_WINDOW_H__
#define __GL_WINDOW_H__

#include "Effect.h"
#include "PostProcessor.h"
#include "ngl/Camera.h"
#include "ngl/TransformStack.h"
#include "ngl/Obj.h"
#include "ScreenQuad.h"
#include "FrameBufferObject.h"
#include "Frustum.h"
#include "TextureManager.h"
#include "LightingManager.h"
#include "GameObject.h"
#include "ngl/VertexArrayObject.h"

// must be included after our stuff becuase GLEW needs to be first
#include <QtOpenGL>

class GLWindow : public QGLWidget
{
Q_OBJECT
public :

  GLWindow(
           QWidget *_parent
          );

void processKeyPress(QKeyEvent *_event);

public slots:

  inline void toggleWireframe(bool _mode)
  {
      m_wireframe = _mode;
      updateGL();
  }

  inline void toggleShadowMap(bool _mode)
  {
      m_showShadowMap = _mode;
      updateGL();
  }

  inline void toggleDebug(bool _mode)
  {
      m_debug = _mode;
      updateGL();
  }


  inline void setKa(double _value)
  {
      m_Ka = (float)_value;
      updateGL();
  }

  inline void setKd(double _value)
  {
      m_Kd = (float)_value;
      updateGL();
  }

  inline void setDVecX(double _value)
  {
      m_directionalVec.m_x = _value;
      updateGL();
  }

  inline void setDVecY(double _value)
  {
      m_directionalVec.m_y = _value;
      updateGL();
  }

  inline void setDVecZ(double _value)
  {
      m_directionalVec.m_z = _value;
      updateGL();
  }

  inline void setAmbientColourR(double _value)
  {
      m_ambientColour.m_x = _value;
      updateGL();
  }

  inline void setAmbientColourG(double _value)
  {
      m_ambientColour.m_y = _value;
      updateGL();
  }

  inline void setAmbientColourB(double _value)
  {
      m_ambientColour.m_z = _value;
      updateGL();
  }

  inline void setDColourR(double _value)
  {
      m_directionalColour.m_x = _value;
      updateGL();
  }

  inline void setDColourG(double _value)
  {
      m_directionalColour.m_y = _value;
      updateGL();
  }

  inline void setDColourB(double _value)
  {
      m_directionalColour.m_z = _value;
      updateGL();
  }

  inline void changeNormWeight(double _value)
  {
      m_AAweightNorm = (float)_value;
      updateGL();
  }

  inline void changeDepthWeight(double _value)
  {
      m_AAweightDepth = (float)_value;
      updateGL();
  }

  inline void changeNormBarrier(double _value)
  {
      m_AAbarrierNorm = (float)_value;
      updateGL();
  }

  inline void changeDepthBarrier(double _value)
  {
      m_AAbarrierDepth = (float)_value;
      updateGL();
  }

  inline void changeKernel(double _value)
  {
      m_AAkernel = (float)_value;
      updateGL();
  }

  void setMainDisplay(int _displayMode);

protected:

  float m_AAbarrierNorm, m_AAbarrierDepth, m_AAweightNorm,m_AAweightDepth, m_AAkernel;

  void genShader(const std::string &_name, const std::string &_VSname, const std::string &_FSname, const std::vector<std::string> &_attributes);

  int m_currentDisplay;

  int m_spinXFace;

  int m_spinYFace;

  bool m_rotate;

  int m_origX;

  int m_origY;

  void initializeGL();

  void resizeGL(const int _w,const int _h){m_windoWidth = _w; m_windowHeight = _h;}

  void paintGL();

  void timerEvent(QTimerEvent *_event);

  void createScreenQuad();

  ngl::TransformStack m_transformStack;

private:
  void mouseMoveEvent (
                       QMouseEvent * _event
                      );
  void mousePressEvent (
                        QMouseEvent *_event
                       );
  void mouseReleaseEvent (
                          QMouseEvent *_event
                         );

  void setupShaders();

  void setupTextures();

  void lightAccumulation();
  void shadowPass();
  void geometryPass();
  void debugPass();

  void postProcess();

  void postProcessUniforms();

  void postProcessSetup();

  void addStandardEffect(const std::string &_effectName,
                         const std::string &_outputName,
                         const std::string &_shaderName,
                         const std::string &_sourceName);

  TextureManager m_textureManager;

  LightingManager m_lightingManager;

  int m_updatetimer;

  float m_time;
  float m_timeStep;
  float m_Ka;
  float m_Kd;
  bool m_wireframe;
  bool m_debug;
  ScreenQuad m_viewportQuad;
  Frustum m_frustum;
  FrameBufferObject m_fbo;
  FrameBufferObject m_shadowBuffer;

  ngl::Camera m_cam;

  unsigned int m_pointLightVAO;
  std::string m_spotLightName;
  unsigned int m_screenQuadVAO;

  ScreenQuad m_debugQuad1;
  ScreenQuad m_debugQuad2;
  ScreenQuad m_debugQuad3;
  ScreenQuad m_debugQuad4;
  ScreenQuad m_debugQuad5;
  ScreenQuad m_debugQuad6;

  ngl::Vector m_directionalVec;

  ngl::Vector m_ambientColour;

  ngl::Vector m_directionalColour;

  bool m_showShadowMap;

  PostProcessor m_postProcessor;

  ngl::Obj *obj;

  int m_windoWidth, m_windowHeight;
};

#endif