title: OpenGL - Triangle with a shader isn't showing
body: <p>This program builds with no problem, and the executable starts up, but no triangle shows up. I am following a GLSL tutorial where a Shader class is made to handle GLSL files.</p>
  
  <p>Shader.h</p>
  
  <pre><code>#ifndef SHADER_H_
  #define SHADER_H_
  
  #include &lt;GL/glew.h&gt;
  #include &lt;GL/glfw.h&gt;
  #include &lt;string&gt;
  
  class Shader {
  
      public:
          Shader();
          Shader(const char *vsFile, const char *fsFile);
          ~Shader();
          void init(const char *vsFile, const char *fsFile);
          void bind();
          void unbind();
          unsigned int id();
  
      private:
          unsigned int shader_id;
          unsigned int shader_vp;
          unsigned int shader_fp;
  };
  
  #endif // SHADER_H_
  </code></pre>
  
  <p>Shader.cpp</p>
  
  <pre><code>#include "Shader.h"
  #include &lt;cstring&gt;
  #include &lt;iostream&gt;
  #include &lt;ftream&gt;
  #include &lt;cstdlib&gt;
  using namespace std;
  
  static char* textFileRead(const char *fileName) {
      char* text;
  
      if (fileName != NULL) {
          FILE *file = fopen(fileName, "rt");
  
          if (file != NULL) {
              fseek(file, 0, SEEK_END);
              int count = ftell(file);
              rewind(file);
  
              if (count &gt; 0) {
                  text = (char*)malloc(sizeof(char) * (count + 1));
                  count = fread(text, sizeof(char), count, file);
                  text[count] = '\0';
              }
              fclose(file);
          }
      }
      return text;
  }
  
  Shader::Shader() {}
  
  Shader::Shader(const char *vsFile, const char *fsFile)
  {
      init(vsFile, fsFile);
  }
  
  void Shader::init(const char *vsFile, const char *fsFile)
  {
      shader_vp = glCreateShader(GL_VERTEX_SHADER);
      shader_fp = glCreateShader(GL_FRAGMENT_SHADER);
  
      const char *vsText = textFileRead(vsFile);
      const char *fsText = textFileRead(fsFile);
  
      if (vsText == NULL || fsText == NULL)
      {
          cerr &lt;&lt; "Either vertex shader or fragment shader file is not found" &lt;&lt; endl;
          return;
      }
  
      glShaderSource(shader_vp, 1, &amp;vsText, 0);
      glShaderSource(shader_fp, 1, &amp;fsText, 0);
  
      glCompileShader(shader_vp);
      glCompileShader(shader_fp);
  
      shader_id = glCreateProgram();
      glAttachShader(shader_id, shader_fp);
      glAttachShader(shader_id, shader_vp);
      glLinkProgram(shader_id);
  }
  
  Shader::~Shader()
  {
      glDetachShader(shader_id, shader_fp);
      glDetachShader(shader_id, shader_vp);
  
      glDeleteShader(shader_fp);
      glDeleteShader(shader_vp);
      glDeleteShader(shader_id);
  }
  
  unsigned int Shader::id()
  {
      return shader_id;
  }
  
  void Shader::bind()
  {
      glUseProgram(shader_id);
  }
  
  void Shader::unbind()
  {
      glUseProgram(0);
  }
  </code></pre>
  
  <p>Main.cpp</p>
  
  <pre><code>#include "Shader.h"
  #include &lt;cstdlib&gt;
  #include &lt;iostream&gt;
  using namespace std;
  
  Shader shader;
  
  void init()
  {
      glEnable(GL_DEPTH_TEST);
      glDepthFunc(GL_LESS);
  
      shader.init("shader.vert", "shader.frag");
  }
  
  void resize(int w, int h)
  {
      glViewport(0, 0, (GLsizei)w, (GLsizei)h);
      glMatrixMode(GL_PROJECTION);
      glLoadIdentity();
      gluPerspective(60, (GLfloat)w / (GLfloat)h, 1.0, 100.0);
      glMatrixMode(GL_MODELVIEW);
  }
  
  int main()
  {
      int running = GL_TRUE;
  
      // init GLFW
      if (!glfwInit())
          exit(EXIT_FAILURE);
  
      if (!glfwOpenWindow(300, 300, 0, 0, 0, 0, 0, 0, GLFW_WINDOW))
      {
          glfwTerminate();
          exit(EXIT_FAILURE);
      }
  
      glfwSetWindowTitle("ohhai.");
      glfwSetWindowSizeCallback(resize);
  
      /* CHECK GLEW */
      GLenum err = glewInit();
      if (GLEW_OK != err)
      {
          /* Problem: glewInit failed, something is seriously wrong. */
          cout &lt;&lt; "Error: " &lt;&lt; glewGetErrorString(err) &lt;&lt; endl;
      }
      cout &lt;&lt; "Status: Using GLEW " &lt;&lt; glewGetString(GLEW_VERSION) &lt;&lt; endl;
      if (!GLEW_ARB_vertex_buffer_object)
      {
          cerr &lt;&lt; "VBO not supported\n";
          exit(1);
      }
  
      init();
  
      while (running)
      {
          glClear(GL_COLOR_BUFFER_BIT);
          glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
  
          glShadeModel(GL_SMOOTH);
  
          shader.bind();
          glBegin(GL_TRIANGLES);
              //glColor3f(0.2f, 0.5f, 0.54f);
              glVertex2f(0.0f, 0.5f);
  
              //glColor3f(0.75f, 0.8f, 0.1f);
              glVertex2f(-.5f, -.5f);
  
              //glColor3f(0.0f, 0.9f, 0.2f);
              glVertex2f(0.5f, -0.5f);
          glEnd();
          shader.unbind();
  
          glfwSwapBuffers();
  
          running = !glfwGetKey(GLFW_KEY_ESC) &amp;&amp; glfwGetWindowParam(GLFW_OPENED);
      }
  
      glfwTerminate();
  
      exit(EXIT_SUCCESS);
  }
  </code></pre>
  
  <p>shader.vert</p>
  
  <pre><code>void main()
  {
      // set the posistion of the current matrix
      gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
  }
  </code></pre>
  
  <p>shader.frag</p>
  
  <pre><code>void main(void)
  {
      gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
  }
  </code></pre>
  
  <p>Again, when this compiles under g++, it goes through fine, but no triangle was shown. </p>