SFML&OpenGL

#include <GL/glew.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <SFML\OpenGL.hpp>
#include <SFML\Graphics.hpp>
#include <fstream>
#include <string>
#include <vector>

GLuint CompileShader (const char *pszVertexFile, const char *pszFragmentFile)
    {
        bool bOk = true;
        GLint iResult = GL_FALSE;
        int iInfoLogLength;
        GLuint uiProgramID = -1;

        // Output some info
        const unsigned char* version = (const unsigned char*)glGetString(GL_SHADING_LANGUAGE_VERSION);
        printf("SHADER: Running GLSL Version %s\n",version);

        // Create the shaders
        GLuint uiVertexShaderID = glCreateShader(GL_VERTEX_SHADER);
        GLuint uiFragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);

        bOk = uiVertexShaderID != 0 && uiFragmentShaderID != 0;

        // Read the Vertex Shader code from the file
        std::string sVertexShaderCode;
        if (bOk)
        {
            std::ifstream ifsVertexShaderStream(pszVertexFile, std::ios::in);
            if(ifsVertexShaderStream.is_open())
            {
                std::string sLine = "";
                while(getline(ifsVertexShaderStream, sLine))
                    sVertexShaderCode += "\n" + sLine;
                ifsVertexShaderStream.close();
            }
            else
            {
                bOk = false;
            }
        }

        // Read the Fragment Shader code from the file
        std::string FragmentShaderCode;
        if (bOk)
        {
            std::ifstream FragmentShaderStream(pszFragmentFile, std::ios::in);
            if(FragmentShaderStream.is_open())
            {
                std::string sLine = "";
                while(getline(FragmentShaderStream, sLine))
                    FragmentShaderCode += "\n" + sLine;
                FragmentShaderStream.close();
            }
            else
            {
                bOk = false;
            }
        }

        if (bOk)
        {
            // Compile Vertex Shader
            printf("SHADER: Compiling vertex shader '%s'\n", pszVertexFile);
            char const * VertexSourcePointer = sVertexShaderCode.c_str();
            glShaderSource(uiVertexShaderID, 1, &VertexSourcePointer , NULL);
            glCompileShader(uiVertexShaderID);

            // Check Vertex Shader
            glGetShaderiv(uiVertexShaderID, GL_COMPILE_STATUS, &iResult);
            glGetShaderiv(uiVertexShaderID, GL_INFO_LOG_LENGTH, &iInfoLogLength);
            std::vector<char> VertexShaderErrorMessage(iInfoLogLength);
            glGetShaderInfoLog(uiVertexShaderID, iInfoLogLength, NULL, &VertexShaderErrorMessage[0]);

            bOk = strlen(&VertexShaderErrorMessage[0]) == 0;
        }

        if (bOk)
        {
            // Compile Fragment Shader
            printf("SHADER: Compiling fragment shader '%s'\n", pszFragmentFile);
            char const * FragmentSourcePointer = FragmentShaderCode.c_str();
            glShaderSource(uiFragmentShaderID, 1, &FragmentSourcePointer , NULL);
            glCompileShader(uiFragmentShaderID);

            // Check Fragment Shader
            glGetShaderiv(uiFragmentShaderID, GL_COMPILE_STATUS, &iResult);
            glGetShaderiv(uiFragmentShaderID, GL_INFO_LOG_LENGTH, &iInfoLogLength);
            std::vector<char> FragmentShaderErrorMessage(iInfoLogLength);
            glGetShaderInfoLog(uiFragmentShaderID, iInfoLogLength, NULL, &FragmentShaderErrorMessage[0]);

            bOk = strlen(&FragmentShaderErrorMessage[0]) == 0;
        }

        if (bOk)
        {
            // Link the program
            printf("SHADER: Linking shader to program\n");
            uiProgramID = glCreateProgram();
            glAttachShader(uiProgramID, uiVertexShaderID);
            glAttachShader(uiProgramID, uiFragmentShaderID);
            glLinkProgram(uiProgramID);

            // Check the program
            glGetProgramiv(uiProgramID, GL_LINK_STATUS, &iResult);
            glGetProgramiv(uiProgramID, GL_INFO_LOG_LENGTH, &iInfoLogLength);
            std::vector<char> ProgramErrorMessage(std::max(iInfoLogLength, int(1)) );
            glGetProgramInfoLog(uiProgramID, iInfoLogLength, NULL, &ProgramErrorMessage[0]);

            bOk = strlen(&ProgramErrorMessage[0]) == 0;
        }

        if (bOk)
        {
            // Delete temp shaders
            glDeleteShader(uiVertexShaderID);
            glDeleteShader(uiFragmentShaderID);

            // Flush
            glFlush();
        }

        return (bOk ? uiProgramID : -1);
    }


void renderingThread(sf::RenderWindow* window)
{
    // activate the window's context on this thread
    window->setActive(true);

    // Create and compile shader
    GLuint programID = CompileShader( "Basic.vertexshader", "Basic.fragmentshader" );

    // Get a handle for our "MVP" uniform
    GLuint MatrixID = glGetUniformLocation(programID, "MVP");

    // Projection matrix : 45° Field of View, 4:3 ratio, display range : 0.1 unit <-> 100 units
    glm::mat4 Projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.0f);

    // Camera matrix
    glm::mat4 View       = glm::lookAt(
        glm::vec3(4,3,3), // Camera is at (4,3,3), in World Space
        glm::vec3(0,0,0), // and looks at the origin
        glm::vec3(0,1,0)  // Head is up
    );

    // Model matrix : an identity matrix (model will be at the origin)
    glm::mat4 Model      = glm::mat4(1.0f);  // Changes for each model !

    // Our ModelViewProjection : multiplication of our 3 matrices
    glm::mat4 MVP        = Projection * View * Model; // Remember, matrix multiplication is the other way around

    // Create triangle
    static const GLfloat g_vertex_buffer_data[] = {
        -1.0f, -1.0f, 0.0f,
         1.0f, -1.0f, 0.0f,
         0.0f,  1.0f, 0.0f,
    };
    GLuint vertexbuffer;
    glGenBuffers(1, &vertexbuffer);
    glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data), g_vertex_buffer_data, GL_STATIC_DRAW);


    // the rendering loop
    float lastTime = 0.f;
    sf::Clock clock;
    while (window->isOpen())
    {
        // Clear buffers
        glClearColor(1, 0, 0, 1);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        // Use our shader
        glUseProgram(programID);

        // Send our transformation to the currently bound shader, in the "MVP" uniform
        glUniformMatrix4fv(MatrixID, 1, GL_FALSE, &MVP[0][0]);

        // 1rst attribute buffer : vertices
        glEnableVertexAttribArray(0);
        glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
        glVertexAttribPointer(
            0,                  // attribute 0. No particular reason for 0, but must match the layout in the shader.
            3,                  // size
            GL_FLOAT,           // type
            GL_FALSE,           // normalized?
            0,                  // stride
            (void*)0            // array buffer offset
        );

        // Draw the triangle
        glDrawArrays(GL_TRIANGLES, 0, 3); // Starting from vertex 0; 3 vertices total -> 1 triangle

        // Disable attribute
        glDisableVertexAttribArray(0);

        glUseProgram(NULL);


            // draw 2D (NO WORKING)
        window->pushGLStates(); //save the current OpenGL state
        window->resetGLStates();

        sf::CircleShape shape(50);
        shape.setFillColor(sf::Color(0, 255, 0));
        window->draw(shape);

        window->popGLStates();

        // end the current frame
        window->display();
    }

    // Cleanup VBO
    glDeleteBuffers(1, &vertexbuffer);
    glDeleteProgram(programID);
}

int main()
{
    // Create OpenGL 3.3 context and window
    sf::ContextSettings settings;
    settings.depthBits = 24;
    settings.stencilBits = 8;
    settings.antialiasingLevel = 4;
    settings.majorVersion = 3;
    settings.minorVersion = 3;

        // create the window (remember: it's safer to create it in the main thread due to OS limitations)
        sf::RenderWindow window(sf::VideoMode(800, 600, 32), "OpenGL + SFML", sf::Style::Default, settings);

    // Window default options
    window.setVerticalSyncEnabled(true);
    window.setMouseCursorVisible(true);
    window.setFramerateLimit(60);
    window.setVisible(true);

        // deactivate its OpenGL context
        window.setActive(false);

    // Init GLEW (OpenGL Extension Wrangler Library)
    glewExperimental = GL_TRUE;     // ensures that all extensions with valid entry points will be exposed
    bool bOk = (glewInit() == GLEW_OK);
    printf("NFO: Using GLEW %s\n", glewGetString(GLEW_VERSION));

    // Enable depth test (to avoid back triangles to be drawn in first plane)
    glEnable(GL_DEPTH_TEST);

    // Accept fragment if it closer to the camera than the former one
    glDepthFunc(GL_LESS);

    // Create a VAO (Vertex Array Object)
    GLuint m_uiVertexArrayID;
    glGenVertexArrays(1, &m_uiVertexArrayID);
    glBindVertexArray(m_uiVertexArrayID);

    glFlush();

        // launch the rendering thread
        sf::Thread thread(&renderingThread, &window);
        thread.launch();

        // the event/logic/whatever loop
        while (window.isOpen())
        {
        sf::Event event;
            while (window.pollEvent(event))
            {
                    // "close requested" event: we close the window
                if (event.type == sf::Event::Closed)
                        window.close();
            }
        }

    thread.wait();

    glDeleteVertexArrays(1, &m_uiVertexArrayID);
        return 0;
}


/*

BASIC.VERTEXSHADER
-----------------------------------------------------------------------------

#version 330 core

uniform mat4 MVP;
layout(location = 0) in vec3 modelVertices;

void main()
{
    gl_Position =  MVP * vec4(modelVertices, 1);
}


BASIC.FRAGMENTSHADER
-----------------------------------------------------------------------------
#version 330 core

out vec4 color;

void main()
{
    color = vec4 (1.0f, 1.0f, 1.0f, 1.0f);
}
*/