main.cpp

#include <stdio.h>
#include <iostream>
#include <string>
#include <fstream>

#include <GL\glew.h>
#include <GLFW\glfw3.h>

std::string loadFileToString(const char* filePath) {
    std::string fileData;
    std::fstream stream(filePath, std::ios::in);
    if (stream.is_open()) {
        std::string line = "";
        while (getline(stream, line)) {
            fileData += "\n" + line;
        }
        stream.close();
    }
    return fileData;
}

GLuint loadShaders(const char* vertShaderPath, const char* fragShaderPath) {
    GLuint vertShader = glCreateShader(GL_VERTEX_SHADER);
    GLuint fragShader = glCreateShader(GL_FRAGMENT_SHADER);
    std::string vertShaderSource = loadFileToString(vertShaderPath);
    std::string fragShaderSource = loadFileToString(fragShaderPath);
    const char* rawVertShader = vertShaderSource.c_str();
    const char* rawFragShader = fragShaderSource.c_str();
    glShaderSource(vertShader, 1, &rawVertShader, NULL);
    glShaderSource(fragShader, 1, &rawFragShader, NULL);
    glCompileShader(vertShader);
    glCompileShader(fragShader);
    GLuint program = glCreateProgram();
    glAttachShader(program, vertShader);
    glAttachShader(program, fragShader);
    glLinkProgram(program);
    return program;
}

int main(int argc, char** argv) {
    if (!glfwInit()) { //Init GLFW
        fprintf(stderr, "GLFW failed to init.");
        return -1;
    }

    glfwWindowHint(GLFW_SAMPLES, 4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    GLFWwindow* window;
    window = glfwCreateWindow(640, 480, "3D Game", NULL, NULL);
    if (!window) {
        fprintf(stderr, "Failed to create window.");
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);

    glewExperimental = true;
    if (glewInit() != GLEW_OK) {
        fprintf(stderr, "GLEW failed to init.");
        glfwTerminate();
        return -1;
    }

    GLuint vaoID;
    glGenVertexArrays(1, &vaoID);
    glBindVertexArray(vaoID);

    static const GLfloat verts[] = {
        //X,     Y,    Z
        -1.0f, -1.0f, 0.0f,
         1.0f, -1.0f, 0.0f,
         0.0f,  1.0f, 0.0f
    };

    GLuint program = loadShaders("shader.vsh", "shader.fsh");

    GLuint vboID;
    glGenBuffers(1, &vboID);
    glBindBuffer(GL_ARRAY_BUFFER, vboID);
    glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW);

    while (!glfwWindowShouldClose(window)) {
        glEnableVertexAttribArray(0);
        glBindBuffer(GL_ARRAY_BUFFER, vboID);
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
        glUseProgram(program);
        glDrawArrays(GL_TRIANGLES, 0, 3);
        glDisableVertexAttribArray(0);

        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    glfwTerminate(); //Terminate GLFW.
    return 0;
}