So I've coded a model loader in OpenGL, and, it does in fact loads models, but for some reason, I can't see the resulting triangle on the screen. Take a look for yourself:

```
#define GLEW_STATIC

#include <GL\glew.h>    // Graphics Libraries
#include <GLFW\glfw3.h>

#include <iostream>
#include <fstream>
#include <vector>
#include <string>

int main()
{
    std::cout << "Please enter the name of the mesh file: ";
    std::string FileName;
    std::cin >> FileName;

    std::cout << "You entered: " << FileName << std::endl;

    if (!glfwInit())
    {
        std::cout << "Failed to initialize GLFW" << std::endl;
        system("Pause");
        return EXIT_FAILURE;
    }

    std::cout << "GLFW 3.0.4 Initialized" << std::endl;

    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);

    GLFWwindow* Window = glfwCreateWindow(800, 600, "Window", NULL, NULL);
    glfwMakeContextCurrent(Window);

    if (Window == NULL)
    {
        std::cout << "Failed to create an OpenGL 3.3 context" << std::endl;
        system("Pause");
        return EXIT_FAILURE;
    }

    std::cout << "Created an OpenGL 3.3 context" << std::endl;

    glewExperimental = GL_TRUE; 

    if (glewInit() != GLEW_OK)
    {
        std::cout << "Failed to initialize GLEW 1.11.0" << std::endl;
        system("Pause");
        return EXIT_FAILURE;
    }

    std::ifstream FileStream(FileName);
    std::vector <float> Vertices;

    if (!FileStream)
    {
        std::cout << "An error was encountered while opening "<< FileName << std::endl;
        system("Pause");
        return EXIT_FAILURE;
    }

    float coordinateX, coordinateY, coordinateZ;
    std::string Character;

    while (!FileStream.eof())
    {
        FileStream >> Character;

        if (Character == "v")
        {
            FileStream >> coordinateX >> coordinateY >> coordinateZ;
            std::cout << "Loading in " << coordinateX << " " << coordinateY << " " << coordinateZ << std::endl;
            Vertices.push_back(coordinateX);
            Vertices.push_back(coordinateY);
            Vertices.push_back(coordinateZ);
        }

        else
        {
            std::cout << "Skipping " << Character << std::endl;
            continue;
        }
    }

    std::cout << "Loaded " << FileName << std::endl;

    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LESS);

    unsigned int VBO;
    glGenBuffers(1, &VBO);
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(float) * Vertices.size(), &Vertices.front(), GL_STATIC_DRAW);

    unsigned int VAO;
    glGenVertexArrays(1, &VAO);
    glBindVertexArray(VAO);
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);

    const char* Vertex_Shader =
        "#version 330\n"
        "in vec3 vp;"
        "void main () {"
        "  gl_Position = vec4 (vp, 1.0);"
        "}";

    const char* Fragment_Shader =
        "#version 330\n"
        "out vec4 frag_colour;"
        "void main () {"
        "  frag_colour = vec4 (0.5, 0.0, 0.5, 1.0);"
        "}";

    unsigned int VertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(VertexShader, 1, &Vertex_Shader, NULL);
    glCompileShader(VertexShader);

    unsigned int FragmentShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(FragmentShader, 1, &Fragment_Shader, NULL);
    glCompileShader(FragmentShader);

    unsigned int Shader_Program = glCreateProgram();
    glAttachShader(Shader_Program, FragmentShader);
    glAttachShader(Shader_Program, VertexShader);
    glLinkProgram(Shader_Program);

    while (!glfwWindowShouldClose(Window))
    {

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glUseProgram(Shader_Program);
        glBindVertexArray(VAO);
        glDrawArrays(GL_TRIANGLES, 0, Vertices.size());

        glfwPollEvents();
        glfwSwapBuffers(Window);
    }

    return EXIT_SUCCESS;
}

```

And the loaded file is as follows:

```
v 0.0 0.5 0.0
v 0.5 -0.5 0.0
v -0.5 -0.5 0.0

```