Untitled

//////////////////////////////
//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"
////////////////////////////
using namespace std;
///////////////////////////
//DEFINES
///////////////////////////
#define SCREEN_WIDTH  1240
#define SCREEN_HEIGHT 960
#define BPP 32
#define GL_GLEXT_PROTOTYPES
#define GetError( )\
        {\
            for ( GLenum Error = glGetError( ); ( GL_NO_ERROR != Error ); Error = glGetError( ) )\
            {\
                switch ( Error )\
                {\
                    case GL_INVALID_ENUM:      printf( "\n%s\n\n", "GL_INVALID_ENUM"      ); assert( 0 ); break;\
                    case GL_INVALID_VALUE:     printf( "\n%s\n\n", "GL_INVALID_VALUE"     ); assert( 0 ); break;\
                    case GL_INVALID_OPERATION: printf( "\n%s\n\n", "GL_INVALID_OPERATION" ); assert( 0 ); break;\
                    case GL_OUT_OF_MEMORY:     printf( "\n%s\n\n", "GL_OUT_OF_MEMORY"     ); assert( 0 ); break;\
                    default:                                                                              break;\
                }\
            }\
        }

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


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


            //Load Shader Function
            GLuint LoadProgram(const char * 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");


            //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);


                    ///////////////////////////////////
                   // Uniforms <SETUP>
                  //////////////////////////////////

                //glUniform3f(texture1, 2.0, -10.0, 1.0);


            //Return ProgramID
             return ProgramID;


            }


                  //Draw Function for arrays
                  void draw (void)
                  {
                    //Drawing ToolBar
                    glDrawArrays(GL_QUADS, 0, 6);

                    //Drawing MainToolBox
                    glDrawArrays(GL_QUADS, 5, 6);


                  }


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

          //////////////////
          //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);

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

            //////////////////
           //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 Switch for Application
            bool done = false;

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

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

            //SDL Event
            SDL_Event event;

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

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


            //Container for Virtual Array Object
            GLuint vao;

            //Containers for Virtual Buffer Object
            GLuint vbo;
            GLuint vbo2;

            //Texture Sampler
            GLint myTextureSampler;

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


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

             //////////////////
            //IMAGE LOADING
           //////////////////


            //Top File Menu <Top ToolBar>
           SDL_Surface *TopFileMenuSurf = NULL;

           TopFileMenuSurf = IMG_Load("GUI/FileMenu.tga");

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

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

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

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

                             //ToolBar
                             1.0f,  1.0f,  0.0f, 1.0f, 1.0f, 0.0f,
                             -1.0f,  1.0f, 0.0f, 1.0f, 0.0f, 0.0f,
                             -1.0f,  0.94f, 0.0f, 1.0f, 0.0f, 1.0f,
                             1.0f,   0.94f, 0.0f, 1.0f, 1.0f, 1.0f,

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

                                         //Main ToolBox
                             // x     y       z   w       X    Y
                             10.0f, 5.0f, 0.0f, 0.0f, 0.0f, 0.0f,
                             -1.0f,  5.0f, 0.0f, 0.0f, 0.0f, 0.0f,
                             -1.0f, 10.0f, 0.0f, 0.0f, 0.0f, 0.0f,
                             10.0f, 10.0f, 0.0f, 0.0f, 0.0f, 0.0f


                   };


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

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


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

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


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


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


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

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

                    ///////////////////////////////////
                   // Vertex Array Object <SETUP>
                  //////////////////////////////////

                  //Generate Vertex Array Object
                  glGenVertexArrays(1, &vao);


                  //Bind Vertex Array Object as the current used object
                  glBindVertexArray(vao);

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

                    ///////////////////////////////////
                   // Vertex Buffer Object <SETUP>
                  //////////////////////////////////

                  //Generate Vertex Buffer Object
                  glGenBuffers(1, &vbo);


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

                  //Give data to Vertex Buffer Object
                  glBufferData(GL_ARRAY_BUFFER, sizeof(GUIVertices), GUIVertices, GL_DYNAMIC_DRAW);

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

                    ///////////////////////////////////
                   // Attributes <SETUP>
                  //////////////////////////////////

                  //<INDEX GOES UP FOR EACH ATTRIBUTE THATS ONE MORE INDEX TO ADD TO CURRENT INDEX COUNT >//

                  //Set up Attribute for "index 0"  ToolBar?
                  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(float)*6, 0);

                  //Texture Cordinates for ToolBar
                  glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float),reinterpret_cast<const GLvoid *>(4 * sizeof(float)));

                  //Main ToolBox
                  glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float),reinterpret_cast<const GLvoid *>(5 * sizeof(float)));


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

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

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


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

                    ///////////////////////////////////
                   // Textures <SETUP>
                  //////////////////////////////////

                  ////////////////////////////////////////
                  //Top File Menu Bar Texture Loading
                  ///////////////////////////////////////

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

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

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

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

                  glActiveTexture(GL_TEXTURE0);


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


          //Main While Loop
          while(!done)
          {


             //Clear
             glClear(GL_COLOR_BUFFER_BIT);


             //Logic


            //draw
            draw();


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

                 case SDL_QUIT:
                   return 0;
                   break;
                  }


                }


                     //Update
                     SDL_GL_SwapBuffers();


          }


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


        }