OpenTK深度测试不起作用

Question

I'm having an assignment in my Computer Graphics class to write a 2.5D map using openTK. When I tried to to enable gl_Depth_Test for my drawing, it's doesn't work as expected. The 3D shapes overlap each other and the result is the same when I change DepthFunc between Lequal and Always. I tried to get the depth buffer out. It change when I change the x rotation xrot but is always the same for DepthFunc Always and Lequal. When I change DepthFunc to everything else except Less and Equal, nothing is displayed. The code for my init and render is below. In this code cameraPos Z is mean to be very big. Vertex are 2D points on the Oxy plane. Way are 2D polygons in the Oxy plane or 3D shapes. In case of shapes, they're just 2D polygons in Oxy planes with fake 3D effect by streching them by the z axis. The initWorld code basically mean to move the Vertex cordinates to around the origins of the Oxy plane for easier rotate. The GLU.LookAt I took from the LookAt/gluLookat function here http://www.opentk.com/files/Glu.cs

An image of my program without drawing 2D polygons in the Oxy plane is here: http://bayimg.com/NAOaDAafo

Help me to get my Depth test to work.

Init:

    static Vector3 cameraPos = new Vector3(0, 0, (int)(3 * Const.MaxZoom * Const.EarthRadius));
    static Vector3 refPoint = new Vector3(0, 0, 0);
    static Vector3 upVector = new Vector3(0, 1, 0);        
    public static void initWorld()
    {
        float dx = (float)(Vertex.minX + Vertex.maxX) / 2;
        float dy = (float)(Vertex.minY + Vertex.maxY) / 2;
        double greaterEdge = Math.Max((double)(Vertex.maxX - Vertex.minX), (double)(Vertex.maxY - Vertex.minY)) / 2;
        foreach (Vertex v in node)
        {
            v.p.X -= dx;
            v.p.X *= (float)(Const.WindowSize / greaterEdge);
            v.p.Y -= dy;
            v.p.Y *= (float)(Const.WindowSize / greaterEdge);
        }
        Vertex.minX -= dx; Vertex.minX *= (float)(Const.WindowSize / greaterEdge);
        Vertex.maxX -= dx; Vertex.maxX *= (float)(Const.WindowSize / greaterEdge);
        Vertex.minY -= dy; Vertex.minY *= (float)(Const.WindowSize / greaterEdge);
        Vertex.maxY -= dy; Vertex.maxY *= (float)(Const.WindowSize / greaterEdge);
        left = -Const.WindowSize;
        right = Const.WindowSize;
        bot = -Const.WindowSize;
        top = Const.WindowSize;
        near = 0.000001;
        far = 1000000000;
        foreach (Way w in way)
            w.makePointList();
    }

Render:

    window.RenderFrame += (sender, e) =>
        {
            GL.MatrixMode(MatrixMode.Projection);
            GL.LoadIdentity();
            GL.Ortho(left, right, bot, top, near, far);
            GL.Enable(EnableCap.DepthTest);
            GL.DepthMask(true);
            GL.DepthFunc(DepthFunction.Lequal);
            GL.ClearColor(Color.LightGray);
            GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
            GL.MatrixMode(MatrixMode.Modelview);
            GL.LoadIdentity();
            GLU.LookAt(cameraPos, refPoint, upVector);                
            GL.Rotate(xrot, 1, 0, 0);
            GL.Rotate(zrot, 0, 0, 1);
            GL.Scale(zoom, zoom, zoom);
            GL.Translate(mapTranslate);
            for (int i = 1; i >= 0; --i)
                foreach (Way w in way)
                    if (w.drawID == i) w.draw(zoom);
            for (int i = 2; i >= 2; --i)
                foreach (Way w in way)
                    if (w.drawID == i) w.draw(zoom);
            window.SwapBuffers();
        };

Answer 1

Your range of depth values is way too large:

near = 0.000001;
far = 1000000000;

With near being 10^-6, and far 10^9, that's a relative range of 10^15. You can't represent depth values with reasonable precision if the range is this large. Depth buffers typically have 16 or 24 bit precision.

You typically want to have the near to far ratio at something like 1:10, or maybe 1:100, to get good depth precision. Try values like the following, and your results should be a whole lot better:

near = 0.1;
far = 10.0;

Of course you will need to make sure that the coordinates of your geometry are within this range, so you may have to adjust the exact values to your specific use.

If you ever encounter a situation where you really need an extremely large depth range, there are more advanced methods of dealing with that. They partly involve using multiple rendering passes, or different ways of mapping depth values to the depth buffer range (eg logarithmic depth buffers). I very much doubt that this will be needed for the school assignment of the original poster, but I'm mentioning it just to be more complete (based on suggestion by @vesan).

Answer 2

I've found out what I was doing wrong. It turned out that z cordinates were negative of what I thought they were. Changed the DepthFunc to Greater and use GL.ClearDepth(-1.0F) solved the problem. Still I don't know why the reason why my z cordinates were the opposite though.