title: Opengl 3.3+ incorrect shadows when using shadow mapping
body: <p>I am trying to implement shadow mapping on my landscape editor with OpenGL 3.3+. Using a few tutorials I have managed to get my code to compile and run but the whole landscape is in shadow except for the back row of my landscape grid (smallest z).</p>
  
  <p>I am currently using the same projection, view and model matrices for my light as the camera (negative z is furthest from the camera).</p>
  
  <p>Initialisation of my projection, view and model matrices (from LWJGL matrix tutorial):</p>
  
  <pre><code>modelPos = new Vector3f(0f, 0f, -20f);
  modelAngle = new Vector3f(15f, 0f, 0f);
  modelScale = new Vector3f(1f, 1f, 1f);
  cameraPos = new Vector3f(-50f, 0f, -120f);
  
  projectionMatrix = new Matrix4f();
  
  float fieldOfView = 120f;
  float aspectRatio = (float)width / (float)height;
  float near_plane = 0.01f;
  float far_plane = 100f;
  
  float y_scale = DepthMatrixUtility.coTangent(DepthMatrixUtility.degreesToRadians(fieldOfView / 2f));
  float x_scale = y_scale / aspectRatio;
  float frustum_length = far_plane - near_plane;
  
  projectionMatrix.m00 = x_scale;
  projectionMatrix.m11 = y_scale;
  projectionMatrix.m22 = -((far_plane + near_plane) / frustum_length);
  projectionMatrix.m23 = -1;
  projectionMatrix.m32 = -((2 * near_plane * far_plane) / frustum_length);
  </code></pre>
  
  <p>Binding my matrices when displaying scene:</p>
  
  <pre><code>Matrix4f.translate(cameraPos, viewMatrix, viewMatrix);
  Matrix4f.scale(modelScale, modelMatrix, modelMatrix);
  Matrix4f.translate(modelPos, modelMatrix, modelMatrix);
  
  Matrix4f.rotate(DepthMatrixUtility.degreesToRadians(modelAngle.z), new Vector3f(0, 0, 1), modelMatrix, modelMatrix);
  Matrix4f.rotate(DepthMatrixUtility.degreesToRadians(modelAngle.y), new Vector3f(0, 1, 0), modelMatrix, modelMatrix);
  Matrix4f.rotate(DepthMatrixUtility.degreesToRadians(modelAngle.x), new Vector3f(1, 0, 0), modelMatrix, modelMatrix);
  
  matrix = new Matrix4f();
  Matrix4f.mul(matrix, projectionMatrix, matrix);
  Matrix4f.mul(matrix, viewMatrix, matrix);
  Matrix4f.mul(matrix, modelMatrix, matrix);
  
  matrix.store(matrix44Buffer);
  matrix44Buffer.flip();
  
  matrixLocation = GL20.glGetUniformLocation(pId, "matrix");
  GL20.glUniformMatrix4(matrixLocation, false, matrix44Buffer);
  </code></pre>
  
  <p>I have tested my FBO with storing colour in the fragment shader, the height map displays correctly (I drew the FBO texture to a small quad in the corner of my screen) and updates as I alter the height map.</p>
  
  <p>I then modified my FBO to store the depth to a texture on the first pass:</p>
  
  <pre><code>depthTexture = GL11.glGenTextures();
  
  GL11.glBindTexture(GL11.GL_TEXTURE_2D, depthTexture);
  
  GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_DEPTH_COMPONENT, Window.getScreenWidth(), Window.getScreenHeight(), 0, GL11.GL_DEPTH_COMPONENT, GL11.GL_UNSIGNED_BYTE, (ByteBuffer)null);
  
  GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_NEAREST);
  GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_NEAREST);
  GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
  GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
  
  GL11.glBindTexture(GL11.GL_TEXTURE_2D, 0);
  
  fboId = GL30.glGenFramebuffers();
  GL30.glBindFramebuffer(GL30.GL_FRAMEBUFFER, fboId);
  
  GL11.glDrawBuffer(GL11.GL_NONE);
  GL11.glReadBuffer(GL11.GL_NONE);
  
  GL32.glFramebufferTexture(GL30.GL_FRAMEBUFFER, GL30.GL_DEPTH_ATTACHMENT, depthTexture, 0);
  
  verifyFBO();
  </code></pre>
  
  <p>My vertex shader for the first pass (Creating the shadow map):</p>
  
  <pre><code>#version 330 core
  
  uniform mat4 matrix;
  
  in vec4 in_Position;
  
  void main(void)
  {
  gl_Position = matrix * in_Position;
  }
  </code></pre>
  
  <p>My fragment shader for the first pass:</p>
  
  <pre><code>#version 330 core
  
  layout(location = 0) out float fragmentdepth;
  
  void main(void)
  {
  fragmentdepth = gl_FragCoord.z;
  }
  </code></pre>
  
  <p>My bias matrix:</p>
  
  <pre><code>[0.5f, 0.0f, 0.0f, 0.0f]
  [0.0f, 0.5f, 0.0f, 0.0f]
  [0.0f, 0.0f, 0.5f, 0.0f]
  [0.5f, 0.5f, 0.5f, 1.0f]
  </code></pre>
  
  <p>My vertex shader for the second pass (rendering the scene using the shadow map):</p>
  
  <pre><code>void main(void)
  {
      gl_Position = matrix * in_Position;
      ShadowCoord = biasMatrix * lightMatrix * in_Position;
  }
  </code></pre>
  
  <p>My fragment shader for the second pass:</p>
  
  <pre><code>if (texture(shadowMap, ShadowCoord.xy).z  &lt;  ShadowCoord.z)
  {
      vec4 colour = 0.5 * out_Colour;
      out_Colour = new vec4(colour[0], colour[1], colour[2], 1.0f);
  }
  </code></pre>