GLWindow.cpp

Go to the documentation of this file.

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

#include "GLWindow.h"
#include <iostream>

#include "ngl/BBox.h"
#include "ngl/Camera.h"
#include "ngl/Colour.h"
#include "ngl/Light.h"
#include "ngl/Material.h"
#include "ngl/Matrix.h"
#include "ngl/NGLInit.h"
#include "ngl/Obj.h"
#include "ngl/VBOPrimitives.h"
#include "ngl/Transformation.h"
#include "ngl/TransformStack.h"
#include "ngl/ShaderManager.h"

//----------------------------------------------------------------------------------------------------------------------
GLWindow::GLWindow(
                  QWidget *_parent
                  ) :
                    QGLWidget(_parent)
{

  // set this widget to have the initial keyboard focus
  setFocus();
  // re-size the widget to that of the parent (in this case the GLFrame passed in on construction)
  this->resize(_parent->size());
  // Now set the initial GLWindow attributes to default values
  // Roate is false
  m_rotate=false;
  // mouse rotation values set to 0
  m_spinXFace=0;
  m_spinYFace=0;

  // flag of showing help
  m_drawHelp=0;

  m_wireframe=false;
  m_enableMountain=true;
  m_mountainIterations=15;

  // now set the inital camera values
  m_cameraIndex=0;
  m_fov=65.0;
  m_aspect=972.0/656.0;
  m_projection=ngl::PERSPECTIVE;

  m_fpsTimer =startTimer(0);
  m_fps=0;
  m_frames=0;
  m_timer.start();

  // now set size of scene
  m_sceneWidth=50;
  m_sceneHeight=50;

  // set non-flammbale object size
  m_objectRadius = 0.3;
  m_objectHeight = 0.2;

  m_newIndexOfOrigin = 0;

  m_windDirectionRot = 90;
  m_showWindDir = false;
  m_temperature = 23.0;
  m_sceneMoisture = 15.0;
}

//----------------------------------------------------------------------------------------------------------------------
GLWindow::~GLWindow()
{
  ngl::NGLInit *Init = ngl::NGLInit::instance();
  std::cout<<"Shutting down NGL, removing VBO's and Shaders\n";
  Init->NGLQuit();
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::createCameras()
{
  // create a load of cameras
  ngl::Camera cam;
  ngl::Camera Tcam;
  ngl::Camera Scam;
  ngl::Camera Fcam;
  // set the different vectors for the camera positions
  ngl::Vector EYE(0,5,8);
  ngl::Vector LOOK=0.0;
  ngl::Vector UP(0,1,0);

  ngl::Vector TEYE(0,8,0);
  ngl::Vector TLOOK=0.0;
  ngl::Vector TUP(0,0,1);

  ngl::Vector SEYE(2,2,2);
  ngl::Vector SLOOK=0.0;
  ngl::Vector SUP(0,1,0);

  ngl::Vector FEYE(5,2,8);
  ngl::Vector FLOOK(0.0,0.0,0.0);
  ngl::Vector FUP(0,1,0);

  // finally set the cameras shape and position
  cam.set(EYE,LOOK,UP);
  cam.setShape(m_fov,m_aspect, 0.2f,150.0f,m_projection);
  cam.setOrthoParams(-1,1,-1,1,0.1,10.0);
  m_cameras.push_back(cam);

  Tcam.set(TEYE,TLOOK,TUP);
  Tcam.setShape(m_fov,m_aspect, 0.2f,150.0f,m_projection);
  Tcam.setOrthoParams(-0.1,0.1,-0.1,0.1,0.1,10.0);
  m_cameras.push_back(Tcam);
  Scam.set(SEYE,SLOOK,SUP);
  Scam.setShape(m_fov,m_aspect, 0.2f,150.0f,m_projection);
  Scam.setOrthoParams(-0.1,0.1,-0.1,0.1,0.1,10.0);
  m_cameras.push_back(Scam);
  Fcam.set(FEYE,FLOOK,FUP);
  Fcam.setShape(m_fov,m_aspect, 0.2f,150.0f,m_projection);
  Fcam.setOrthoParams(-0.1,0.1,-0.1,0.1,0.1,10.0);
  m_cameras.push_back(Fcam);

}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::setCameraShape()
{
  ngl::ShaderManager *shader=ngl::ShaderManager::instance();
  int cameraSize=m_cameras.size();
  for(int i=0; i<cameraSize; ++i)
  {
    m_cameras[i].setShape(m_fov,m_aspect, 0.2f,150.0f,m_projection);
    m_cameras[i].setOrthoParams(-1,1,-1,1,1,10.0);
  }

  (*shader)["Colour"]->use();
  shader->setShaderParamFromMatrix("Colour","projectionMatrix",m_cameras[m_cameraIndex].getProjection());
  (*shader)["Blinn"]->use();
  shader->setShaderParamFromMatrix("Blinn","projectionMatrix",m_cameras[m_cameraIndex].getProjection());
}

//----------------------------------------------------------------------------------------------------------------------
// This virtual function is called once before the first call to paintGL() or resizeGL(),
//and then once whenever the widget has been assigned a new QGLContext.
// This function should set up any required OpenGL context rendering flags, defining display lists, etc.
void GLWindow::initializeGL()
{
   // set up light
   glEnable(GL_LIGHTING);

   // enable depth testing for drawing
   glEnable(GL_DEPTH_TEST);

   glClearColor(0.3f, 0.3f, 0.3f, 1.0f);         // Grey Background
   ngl::NGLInit *Init = ngl::NGLInit::instance();
   #ifdef WIN32
         glewInit();
   #endif
   Init->initGlew();

   createCameras();

   // now to load the shader and set the values
   // grab an instance of shader manager
   ngl::ShaderManager *shader=ngl::ShaderManager::instance();
   m_light = new ngl::Light(ngl::Vector(1,1,1,1),ngl::Colour(1,1,1,1),ngl::LIGHTREMOTE);

   // ----- Colour Shader
   // create shader program
   shader->createShaderProgram("Colour");
   // load shader sources
   shader->attachShader("cvertex",ngl::VERTEX);
   shader->attachShader("cfragment",ngl::FRAGMENT);
   shader->loadShaderSource("cvertex","shaders/Colour.vs");
   shader->loadShaderSource("cfragment","shaders/Colour.fs");
   // compile
   shader->compileShader("cvertex");
   shader->compileShader("cfragment");
   // link
   shader->attachShaderToProgram("Colour","cvertex");
   shader->attachShaderToProgram("Colour","cfragment");
   shader->linkProgramObject("Colour");
   // use
   (*shader)["Colour"]->use();

   // ----- Blinn Shader
   // create shader program
   shader->createShaderProgram("Blinn");
   // load shader sources
   shader->attachShader("overtex",ngl::VERTEX);
   shader->attachShader("ofragment",ngl::FRAGMENT);
   shader->loadShaderSource("overtex","shaders/Vertex_obj.vs");
   shader->loadShaderSource("ofragment","shaders/Fragment_obj.fs");
   // compile
   shader->compileShader("overtex");
   shader->compileShader("ofragment");
   // link
   shader->attachShaderToProgram("Blinn","overtex");
   shader->attachShaderToProgram("Blinn","ofragment");
   shader->linkProgramObject("Blinn");
   // use
   (*shader)["Blinn"]->use();

   // create an instance of the VBO primitive
   ngl::VBOPrimitives *prim=ngl::VBOPrimitives::instance();

   // create sphere
   prim->createVBOSphere("sphere",1.0,20);

   // create cylinder
   prim->createVBOCylinder("cylinder", m_objectRadius, m_objectHeight, 50, 10);

   // create disk
   prim->createVBODisk("disk", m_objectRadius, 50);

   // create cone
   prim->createVBOCone("cone", 0.9, 2.0, 50, 50);

   // primitive for wind axis
   prim->createVBOCylinder("nglAXISCylinder",0.03,0.4,60,60);
   prim->createVBOCone("nglAXISCone",0.07,0.2,30,30);

   m_light->enable();
   // --- assign texture to Blinn Shader
   // load and set a texture
   ngl::Texture t("resources/textures/Grass.bmp");

   t.setTextureGL();
   glGenerateMipmap(GL_TEXTURE_2D);
   glEnable(GL_MULTISAMPLE);

   // the shader will use the currently active material and light0 so set them
   ngl::Material m(ngl::GOLD);
   m.use();
   ngl::Light *L1 = new ngl::Light(ngl::Vector(0,5,4,1),ngl::Colour(1,1,1,1),ngl::LIGHTLOCAL);
   L1->enable();

   // ----- create fire scene object
   fireScene = new FireArea(m_sceneWidth, m_sceneHeight, m_objectRadius, m_objectHeight, m_enableMountain, m_mountainIterations);
}

//----------------------------------------------------------------------------------------------------------------------
//This virtual function is called whenever the widget has been resized.
// The new size is passed in width and height.
void GLWindow::resizeGL(
                       int _w,
                       int _h
                       )
{
  glViewport(0,0,_w,_h);

  // calculate the aspect ratio
  m_aspect=(float)_w/_h;

  // now set the camera values
  setCameraShape();

}

//----------------------------------------------------------------------------------------------------------------------
//This virtual function is called whenever the widget needs to be painted.
// this is our main drawing routine
void GLWindow::paintGL()
{
   // create an instance of the VBO primitive
   //ngl::VBOPrimitives *prim=ngl::VBOPrimitives::instance();
   // grab an instance of the shader manager
   ngl::ShaderManager *shader=ngl::ShaderManager::instance();
   // clear the screen and depth buffer
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   // Rotation based on the mouse position for our global
   // transform
   ngl::Transformation trans;
   trans.setRotation(m_spinXFace,m_spinYFace,0);
   // set this in the TX stack
   m_transformStack.setGlobal(trans);

   m_light->enable();

   // now set this value in the shader for the current Camera, we do all 3 elements as they
   // can all change per frame
   (*shader)["Blinn"]->use();
   shader->setShaderParamFromMatrix("Blinn","ViewMatrix",m_cameras[m_cameraIndex].getModelView());
   shader->setShaderParamFromMatrix("Blinn","projectionMatrix",m_cameras[m_cameraIndex].getProjection());

   // now set this value in the shader for the current ModelMatrix
   shader->setShaderParamFromMatrix("Blinn","ModelMatrix",m_transformStack.getCurrAndGlobal().getMatrix());

   (*shader)["Colour"]->use();
   shader->setShaderParamFromMatrix("Colour","ViewMatrix",m_cameras[m_cameraIndex].getModelView());
   shader->setShaderParamFromMatrix("Colour","projectionMatrix",m_cameras[m_cameraIndex].getProjection());
   shader->setShaderParam4f("Colour","Colour",0,0,0,1);

   // now go back to solid drawing
   glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);

   // ----- draw scene
   m_transformStack.pushTransform();
   {
       (*shader)["Colour"]->use();

       fireScene->drawArea("Colour", m_transformStack);

       // set colour back to black for the base grid colour
       shader->setShaderParam4f("Colour","Colour",0.0,0.0,0.0,1.0);
   }
   m_transformStack.popTransform();

   // ----- draw dla path
   m_transformStack.pushTransform();
   {
       (*shader)["Colour"]->use();
       shader->setShaderParamFromMatrix("Colour","ModelMatrix",m_transformStack.getCurrAndGlobal().getMatrix());
       shader->setShaderParam4f("Colour","Colour",1.0,0.5,0.8,1.0);

       fireScene->timestep("Colour", m_transformStack);
   }
   m_transformStack.popTransform();

   // ----- draw grid
   m_transformStack.pushTransform();
   {
       if(m_wireframe==false)
       {
           (*shader)["Blinn"]->use();
           fireScene->drawGrid(m_wireframe);
           fireScene->drawBase();
       }
       else
       {
           (*shader)["Colour"]->use();
           shader->setShaderParamFromMatrix("Colour","ModelMatrix",m_transformStack.getCurrAndGlobal().getMatrix());
           shader->setShaderParam4f("Colour","Colour",0.0,0.0,0.0,1.0);
           fireScene->drawGrid(m_wireframe);
       }
   }
   m_transformStack.popTransform();

   // ----- draw fuel object
   m_transformStack.pushTransform();
   {
       glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
       glEnable(GL_BLEND);

       //glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);

       fireScene->drawRandomobject("Colour", m_transformStack);

      // glDisable(GL_BLEND);
   }
   m_transformStack.popTransform();

   // ----- draw AXIS for wind direction
   m_transformStack.pushTransform();
   {
       if(m_showWindDir==true)
       {
           m_transformStack.loadGlobalMatrixToShader("Colour","ModelMatrix");
           drawAxis("Colour",m_transformStack, 2.0, m_spinXFace, m_spinYFace);
       }
   }
   m_transformStack.popTransform();



   // ----- calculate and draw FPS
   ++m_frames;
   glUseProgramObjectARB(0);

   // ----- showing text
   glUseProgram(0);
   glColor3f(0.9,0.85,0.8);
   QFont font;
   font.setPointSize(10);

   // now we are going to construct a string to draw the mode information
/*     QString text;
  switch ( m_moveMode)
   {
     case MOVEEYE : mode=QString("Move Eye"); break;
     case MOVELOOK : mode=QString("Move Look"); break;
     case MOVEBOTH : mode=QString("Move Both"); break;
     case MOVESLIDE : mode=QString("Move Slide"); break;
   }
   QString text=QString("Active Camera : %1 ,Current mode = %2").arg(m_cameraIndex).arg(mode);
   renderText(10,18,text,font);
   text=QString("FOV = %1 ").arg(m_fov);
   renderText(10,18*2,text,font);

   font.setPointSize(8);

   renderText(10,18*3,"ModelView Matrix",font);
   // now we use the QString sprintf
   ngl::Matrix m=m_cameras[m_cameraIndex].getModelView();
   text.sprintf("[ %+0.4f %+0.4f %+0.4f %+0.4f]",m.openGL()[0],m.openGL()[1],m.openGL()[2],m.openGL()[3]);
   renderText(10,16*4,text,font);
   text.sprintf("[ %+0.4f %+0.4f %+0.4f %+0.4f]",m.openGL()[4],m.openGL()[5],m.openGL()[6],m.openGL()[7]);
   renderText(10,16*5,text,font);
   text.sprintf("[ %+0.4f %+0.4f %+0.4f %+0.4f]",m.openGL()[8],m.openGL()[9],m.openGL()[10],m.openGL()[11]);
   renderText(10,16*6,text,font);
   text.sprintf("[ %+0.4f %+0.4f %+0.4f %+0.4f]",m.openGL()[12],m.openGL()[13],m.openGL()[14],m.openGL()[15]);
   renderText(10,16*7,text,font);

   renderText(10,16*8,"Projection Matrix",font);
   // now we use the QString sprintf
   m=m_cameras[m_cameraIndex].getProjection();
   text.sprintf("[ %+0.4f %+0.4f %+0.4f %+0.4f]",m.openGL()[0],m.openGL()[1],m.openGL()[2],m.openGL()[3]);
   renderText(10,16*9,text,font);
   text.sprintf("[ %+0.4f %+0.4f %+0.4f %+0.4f]",m.openGL()[4],m.openGL()[5],m.openGL()[6],m.openGL()[7]);
   renderText(10,16*10,text,font);
   text.sprintf("[ %+0.4f %+0.4f %+0.4f %+0.4f]",m.openGL()[8],m.openGL()[9],m.openGL()[10],m.openGL()[11]);
   renderText(10,16*11,text,font);
   text.sprintf("[ %+0.4f %+0.4f %+0.4f %+0.4f]",m.openGL()[12],m.openGL()[13],m.openGL()[14],m.openGL()[15]);
   renderText(10,16*12,text,font);

   font.setPointSize(10);
   font.setBold(true);
   renderText(10,16*14,"Press 'h' to display Help",font);

   // ----- draw help
   int m_showHelp = m_drawHelp%2;
   if (m_showHelp==1)
   {
       font.setPointSize(9);
       font.setBold(false);

       // now render the text using the QT renderText helper function
       renderText(10,18*14,"Arrow Keys : move Camera",font);
       renderText(10,18*15,"0-4 : switch cameras",font);
       renderText(10,18*16,"z/x : decrease/increase terrain height",font);
       renderText(10,18*17,"xxxx",font);
       renderText(10,18*18,"c : d",font);
       renderText(10,18*19,"v : increase terrain size",font);
       renderText(10,18*20,"+/-  : change fov of Camera",font);
       renderText(10,18*21,"5/6 : ortho/perspective projection",font);
       renderText(10,18*22,"i/o : move camera in/out",font);
   }
   */
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::mouseMoveEvent (
                              QMouseEvent * _event
                              )
{
  // note the method buttons() is the button state when event was called
  // this is different from button() which is used to check which button was
  // pressed when the mousePress/Release event is generated
  if(m_rotate && _event->buttons() == Qt::LeftButton)
  {
    m_spinYFace = ( m_spinYFace + (_event->x() - m_origX) ) % 360 ;
    m_spinXFace = ( m_spinXFace + (_event->y() - m_origY) ) % 360 ;
    m_origX = _event->x();
    m_origY = _event->y();
  }
  // re-draw GL
  updateGL();
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::mousePressEvent (
                               QMouseEvent * _event
                               )
{
  // this method is called when the mouse button is pressed in this case we
  // store the value where the maouse was clicked (x,y) and set the Rotate flag to true
  if(_event->button() == Qt::LeftButton)
  {
    m_origX = _event->x();
    m_origY = _event->y();
    m_rotate =true;
  }
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::mouseReleaseEvent (
                                 QMouseEvent * _event
                                 )
{
  // this event is called when the mouse button is released
  // we then set Rotate to false
  if (_event->button() == Qt::LeftButton)
  {
    m_rotate=false;
  }
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::timerEvent(
                          QTimerEvent *_event
                         )
{
    if(_event->timerId() == m_fpsTimer)
    {
        if( m_timer.elapsed() > 1000.0)
        {
            m_fps=m_frames;
            m_frames=0;
            m_timer.restart();
        }
    }
    updateGL();
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::toggleWireframe(
                              bool _mode
                              )
{
    m_wireframe=_mode;

    fireScene->drawGrid(m_wireframe);
    updateGL();
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::toggleShowLine(
                             bool _mode
                             )
{
    fireScene->showLine(_mode);
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::toggleTerrain(
                            bool _mode
                            )
{
    m_enableMountain = _mode;
    fireScene->toggleMountainDraw(m_enableMountain, m_mountainIterations);
    fireScene->updateGridPoint();
    fireScene->seperateList();
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::increaseTerrainHeight()
{
    fireScene->adjustMountainHeight(0.01, 2);
    fireScene->updateGridPoint();
    fireScene->seperateList();
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::decreaseTerrainHeight()
{
    fireScene->adjustMountainHeight(0.01, 1);
    fireScene->updateGridPoint();
    fireScene->seperateList();
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::zoomIn()
{
    --m_fov;
    setCameraShape();
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::zoomOut()
{
    ++m_fov;
    setCameraShape();
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::pickCamera(
                         int _i
                         )
{
    m_cameraIndex = _i;
    updateGL();
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::setColour()
{
        QColor colour = QColorDialog::getColor();
        if( colour.isValid())
        {
                ngl::ShaderManager *shader=ngl::ShaderManager::instance();
                (*shader)["Colour"]->use();
                shader->setShaderParam4f("Colour","Colour",colour.redF(),colour.greenF(),colour.blueF(),1.0);
                updateGL();
        }
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::resetMountain()
{
    fireScene->buildMountain();
    fireScene->updateGridPoint();
    fireScene->seperateList();
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::setNewMountainIterations(
                                       int _newIterations
                                       )
{
    m_mountainIterations = _newIterations;
    fireScene->toggleMountainDraw(m_enableMountain,m_mountainIterations);
    fireScene->updateGridPoint();
    fireScene->seperateList();
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::moveOriginDown()
{
    fireScene->adjustOrigin(4);
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::moveOriginLeft()
{
    fireScene->adjustOrigin(1);
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::moveOriginRight()
{
    fireScene->adjustOrigin(2);
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::moveOriginUp()
{
    fireScene->adjustOrigin(3);
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::adjustObstacleAmount(
                                   int _newNumber
                                   )
{
    fireScene->pickObjectPosition(_newNumber);
    fireScene->updateGridPoint();
    fireScene->seperateList();
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::adjustFuelAmount(int _newAmount)
{
    fireScene->pickFlammableObjectPosition(_newAmount);
    fireScene->updateGridPoint();
    fireScene->seperateList();
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::generateNewFirePath()
{
    fireScene->generateNewDLA();
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::editDLA()
{
    fireScene->pauseTime(true, true);
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::pauseAnimation()
{
    fireScene->pauseTime(true, false);
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::playAnimation()
{
    fireScene->pauseTime(false, false);
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::assignNewOrigin(
                              int _newOriginAmount
                              )
{
    fireScene->adjustOriginAmount(_newOriginAmount);
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::selectMovingOrigin(
                                 int _indexOfOrigin
                                 )
{
    m_newIndexOfOrigin = _indexOfOrigin-1;
    fireScene->changeMovingOriginIndex(m_newIndexOfOrigin);
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::toggleShowMark(
                             bool _mode
                             )
{
    fireScene->showMark(_mode);
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::enableWind(
                         bool _mode
                         )
{
    fireScene->assignWind(_mode);

    if(_mode==false)
    {
        m_showWindDir = false;
    }
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::showWindDir(
                          bool _mode
                          )
{
    m_showWindDir = _mode;
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::assignWindSpeed(
                              int _newWindSpeed
                              )
{
    if(_newWindSpeed<4)
        _newWindSpeed = 4;

    fireScene->assignWindSpeed(_newWindSpeed);
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::changeWindDirection(
                                  int _newDir
                                  )
{
    m_windDirectionRot = _newDir;
    fireScene->assignWindDirection(ngl::Vector(m_windDirectionRot,0.0,m_windDirectionRot));
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::changeTemperature(
                                double _newTemp
                                )
{
    m_temperature = _newTemp;
    fireScene->assignNewMoisture(_newTemp, 1);
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::changeMoistureOfTheScene(
                                       double _newSceneMoisture
                                       )
{
    m_sceneMoisture = _newSceneMoisture;
    fireScene->assignNewMoisture(_newSceneMoisture, 2);
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::changeObjMoisture(
                                double _newObjMoisture
                                )
{
    fireScene->assignNewObjMoisture(_newObjMoisture);
    fireScene->updateGridPoint();
    fireScene->seperateList();
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::adjustFuelSize(
                             int _side,
                             int _type
                             )
{
    fireScene->adjustObjSize(_side, _type);
    fireScene->updateGridPoint();
    fireScene->seperateList();
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::selectObjIndexToAdjustSize(
                                         int _objIndex
                                         )
{
    int m_objIndex = _objIndex-1;
    fireScene->changeIndexOfObj(m_objIndex);
}

//----------------------------------------------------------------------------------------------------------------------
void GLWindow::drawAxis(
                       const std::string &m_shaderName,
                       ngl::TransformStack &m_axisTransformStack,
                       float m_scale,
                       int m_xRot,
                       int m_yRot
                       )
{
    ngl::VBOPrimitives *prim=ngl::VBOPrimitives::instance();
    // grab an instance of the shader manager
    ngl::ShaderManager *shader=ngl::ShaderManager::instance();

    ngl::Transformation tx;

    ngl::Vector m_colour = ngl::Vector(0.8,0.6,1.0);

    m_axisTransformStack.pushTransform();
    {
        (*shader)[m_shaderName]->use();
        shader->setShaderParamFromMatrix(m_shaderName,"ModelMatrix",m_axisTransformStack.getCurrAndGlobal().getMatrix());

        // ----- set colour to each point
        shader->setShaderParam4f(m_shaderName,m_shaderName,m_colour.m_x,m_colour.m_y,m_colour.m_z,1.0);

        // set the global rotation
        tx.setRotation(m_xRot,m_yRot,0.0);
        m_axisTransformStack.setCurrent(tx);

        // set the global rotation
        m_axisTransformStack.pushTransform();
        {
            float m_rot = m_windDirectionRot - 180;
            m_axisTransformStack.getCurrentTransform().setScale(m_scale,m_scale,m_scale);
            m_axisTransformStack.getCurrentTransform().setPosition(ngl::Vector(0,5,0));
            m_axisTransformStack.getCurrentTransform().setRotation(0,m_rot,0);
            m_axisTransformStack.loadGlobalMatrixToShader(m_shaderName,"ModelMatrix");
            prim->draw("nglAXISCylinder");

            m_axisTransformStack.getCurrentTransform().setPosition(ngl::Vector(0,5,0));
            m_axisTransformStack.getCurrentTransform().setRotation(0, m_windDirectionRot,0);
            m_axisTransformStack.loadGlobalMatrixToShader(m_shaderName,"ModelMatrix");
            prim->draw("nglAXISCone");

        }
        m_axisTransformStack.popTransform();

    }
    m_axisTransformStack.popTransform();
}