#include <glew.h>
#include <freeglut.h>
#include <iostream>
#include <fstream>
#include <string>


using namespace std;


GLuint vbo, shader, vs, ps;


GLfloat verts[] =
{
    0.75f, 0.75f, 0.0f, 1.0f,
    0.75f, -0.75f, 0.0f, 1.0f,
    -0.75f, -0.75f, 0.0f, 1.0f,
};


GLuint CreateShader(GLenum type, const char* src);
GLuint CreateProgram(GLuint vs, GLuint ps);


void init()
{
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, 12 * sizeof(GLfloat), verts, GL_STATIC_DRAW);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(0);


ifstream f1, f2;
string   v,  p, tmp;


f1.open("v.vert");
f2.open("f.frag");


if(!f1.is_open() || !f2.is_open())
{
glDeleteBuffers(1, &vbo);
exit(1);
}


while(!f1.eof())
{
std::getline(f1, tmp);


v += tmp + "\n";


tmp.clear();
}


while(!f2.eof())
{
std::getline(f2, tmp);


p += tmp + "\n";


tmp.clear();
}


vs     = CreateShader(GL_VERTEX_SHADER, v.c_str());
ps     = CreateShader(GL_FRAGMENT_SHADER, p.c_str());
shader = CreateProgram(vs, ps);


if(shader == -1) 
{
glDeleteBuffers(1, &vbo);
glDeleteShader(vs);
glDeleteShader(ps);


exit(1);
}


glUseProgram(shader);
glDeleteShader(vs);
glDeleteShader(ps);


f1.close();
f2.close();
}




void display()
{
glClearColor(1.0f, 1.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
glDrawArrays(GL_TRIANGLES, 0, 3);
glFlush();
glutSwapBuffers();
}


int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA);
glutInitWindowSize(512, 512);
glutInitContextVersion(4, 3);
glutInitContextProfile(GLUT_CORE_PROFILE);
glutCreateWindow(argv[0]); 


if(glewInit())
{
return 0;
}


init();


glutDisplayFunc(display);
glutMainLoop();


return 0;
}


GLuint CreateShader(GLenum type, const GLchar* src)
{
GLuint res = glCreateShader(type);
GLint compileStatus;


glShaderSource(res, 1, &src, nullptr);
glCompileShader(res);
glGetShaderiv(res, GL_COMPILE_STATUS, &compileStatus);


if(compileStatus == GL_FALSE)
{
GLint   infoLength;
GLchar *infoLog = nullptr;


glGetShaderiv(res, GL_INFO_LOG_LENGTH, &infoLength);


infoLog = new GLchar[infoLength + 1];


glGetShaderInfoLog(res, infoLength, nullptr, infoLog);


cout << infoLog << endl;


delete []infoLog;
}


return res;
}


GLuint CreateProgram(GLuint vs, GLuint fs)
{
GLuint prog = glCreateProgram();
GLint status;


glAttachShader(prog, vs);
glAttachShader(prog, ps);
glLinkProgram(prog);
glGetProgramiv(prog, GL_LINK_STATUS, &status);
glDetachShader(prog, vs);
glDetachShader(prog, fs);


if(status == GL_FALSE) 
{
return -1;
}


return prog;
}

#version 430 core


out vec4 outColor;


void main()
{
outColor = vec4(1.0f, 1.0f, 1.0f, 1.0f);
}

#include <iostream>
#include <glew.h>
#include <glfw3.h>


GLfloat clearColor[] = { 1.0f, 1.0f, 1.0f, 1.0f };
GLuint vertexShader, fragmentShader, shaderProgram, vbo;


GLfloat vertices[] = { 0.0f, 0.5f, 
  0.5f, 0.0f, 
 -0.5f, 0.0f };


GLuint CreateShader(GLenum type, const GLchar* src);
GLuint CreateProgram(GLuint vShader, GLuint fShader);


void InitScene()
{
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);


GLchar vsrc[] = { "#version 430 core   \n"
 "layout(location = 0) in vec4 position; \n"
 "void main() {                          \n"
 "gl_Position = position;                \n"
 "}                                      \n" };


GLchar fsrc[] = { "#version 430 core    \n"
 "out vec4 resColor;    \n"
 "void main() {    \n"
 "resColor = vec4(1.0f, 0.0f, 0.0f, 1.0f);\n"
 "}    \n" };


vertexShader   = CreateShader(GL_VERTEX_SHADER, vsrc);
fragmentShader = CreateShader(GL_FRAGMENT_SHADER, fsrc);
shaderProgram  = CreateProgram(vertexShader, fragmentShader);


if(shaderProgram == -1) 
{
std::getchar();
exit(1);
}


glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
}


void ResizeCallback(GLFWwindow* wnd, int width, int height)
{
glViewport(0, 0, width, height);
}


void Draw()
{
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(0);
glUseProgram(shaderProgram);


glClearBufferfv(GL_COLOR, 0, clearColor);
glDrawArrays(GL_TRIANGLES, 0, 3);
glFlush();


glBindBuffer(GL_ARRAY_BUFFER, 0);
glUseProgram(0);
}


void Terminate()
{
glDeleteBuffers(1, &vbo);
glDeleteProgram(shaderProgram);
}


int main(int argc, char** argv)
{
if(!glfwInit()) return 0;


GLFWwindow* wnd = glfwCreateWindow(640, 480, "Hello triangle", nullptr, nullptr);


if(!wnd) 
{
glfwTerminate();
return 0;
}


glfwMakeContextCurrent(wnd);
glewExperimental = true;


if(glewInit() != GLEW_OK)
{
glfwTerminate();
return 0;
}


glfwSetWindowSizeCallback(wnd, ResizeCallback);


InitScene();


while(!glfwWindowShouldClose(wnd))
{
Draw();
glfwSwapBuffers(wnd);
glfwPollEvents();
}


Terminate();


glfwDestroyWindow(wnd);
glfwTerminate();


return 0;
}


GLuint CreateProgram(GLuint vShader, GLuint fShader)
{
GLuint p = glCreateProgram();


glAttachShader(p, vShader);
glAttachShader(p, fShader);
glLinkProgram(p);


GLint status;


glGetProgramiv(p, GL_LINK_STATUS, &status);


if(status == GL_FALSE)
{
glGetProgramiv(p, GL_INFO_LOG_LENGTH, &status);


GLchar* infoLog = new GLchar[status + 1];


glGetProgramInfoLog(p, status, nullptr, infoLog);


std::cout << "Program error: \n" << infoLog << "\n";


return -1;
}


return p;
}


GLuint CreateShader(GLenum type, const GLchar* src)
{
GLuint s      = glCreateShader(type);
GLint  status = 0;


glShaderSource(s, 1, &src, nullptr);
glCompileShader(s);
glGetShaderiv(s, GL_COMPILE_STATUS, &status);


if(status == GL_FALSE)
{
glGetShaderiv(s, GL_INFO_LOG_LENGTH, &status);


GLchar* infoLog = new GLchar[status + 1];


glGetShaderInfoLog(s, status, nullptr, infoLog);


switch(type)
{
case GL_VERTEX_SHADER:   std::cout << "Vertex shader error: \n";   break;
case GL_FRAGMENT_SHADER: std::cout << "Fragment shader error: \n"; break;
}


std::cout << infoLog << "\n";


delete []infoLog;


return -1;
}


return s;
}