Opengl 深度剥离可以在没有任何着色器的情况下实现吗？

我不知道着色器，但我对它们的概念有一个基本概念

---

我需要实现深度剥离，因此我想知道，首先我是否应该深入到着色器世界，或者它可以在没有着色器的情况下实现，只需巧妙地使用glDepthFunc..

是的，如果你有GL_ARB_depth_纹理和GL_ARB_阴影，尽管它非常精细，你也可以这样做

GL_ARB_occlusion_查询也非常有用，因为它允许您决定何时停止剥离。如果您没有这样做，那么您仍然可以这样做，但需要通过循环进行固定次数的迭代。过高会浪费时间和内存，过低会引入视觉伪影

这段代码是从我不久前调试一些深度剥离算法时使用的一些测试代码中提取出来的。我已经删除了所有特定于系统的东西，用伪代码替换了它&做了一些重构，所以不要期望它能够编译。希望你能得到这个想法

对于使用这种方法的顺序无关透明度，您可能会创建一个深度纹理列表，然后按相反顺序遍历

[守则] bool图纸表面（通径） { GLU已启用缓存模板测试； 已启用GLUα测试； GLU已启用深度测试； GLU已启用面消隐

    glGetBooleanv(GL_STENCIL_TEST, &cached_stencil_test_enabled);
    glGetBooleanv(GL_ALPHA_TEST, &cached_alpha_test_enabled);
    glGetBooleanv(GL_DEPTH_TEST, &cached_depth_test_enabled);
    glGetBooleanv(GL_CULL_FACE, &cached_face_cull_enabled);

    if(HasShadow()) // Checks GL_ARB_shadow
    {
        return false; 
    }
    else
    {
        GLuint depthTexture(0);

        bool status(true);

        glEnable(GL_DEPTH_TEST);
        glDepthFunc(GL_LEQUAL);
        glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);

        // Draw geometry into the depth buffer.  No textures, shaders etc.
        //
        // This could easily be folded into next part by restructuring into 
        // do...while()
        status&= DrawSimpleGeometry();

        if(status)
        {
            // for transparency etc. you would build a list of these inside the 
            // loop.  For finding the nth surface we can recycle one.
            glGenTextures(1, &depthTexture);

            if(depthTexture)
            {
                glBindTexture(GL_TEXTURE_2D, depthTexture);

                glTexImage2D(GL_TEXTURE_2D, 0,
                             GL_DEPTH_COMPONENT, 
                             ctx->GetViewportWidth(), 
                             ctx->GetViewportHeight(), 0,
                             GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);


                // Set up texture unit.
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, 
                                GL_NEAREST);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, 
                                GL_NEAREST);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, 
                                GL_CLAMP);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, 
                                GL_CLAMP); 

                glEnable(GL_TEXTURE_2D);

                // Set up texture coord generation.  Should get bias from depth buffer 
                // precision.
                SetupTexGen(-0.004);

                // Set up shadow test.

                glTexParameteri(GL_TEXTURE_2D, 
                                GL_TEXTURE_COMPARE_MODE_ARB, 
                                        GL_COMPARE_R_TO_TEXTURE_ARB);

                glTexParameteri(GL_TEXTURE_2D, 
                                GL_TEXTURE_COMPARE_FUNC_ARB, 
                                GL_GREATER);

                glTexParameteri(GL_TEXTURE_2D, 
                                GL_DEPTH_TEXTURE_MODE_ARB, 
                                GL_ALPHA);

                glAlphaFunc(GL_GREATER, 0.5f);
                glEnable(GL_ALPHA_TEST); 

                for(size_t n=0;(n<passes) && status;n++)
                {
                    // Update depth texture.
                    glBindTexture(GL_TEXTURE_2D, depthTexture);
                    glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 
                                        ctx->GetViewportWidth(), 
                                        ctx->GetViewportHeight());


                    glClear(GL_DEPTH_BUFFER_BIT);

                    status&= DrawSimpleGeometry();
                }

                // deactivate shadow test.
                {
                    // Texgen
                    glDisable(GL_TEXTURE_GEN_S);
                    glDisable(GL_TEXTURE_GEN_T);
                    glDisable(GL_TEXTURE_GEN_R);
                    glDisable(GL_TEXTURE_GEN_Q);

                    // Texture unit
                    glDisable(GL_TEXTURE_2D);

                    // Shadow comparison
                    glDisable(GL_ALPHA_TEST); 
                }

                glDeleteTextures(1, &depthTexture);
            }
            else
            {
                status = false;
            }
        }

        // Restore some of the rendering state.
        if(cached_face_cull_enabled)
        {
            glEnable(GL_CULL_FACE);
            glCullFace(GL_BACK);
        }
        else
        {
            glDisable(GL_CULL_FACE);
        }

        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

        if(cached_face_cull_enabled)
        {
            glEnable(GL_CULL_FACE);
            glCullFace(GL_BACK);
        }
        else
        {
            glDisable(GL_CULL_FACE);
        }

        if(!cached_stencil_test_enabled)
        {
            glDisable(GL_STENCIL_TEST);
        }
        else
        {
            glEnable(GL_STENCIL_TEST);
        }

        if(!cached_alpha_test_enabled)
        {
            glDisable(GL_ALPHA_TEST);
        }
        else
        {
            glEnable(GL_ALPHA_TEST);
        }

        if(!cached_depth_test_enabled)
        {
            glDisable(GL_DEPTH_TEST);
        }
        else
        {
            glEnable(GL_DEPTH_TEST);
        }

        // FINALLY: Draw everything.
        if(status)
        {
            glDepthFunc(GL_EQUAL);
            status&= DrawAllGeometry();
        }

        glDepthFunc(GL_LEQUAL);

        return status;
    }
}

[/code]

---

HTH.

使用opengl 4.x core profile，您必须指定着色器！glDepthFunc仅配置深度比较函数。.深度剥离方法通常需要多次渲染。.因此一定要先编写一些着色器。.但您不必深入着色器世界来编写效果：）开始使用着色器越早，更好。即使你保持简单，你也可以做一些非常了不起的事情。决定首先学习什么GLSL版本。建议使用GLSL 1.50和更高版本。好的，伙计们，如果没有其他方法，那么我将使用着色器。问一个问题，因为我现在使用的是opengl 2.x，这意味着GLSL 1.10。我是否也应该升级并使用一些te opengl或我可以用opengl 2.x完全实现深度剥离？您可以使用GLSL 1.2，但也可以正确地使用它，至少可以针对GLSL/GL 3.3。很多东西都不推荐使用，但您仍然具有向后兼容性。（除非您在OS x上停留在GL 3.2仅核心配置文件上）使用opengl 3.3。

    double tmp[16];

    glGetDoublev(GL_PROJECTION_MATRIX, tmp);

    projection = Matrix(tmp);

    Matrix bias_matrix(0.5, 0.0, 0.0,        0.0,
                       0.0, 0.5, 0.0,        0.0,
                       0.0, 0.0, 0.5,        0.0,
                       0.5, 0.5, 0.5 + bias, 1.0);


    return (projection * bias_matrix);
}

void SetupTexGen(double bias)
{
    Matrix texmat;
    Matrix mv, imv;

    {
        double tmp[16];
        glGetDoublev(GL_MODELVIEW_MATRIX, tmp);
        mv = Matrix(tmp);

        imv = mv.GetInverse();
    }

    glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
    glTexGendv(GL_S, GL_EYE_PLANE, imv.Row(0));
    glEnable(GL_TEXTURE_GEN_S);

    glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
    glTexGendv(GL_T, GL_EYE_PLANE, imv.Row(1));
    glEnable(GL_TEXTURE_GEN_T);

    glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
    glTexGendv(GL_R, GL_EYE_PLANE, imv.Row(2));
    glEnable(GL_TEXTURE_GEN_R);

    glTexGeni(GL_Q, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
    glTexGendv(GL_Q, GL_EYE_PLANE, imv.Row(3));
    glEnable(GL_TEXTURE_GEN_Q);

    texmat = CreateTextureMatrix(bias);

    glMatrixMode(GL_TEXTURE);
    glLoadIdentity();

    glMultMatrixd(texmat);
    glMatrixMode(GL_MODELVIEW);
}