OpenGL flickering issue in rendering

Question

I have an OpenGL rendering issue and I think that is due to a problem with the Z-Buffer.
I have a code to render a set of points where their size depends on the distance from the camera. Thus bigger points means that are closer to the camera. Moreover in the following snapshots the color reflect the z-buffer of the fragment.



How you can see there is a big point near the camera.
However some frames later the same point is rendered behind more distant points.

These are the functions that I call before render the points:

  glClearDepth(1.0f);

  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  
  glEnable(GL_DEPTH_TEST);
  
  glDepthFunc(GL_LEQUAL);

this is the vertex shader:

#version 330 core

layout (location = 0) in vec3 position;
layout (location = 1) in vec4 color;

// uniform variable
uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;
uniform float pointSize;

out vec4 fragColor;

void main() {
  
  gl_Position = projection * view * model * vec4(position, 1.0f);
  
  vec3 posEye = vec3(view * model * vec4(position, 1.0f));
  
  float Z = length(posEye);
  
  gl_PointSize = pointSize / Z;
      
  fragColor = color;

}

and this is the fragment shader

#version 330 core

in vec4 fragColor;

out vec4 outColor;

void main() {
    
  vec2 cxy = 2.0 * gl_PointCoord - 1.0;

  float r = dot(cxy, cxy);

  if(r > 1.0) discard;

  // calculate lighting
  vec3 pos = vec3(cxy.x,cxy.y,sqrt(1.0-r));
  vec3 lightDir = vec3(0.577, 0.577, 0.577);
  float diffuse = max(0.0, dot(lightDir, pos));

  float alpha = 1.0;
  float delta = fwidth(r);
  alpha = 1.0 - smoothstep(1.0 - delta, 1.0 + delta, r);

  outColor = fragColor * alpha * diffuse;

}

UPDATE

looks like that the problem was due to the definition of the near and far planes.
There is something that I do not understand about which are the best values that I should use.

this is the function that I use to create the projective matrix

glm::perspective(glm::radians(fov), width/(float)height, zNear, zFar);

where winth=1600 height=1200 fov=45

when things didn't work zNear was set to zero and zFar was set to double the distance of the farthest point from the center of gravity of the point cloud, i.e. in my case 1.844

If I move the near clipping plane from zero to 0.1 the flicker seems resolved. However, the distant objects, which I saw before, disappear. So I also changed the far plane to 10 and everything seems to work. Unfortunately, I don't understand why the values I used before were not good.

Answer 1

As already updated the issue is called Z-fighting when choosing the wrong near and far panes in the projection matrix. If they are to far away from your objects, there is only a very discrete number of values for z left. Then the drawing is detemined by the call order and processing order in the shaders, since there is no difference in z. If one has a hint of what needs to come first, draw it that way. Once the rendering-call was set, there is no proper way to determine which processor gets the objects first and that you'll see as flickering.

So please update the way you establish your projection Matrix. Best practise: look at the objects need to be rendered and determine a roughly bounding box, make it a bounding ball and center-radius is a point in the near pane, center+radius is a point in the far pane. Done!

Update

looking into

glm::perspective(glm::radians(fov), width/(float)height, zNear, zFar);

gives a specific for the only influence of z: (before normalization):

Result[3][2] = - (static_cast<T>(2) * zFar * zNear) / (zFar - zNear);

meaning other than zFar!=zNear, it should be also avoided to set zNear to zero. This means there is no difference in z, so it has to Flicker. I would then assume that you don't applied some transform on your projection matrix, better don't. If all your objects live in a space around the coordinates center meaning also in the center of your projection, move them in front of the projection as a last step. So apply some translation not onto the projection/view matrix, but on your object matrix, to avoid having such an ill formed projection space. E.g. set near to 1, and move all objects with that amount through your scene.