title: OpenGL Depth Not working, Triangles Disappear
body: <p>For some reason I can't detect I can't set a z index for any triangle. The triangle will display, at the same depth, from 1 to -1 (inclusive), but after that it dissapers. I am not applying any MVP matrix (trying to figure out this first) and I would expect to be able to see my triangle get smaller as I decrease the z value. This is what I have so far:</p>
  
  <pre><code>//My main function
  glutInit(&amp;argc, argv);
  glutInitDisplayMode(GLUT_RGBA|GLUT_ALPHA|GLUT_DOUBLE|GLUT_DEPTH);
  glutInitWindowSize(640, 480);
  glutCreateWindow("Window");
  
  if (init_resources()) {
      glutDisplayFunc(onDisplay);
      glutIdleFunc(idle);
      glEnable(GL_BLEND);
      glEnable(GL_DEPTH_TEST);
      glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
      glutKeyboardFunc(keyboard);
      glutMouseFunc(mouse);
      glutMainLoop();
  }
  
  //And in my display function
  glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);
  </code></pre>
  
  <p>And with my vertext shader:</p>
  
  <pre><code>gl_Position = vec4(coord2d, 0.0, 1.0);
  </code></pre>
  
  <p><code>glGetIntegerv(GL_DEPTH_BITS, &amp;depth)</code> also returns 24.</p>
  
  <p>edit: full code</p>
  
  <pre><code>Sprite *sprite1;
  Sprite *sprite2;
  
  GLuint program;
  GLuint cameraAttribute;
  
  int init_resources()
  {   
  
      //Link shaders, create program and attach shaders
      GLint link_ok = GL_FALSE;
      GLuint vs, fs;
      if ((vs = create_shader("vertShader.sh", GL_VERTEX_SHADER))   == 0) return 0;
      if ((fs = create_shader("fragShader.sh", GL_FRAGMENT_SHADER)) == 0) return 0;
  
      program = glCreateProgram();
      glAttachShader(program, vs);
      glAttachShader(program, fs);
  
  
      glLinkProgram(program);
      glGetProgramiv(program, GL_LINK_STATUS, &amp;link_ok);
      if (!link_ok) {
          fprintf(stderr, "glLinkProgram:");
          print_log(program);
          return 0;
      }
  
      //Create Attributes
      cameraAttribute = glGetUniformLocation(program, "camera");
      if(cameraAttribute == -1){
          cout &lt;&lt; "Error!";
      }
  
  
      //Init sprites
      sprite1 = new Sprite();
      sprite2 = new Sprite();
  
  
      return 1;
  }
  
  void onDisplay()
  {
      glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
      glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);
      glUseProgram(program);
  
  
      sprite1-&gt;render();
      sprite2-&gt;render();
  
      glutSwapBuffers();
  }
  
  void idle()
  {
  
      //Create Projection Matrix to change clip space.
      mat4 projectionMatrix = perspective(60.0f, (float)glutGet(GLUT_WINDOW_WIDTH) / (float)glutGet(GLUT_WINDOW_HEIGHT), 0.1f, 100.f);
      glUniformMatrix4fv(cameraAttribute, 1, GL_FALSE, &amp;projectionMatrix[0][0]);
  
  }
  
  void free_resources()
  {
      glDeleteProgram(program);
  }
  
  
  int main(int argc, char* argv[]) {
      glutInit(&amp;argc, argv);
      glutInitDisplayMode(GLUT_RGBA|GLUT_ALPHA|GLUT_DOUBLE|GLUT_DEPTH);
      glutInitWindowSize(640, 480);
      glutCreateWindow("My Second Triangle");
      glEnable(GL_BLEND);
      glEnable(GL_DEPTH_TEST);
  
      if (init_resources()) {
          glutDisplayFunc(onDisplay);
          glutIdleFunc(idle);
          glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  
          //uses glGetError to check for how many errors there are.
          cout &lt;&lt; CheckGLErrors() &lt;&lt; "\n";
  
          glutMainLoop();
      }
  
  
      free_resources();
      return 0;
  }
  </code></pre>
  
  <p>And my sprite file:</p>
  
  <pre><code>#include "Sprite.h"
  
  Sprite::Sprite(){
      init();
  }
  
  
  void Sprite::init(){
  
      GLfloat triangle_vertices[] = {
          0.0,  0.8f,
          -0.8f, -0.8f,
          0.8f, -0.8f,
      };
  
      //Set attributes
      locationAttribute = glGetAttribLocation(program, "coord2d");
      if (locationAttribute == -1) {
          fprintf(stderr, "Could not bind attribute location");
      }
  
      translationUniform = glGetUniformLocation(program, "translationUniform");
      if(translationUniform == -1){
          fprintf(stderr, "Could not bind attribute transformation");
      }
  
  
      //Create buffer
      glGenBuffers(1, &amp;mainBuffer);
      glBindBuffer(GL_ARRAY_BUFFER, mainBuffer);
      glBufferData(GL_ARRAY_BUFFER, sizeof(triangle_vertices), triangle_vertices, GL_STATIC_DRAW);
  
      glEnableVertexAttribArray(0);
  
      glVertexAttribPointer(
                            locationAttribute, // attribute
                            2,                 // number of elements per vertex, here (x,y)
                            GL_FLOAT,          // the type of each element
                            GL_FALSE,          // take our values as-is
                            0,                 // no extra data between each position
                            0                  // offset of first element
      );
  
      glBindBuffer(GL_ARRAY_BUFFER, 0);
  }
  
  void Sprite::render(){
      glBindBuffer(GL_ARRAY_BUFFER, mainBuffer);
      glDrawArrays(GL_TRIANGLES, 0, 3);
  
  }
  </code></pre>
  
  <p>And Vertex shader: (note, versions are added by the parser)</p>
  
  <pre><code>attribute vec2 coord2d;
  
  uniform mat4 translationUniform;
  uniform mat4 camera;
  
  
  void main(void) {
  
      gl_Position = camera * vec4(coord2d, -1.1, 1.0);
  }
  </code></pre>