//////////////////////////////
//Main Libary
/////////////////////////////
#define NO_SDL_GLEXT
#include <glew.h>
#include "SDL/SDL.H"
#include  "SDL/SDL_IMAGE.H"
#include "SDL/SDL_OPENGL.H"
#undef main
#include <iostream>
#include <cassert>
#include <string>
#include <algorithm>
#include <boost/iostreams/stream.hpp>
#include <libs/iostreams/example/container_device.hpp>
#include <boost/filesystem.hpp>
#include <boost/iostreams/categories.hpp>
#include <boost/algorithm/string.hpp>
#include <vector>
#include <fstream>
#include "GL/glu.h"
#include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <glm/gtc/matrix_transform.hpp>
/////////////////////////////
using namespace std;
using namespace boost::filesystem;
namespace io = boost::iostreams;
namespace ex = boost::iostreams::example;
////////////////////////////

//for holding the string
typedef ex::container_source<string> string_source;
typedef std::vector< std::string > string_list;

struct Point {float x,  y, z;};
std::vector<unsigned int>faces;
std::vector<Point>points;
//Turn on FileReader
bool ModelRender = false;

float
leftandright = 0.0,
             upanddown = 0.0,
             forwardandbackward = 0.0;
GLuint vertexbuffer;
float minusyaxis = -sin(0);
float yaxis = sin(0);


///////////////////////////
//DEFINES
///////////////////////////
#define SCREEN_WIDTH  1240
#define SCREEN_HEIGHT 960
#define BPP 32
#define GL_GLEXT_PROTOTYPES
#define printOpenGLError() printOglError(__FILE__, __LINE__)

int printOglError(char *file, int line)
{

  GLenum glErr;
  int    retCode = 0;

  glErr = glGetError();
  if (glErr != GL_NO_ERROR)
  {
    printf("glError in file %s @ line %d: %s\n",
        file, line, gluErrorString(glErr));
    retCode = 1;
  }
  return retCode;
}

///////////////////////////

////////////////////////////
//Other Header Files
///////////////////////////
#include "SurfaceStorage.h"
#include "IndexAssignerFunction.h"
//////////////////////////

////////////////////////
//Global Variables
////////////////////////

/////////////////////////

bool MoveObjVertex = false;
bool modelloader = true;



float* point=reinterpret_cast<float*>(&points[0]);
int num_bytes = points.size() * sizeof(points[0]);
GLuint matrixuniform;

GLuint vao[2];

GLuint translation;
GLuint Rotation;
GLuint xvalue = 600.0f;
GLuint objvbo;
GLuint objtextureID;
GLuint ModelTexture;



/////////////////
//EVENT CREATION
////////////////

//SDL Event
SDL_Event event;

int counter = 0;
int indexID;

float xm;
float ym;

int length;
char * buffer;


static GLfloat TranslationMatrix[] = {

  1.0, 0.0, 0.0, 0.0,
  0.0, 1.0, 0.0, 0.0,
  0.0, 0.0, 1.0, 0.0,
  0.0, 0.0, 0.0, 1.0


};

       //Translation Process
  GLfloat RotationMatrix[] = {
        1.0, 0.0, 0.0, 0.0,
        0.0, 1.0, 0.0, 0.0,
        0.0, 0.0, 1.0, 0.0,
        0.0, 0.0, 0.0, 1.0
 };


//Obj Graphic
static const GLfloat ObjGraphicVertices[] = {
  //x      y        z
  200.0f,  720.0f,   0.0f,   1.0f,  1.0f,   0.0f,
  320.0f,  720.0f,   0.0f,   1.0f,  0.0f,   0.0f,
  320.0f,  640.0f,   0.0f,   1.0f,  0.0f,   1.0f,
  200.0f,  640.0f,   0.0f,   1.0f,  1.0f,   1.0f

};



////////////////////////

///////////////////////
//Structure Rectangle
//////////////////////

struct rectangle
{

  GLuint textureID;
  GLuint vbo;
  GLfloat matrix[16];

};

//////////////////////
//Rectangle Variables
/////////////////////

//////////////////////
rectangle menubar;
rectangle MainToolBox;
rectangle BoxStorage;
rectangle MenuContext;
rectangle boxstorage;
rectangle ObjGraphic;
//////////////////////

glm::mat4 ortho;

///////////////////////////////////
//Prototypes
//////////////////////////////////
void create_rectangle(const char * const path, rectangle *r, const GLfloat *vertices, size_t byte_count, const GLfloat * transformation);
void draw_rectangle(rectangle *r, const float *TranslationMatrix);
void render_rectangle(void);
void setup_sdl_glew (void);
GLuint LoadProgram(const char * const vertex_file_path, const char * Fragment_file_path);
int load_texture(const char * const path);
void draw (void);
/////////////////////////////////

//////////////////////////
//Setup Vbo Function
/////////////////////////
void setup_vbos(void)
{

  ///////////////////
  //Vertex Cordinates
  ///////////////////

  ////////////////////////////
  //Graphical User Interface
  ///////////////////////////

  //1240 by 960


  //Start GUI Cordinates x y z w - NEEDS TEX CORDS
  static const GLfloat GUIVertices[] = {

    //ToolBar
    1240.0f, 960.0f,  0.0f, 1.0f, 1.0f, 0.0f,
    -1.0f,   960.0f,  0.0f, 1.0f, 0.0f, 0.0f,
    -1.0f,   930.0f,  0.0f, 1.0f, 0.0f, 1.0f,
    1240.0f, 930.0f,  0.0f, 1.0f, 1.0f, 1.0f

  };

  static const GLfloat MainToolBoxVertices[] = {

    //Main ToolBox
    // x     y       z   w       X    Y
    1240.0f, 120.0f,   0.0f, 1.0f, 1.0f,  0.0f,
    -1.0f,   120.0f,   0.0f, 1.0f, 0.0f,  0.0f,
    -1.0f,    0.0f,    0.0f, 1.0f, 0.0f,  1.0f,
    1240.0f,  0.0f,    0.0f, 1.0f, 1.0f,  1.0f

  };

  //Menu Context
  static const GLfloat MenuContextVertices[] = {

    // x     y           z     w       X    Y
    -0.76f,   0.94f,   0.0f, 1.0f,   1.0f, 0.0f,
    -1.10f, 0.94f,   0.0f,   1.0f,   0.0f, 0.0f,
    -1.10f, 0.60f,   0.0f,   1.0f,   0.0f, 1.0f,
    -0.76f,   0.60f,   0.0f, 1.0f,   1.0f, 1.0f

  };

  //Box Storage
  static const GLfloat BoxStorageVertices[] = {

    1112.0f, 860.0f,   0.0f, 1.0f,        1.0f,  0.0f,
    120.0f,   860.0f,   0.0f,   1.0f,     0.0f, 0.0f,
    120.0f,   200.0f,   0.0f,   1.0f,    0.0f, 1.0f,
    1112.0f, 200.0f,   0.0f, 1.0f,       1.0f,  1.0f

  };

  ////////////////////////////////
  //Generate Vertex Array Object
  /////////////////////////////////

  glGenVertexArrays(1, &vao[0]);

  create_rectangle("GUI/FileMenu.tga", &menubar, GUIVertices, sizeof(GUIVertices), NULL);
  create_rectangle("GUI/MainToolBox.tga", &MainToolBox, MainToolBoxVertices, sizeof(MainToolBoxVertices), NULL);
  create_rectangle("GUI/MenuContext.tga", &MenuContext, MenuContextVertices, sizeof(MenuContextVertices), NULL);
  create_rectangle("GUI/BoxStorage.tga", &boxstorage, BoxStorageVertices, sizeof(BoxStorageVertices), NULL);
  create_rectangle("GUI/ObjGraphic.tga",  &ObjGraphic, ObjGraphicVertices,  sizeof(ObjGraphicVertices),  NULL);

}

//LOAD SHADER FUNCTION
GLuint LoadProgram(const char * const vertex_file_path, const char * Fragment_file_path){

  GLuint VertexShaderID = glCreateShader(GL_VERTEX_SHADER);
  GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);

  //READ THE VERTEX SHADER CODE
  string VertexShaderCode;
  ifstream VertexShaderStream(vertex_file_path, std::ios::in);
  if(VertexShaderStream.is_open())
  {
    string Line = "";
    while(getline(VertexShaderStream, Line))
      VertexShaderCode += "\n" + Line;
    VertexShaderStream.close();
  }

  //READ THE FRAGMENT SHADER CODE
  string FragmentShaderCode;
  ifstream FragmentShaderStream(Fragment_file_path, std::ios::in);
  if(FragmentShaderStream.is_open())
  {

    string Line = "";
    while(getline(FragmentShaderStream, Line))
      FragmentShaderCode += "\n" + Line;
    FragmentShaderStream.close();

  }

  GLint Result = GL_FALSE;
  int InfoLogLength;

  //Compile Vertex Shader
  printf("Compiling Shader : %s\n", vertex_file_path);
  char const * VertexSourcePointer = VertexShaderCode.c_str();
  glShaderSource(VertexShaderID,  1,  &VertexSourcePointer,  NULL);
  glCompileShader(VertexShaderID);

  //Check Vertex Shader
  glGetShaderiv(VertexShaderID, GL_COMPILE_STATUS,  &Result);
  glGetShaderiv(VertexShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
  vector<char> VertexShaderErrorMessage(InfoLogLength);
  glGetShaderInfoLog(VertexShaderID, InfoLogLength, NULL, &VertexShaderErrorMessage[0]);
  fprintf(stdout, "%s\n",  &VertexShaderErrorMessage[0]);

  //Compile Fragment Shader
  printf("Compiling Shader : %s\n",  Fragment_file_path);
  char const * FragmentSourcePointer = FragmentShaderCode.c_str();
  glShaderSource(FragmentShaderID, 1, &FragmentSourcePointer, NULL);
  glCompileShader(FragmentShaderID);

  //Check Fragment Shader
  glGetShaderiv(FragmentShaderID, GL_COMPILE_STATUS, &Result);
  glGetShaderiv(FragmentShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
  vector<char> FragmentShaderErrorMessage(InfoLogLength);
  glGetShaderInfoLog(FragmentShaderID, InfoLogLength, NULL, &FragmentShaderErrorMessage[0]);
  fprintf(stdout,  "%s\n",  &FragmentShaderErrorMessage[0]);

  fprintf(stdout,  "Linking Program\n");
  GLuint ProgramID = glCreateProgram();

  //Bind Attribute
  glBindAttribLocation(ProgramID, 0, "position");
  glBindAttribLocation(ProgramID, 1, "Texcoord0");

  //Link The Program
  glAttachShader(ProgramID, VertexShaderID);
  glAttachShader(ProgramID, FragmentShaderID);
  glLinkProgram(ProgramID);

  GLuint texture1;

  texture1 = glGetUniformLocation(ProgramID, "myTextureSampler");
  matrixuniform =  glGetUniformLocation(ProgramID, "myMatrix");
  translation = glGetUniformLocation(ProgramID, "TranslationMatrix");
   Rotation = glGetUniformLocation(ProgramID, "RotationMatrix");


  //Check The Program
  glGetProgramiv(ProgramID,  GL_LINK_STATUS, &Result);
  glGetProgramiv(ProgramID, GL_INFO_LOG_LENGTH, &InfoLogLength);
  vector<char> ProgramErrorMessage( max(InfoLogLength, int(1)) );
  fprintf(stdout,  "%s\n", &ProgramErrorMessage[0]);

  //Delete Shader
  glDeleteShader(VertexShaderID);
  glDeleteShader(FragmentShaderID);

  glUseProgram(ProgramID);

  //Return ProgramID
  return ProgramID;
}

/////////////////////////////////
//Create Rectangle Function
/////////////////////////////////
void create_rectangle(const char * const path, rectangle *r, const GLfloat *vertices, size_t byte_count, const GLfloat * transformation)
{

  glGenBuffers(1, &r->vbo);
  glBindBuffer(GL_ARRAY_BUFFER, r->vbo);
  glBufferData(GL_ARRAY_BUFFER, byte_count, vertices, GL_DYNAMIC_DRAW);
  r->textureID = load_texture(path);

}

void draw_rectangle(rectangle *r, const float *TranslationMatrix,  const float *RotationMatrix)
{

  /////////////////////////////////////////////////////
  //Object Graphic <Vertex Attributes/Bindings/Drawing>
  /////////////////////////////////////////////////////

  //Bind array buffer to Vertex Buffer Object
  glBindBuffer(GL_ARRAY_BUFFER, r->vbo);

  // "Bind" the newly created texture : all future texture functions will modify this texture
  glBindTexture(GL_TEXTURE_2D, r->textureID);

  //MenuContext Vertices cordinates
  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float),reinterpret_cast<const GLvoid *>(0 * sizeof(float)));

  //MenuContext Texture cordinates
  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 6 * sizeof(float),reinterpret_cast<const GLvoid *>(4 * sizeof(float)));

  //Enable Attribute for "index 1"
  glEnableVertexAttribArray(0);

  //Enable Attribute for "index 1"
  glEnableVertexAttribArray(1);

  //Get Matrix Values/Matrix
  glUniformMatrix4fv(matrixuniform, 1, TRUE, r->matrix);

  glUniformMatrix4fv(matrixuniform, 1, GL_FALSE, glm::value_ptr(ortho));

  glUniformMatrix4fv(translation, 1, TRUE, TranslationMatrix);

  glUniformMatrix4fv(Rotation, 1, TRUE, RotationMatrix);

  glDrawArrays(GL_QUADS, 0, 4);

  //END OF MOVE OBJ VERTEX

}

//Setup SDL/GLEW
void setup_sdl_glew (void)
{
  /////////////////////////////////////////////////////////////////////////////////////////////////

  //////////////////
  //SDL SETUP
  /////////////////

  //ENABLE SDL
  SDL_Init(SDL_INIT_EVERYTHING);

  //SCREEN POSITION
  SDL_putenv("SDL_VIDEO_CENTERED=center");

  //SCREEN SETUP
  Screen = SDL_SetVideoMode(SCREEN_WIDTH,SCREEN_HEIGHT,BPP,SDL_OPENGL|SDL_DOUBLEBUF);

  ortho = glm::ortho(0.0f, (float)SCREEN_WIDTH, 0.0f, (float)SCREEN_HEIGHT);

  //////////////////
  //GLEW SETUP
  /////////////////

  //GLEW SETUP
  GLenum err = glewInit();
  glGetError();

  //GLEW ERROR CHECKING
  if (GLEW_OK != err)
  {
    /* Problem: GlewInit failed, something is seriously wrong. */
    fprintf(stderr, "Error: %s\n", glewGetErrorString(err));

  }
  fprintf(stdout, "Status: Using GLEW %s\n", glewGetString(GLEW_VERSION));
  /////////////////////////////////////////////////////////////////////////////////////

}

///////////////////////
//ON AND OFF SWITCHES
//////////////////////

//ON AND OFF SWITCHES FOR APPLICATION
bool done = false;

bool MenuContextToggle = false;

bool BoxStorageToggle = false;

bool ObjGraphicToggle = false;

//Load Texture
int load_texture(const char * const path)
{

  GLuint textureID;

  SDL_Surface *surface = IMG_Load(path);

  // Create one OpenGL textureID
  glGenTextures(1, &textureID);

  // "Bind" the newly created textureID : all future textureID functions will modify r textureID
  glBindTexture(GL_TEXTURE_2D, textureID);

  // Give the image to OpenGL
  glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA, surface->w,surface->h, 0, GL_BGR, GL_UNSIGNED_BYTE, surface->pixels);

  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

  SDL_FreeSurface(surface);

  return textureID;
}

//Draw Function for arrays <VERTEX POSITION DRAWING>
void draw (void)
{
  draw_rectangle(&menubar, TranslationMatrix, RotationMatrix);
  draw_rectangle(&MainToolBox,  TranslationMatrix, RotationMatrix);

}

void ModelLoad(const char * path, int Index)
{

}

//Main Entry Point
int main(int argc , char *argv[])
{

  /////////////////
  //SETUP
  ////////////////

  //SDL and Glew
  setup_sdl_glew();

  /////////////////

  objsurface = IMG_Load("GUI/ObjGraphic.tga");
  ModelSurface = IMG_Load("GUI/Textures/model.tga");

  //Keyboard Setup
  Uint8 *keystate = SDL_GetKeyState(NULL);

  SDL_EnableKeyRepeat(100, SDL_DEFAULT_REPEAT_INTERVAL);

  //Setup Vertex Buffer Object
  setup_vbos();

  /////////////////////////////
  // OpenGL - Viewport Setup
  /////////////////////////////

  //Clear Color
  glClearColor(0.0,0.0,1.0,0.0);

  //View Port Setup
  glViewport(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);

  ////////////////////////////////////////////////////////////////////////////////////////////////////

  ////////////////
  //Load Shaders
  ////////////////

  //Load Shader Program
  LoadProgram("graphicaluserinterface.v", "graphicaluserinterface.f");

  ////////////////////////////////////////////////////////////////////////////////////////////////////

  int Mouse_X, Mouse_Y;

  glGenTextures(1, &ModelTexture);

  glBindTexture(GL_TEXTURE_2D, ModelTexture);

  glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA,  ModelSurface->w, ModelSurface->h, 0, GL_BGR, GL_UNSIGNED_BYTE, ModelSurface->pixels);

  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

  glGenBuffers(1, &vertexbuffer);

  glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);

  glBufferData(GL_ARRAY_BUFFER, 3 * sizeof(points), &points[0], GL_STATIC_DRAW);


  //Main While Loop
  while(!done)
  {
    //Get the X and Y Positions on Mouse Cursor and put it into Storage
    SDL_GetMouseState(&Mouse_X,&Mouse_Y);


    //Clear
    glClear(GL_COLOR_BUFFER_BIT);

    //Logic

    //draw <Basic GUI>
    draw();

    if(BoxStorageToggle == true)
    {


      draw_rectangle(&boxstorage, TranslationMatrix, RotationMatrix);

      //////////////////////////////
      //Directory Reading Proccess
      /////////////////////////////

      //File Path
      path p("Box Storage");

      //String vector container
      std::vector < std::string > list;

      ////////////////////////////

      //Iteration Loop
      try
      {
        for (directory_iterator it(p); it != directory_iterator(); ++it)
        {

          //Output it contents to CMD window
          //   cout << *it << endl;

          //find the it path names store it in s
          string s = (*it).path().string();

          //then push back list
          list.push_back( s );

        }

      }

      catch (const filesystem_error& ex)
      {
        //  cout << ex.what() << endl;
      }

      //Float Containers
      float row=0,column=0;
      float quad_width = -146.0f , quad_height = -100.0f;

      //iteration Loop
      for(int i=0;i<list.size();++i)
      {
        //if list is not at its full capacity
        if(list[i].find(".obj") != std::string::npos)
        {
          //every 6th quad, change row
          if(i % 6 == 0)
          {
            //beginning of a row
            column = 0;

            //row iteration
            ++row;
          }
           //Translation Process
      GLfloat RotationMatrix[] = {
        1.0, 0.0, 0.0, 0.0,
        0.0, 1.0, 0.0, 0.0,
        0.0, 0.0, 1.0, 0.0,
        0.0, 0.0, 0.0, 1.0
      };

          //Translation Process
          GLfloat TranslationMatrix[] = {
            1.0, 0.0, 0.0, 720.0+column*quad_width,
            0.0, 1.0, 0.0, 82.0+row*quad_height,
            0.0, 0.0, 1.0, 0.0,
            0.0, 0.0, 0.0, 1.0
          };

          //Send Translation Matrix up to the vertex shader
          glUniformMatrix4fv(translation, 1, TRUE, TranslationMatrix);

          glUniformMatrix4fv(Rotation, 1, TRUE, RotationMatrix);
          //Draw Rectangle to frustum
          draw_rectangle(&ObjGraphic, TranslationMatrix, RotationMatrix);
        }

        //column itearation
        ++column;

        //Index Assigners
        if(event.type == SDL_MOUSEBUTTONDOWN && SDL_BUTTON(SDL_BUTTON_LEFT))
        {
          //use Index Assigner
          int index = IndexAssigner(1, 1);

          //make a fileobject and store list and the index of that list in a c string
          ifstream file (list[index].c_str() );

         int face[4];

          //While FileObject not equal end of file
          while (!file.eof() )
          {

            char modelbuffer[2000000];

            file.getline(modelbuffer, 2000000);

            switch(modelbuffer[0])
            {

              cout << " " << endl;

              case 'v' :

              Point p;

              sscanf(modelbuffer, "v %f %f %f",  &p.x, &p.y, &p.z);

              points.push_back(p);

              cout << " p.x = " << p.x << " p.y = " << p.y << " p.z = " << p.x << endl;

              break;

              cout << " " << endl;

              case 'f':

              int read_count = sscanf(modelbuffer, "f %i %i %i %i", &face[0], &face[1], &face[2],  &face[3]);

              cout << "face[0] = " << face[0] << " face[1] = " << face[1] << " face[2] = " << face[2] << " face[3] = " << face[3] << "\n";

              if(read_count !=4)
              {

                cout << "bad/n"; throw std::exception();

              }

              faces.push_back(face[0] - 1);
              faces.push_back(face[1] - 1);
              faces.push_back(face[2] - 1);
              faces.push_back(face[3] - 1);

              cout << face[0] - 1 << face[1] - 1 << face[2] - 1 << face[3] - 1 << endl;

            }

            cout << " " << endl;


            //Turn on ModelRender
            ModelRender = true;


          }

          for(std::vector<unsigned int>::iterator i = faces.begin(); i != faces.end(); ++i){ cout << *i; } cout << "\n";

        }

      }

    }


    //If ModelRender is On
    if(ModelRender == true)
    {

      glBindTexture(GL_TEXTURE_2D, ModelTexture);

      //Enable Attribute for "index 0"
      glEnableVertexAttribArray(0);

      //Enable Attribute for "index 1"
      glEnableVertexAttribArray(1);

      glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);

      //Model Vertices cordinates
      glVertexAttribPointer(0, 0, GL_INT, GL_FALSE,0,0);

      //Model Texture cordinates
      glVertexAttribPointer(1, 0, GL_FLOAT, GL_FALSE,0,0);

           //Translation Process
  GLfloat RotationMatrix[] = {
        1.0, 0.0, 0.0, 0.0,
        0.0, 1.0, 0.0, 0.0,
        0.0, 0.0, 1.0, 0.0,
        0.0, 0.0, 0.0, 1.0
 };


      //Translation Process
      GLfloat TranslationMatrix[] = {
        1.0, 0.0, 0.0, 0.0,
        0.0, 1.0, 0.0, 0.0,
        0.0, 0.0, 1.0, 1.0,
        0.0, 0.0, 0.0, 1.0
      };

      //Send Translation Matrix up to the vertex shader
      glUniformMatrix4fv(translation, 1, TRUE, TranslationMatrix);

      //Send Rotation Matrix up to the vertex shader
      glUniformMatrix4fv(Rotation, 1, TRUE, RotationMatrix);

      glDrawElements( GL_QUADS, faces.size(), GL_UNSIGNED_INT, reinterpret_cast<GLvoid*>(&faces[0]));

    }



    //Turn of Menu Context Toggle
    if(keystate[SDLK_SPACE])
    {

      MenuContextToggle = false;

    }

    //Turn on Box Storage
    if(keystate[SDLK_b])
    {

      BoxStorageToggle = true;

    }

    ///////////////////////////////////////////


    /////////////////////////////////////////////////////////////////

    ///////////////////////
    //Menu Context <SETUP>
    //////////////////////

    ///////////////////////////////////////////////////////////////

    //SDL EVENT QUEUE
    while(SDL_PollEvent(&event))
    {
      switch(event.type)
      {

        //if User Presses Quit Button
        case SDL_QUIT:
          return 0;
          break;

          /////////////////////////////////////////////

          ////////////////
          //MOUSE EVENTS
          ///////////////

        case SDL_MOUSEBUTTONDOWN:

          if(Mouse_X <= 15, Mouse_Y <= 30)
          {

            MenuContextToggle = true;

          }

          ///////////////////////////////////////////////

      }

    }
    //Update
    SDL_GL_SwapBuffers();
  }

}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////