OpenGL：Radeon 驱动程序似乎与深度测试混为一谈

Posted 2023-04-15

【中文标题】OpenGL：Radeon 驱动程序似乎与深度测试混为一谈

【英文标题】：OpenGL: Radeon driver seems to mess with depth testing

【发布时间】：2014-09-19 08:50:57

【问题描述】：

我在这里遇到了一个非常奇怪的深度测试问题。 我在 Windows 上的 OpenGL 3.3 核心配置文件上下文中渲染一个简单的网格，启用了深度测试并将 glDepthFunc 设置为 GL_LESS。在我的机器上（一台带有 nVidia Geforce GTX 660M 的笔记本电脑），一切都按预期工作，深度测试正在工作，这就是它的样子：

现在，如果我在另一台 PC 上运行程序，一台装有 Radeon R9 280 的塔，它看起来更像这样：

很奇怪，真正奇怪的是，当我在绘制之前每帧调用 glEnable(GL_DEPTH_TEST) 时，两台机器上的结果都是正确的。 当我这样做时它正在工作，我认为在两台机器上都正确创建了深度缓冲区，当我在初始化时仅启用一次深度测试时，似乎在渲染之前以某种方式禁用了深度测试。 以下是可能成为问题一部分的最少代码：

在创建上下文并使其成为当前上下文之后，在初始化时调用的代码：

glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);

在缓冲区交换之前每帧调用的代码：

glClearColor(0.4f, 0.6f, 0.8f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

// mShaderProgram->getID() simply returns the handle of a simple shader program
glUseProgram(mShaderProgram->getID());  

glm::vec3 myColor = glm::vec3(0.7f, 0.5f, 0.4f);
GLuint colorLocation = glGetUniformLocation(mShaderProgram->getID(), "uColor");
glUniform3fv(colorLocation, 1, glm::value_ptr(myColor));

glm::mat4 modelMatrix = glm::mat4(1.0f);
glm::mat4 viewMatrix = glm::lookAt(glm::vec3(0.0f, 3.0f, 5.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
glm::mat4 projectionMatrix = glm::perspectiveFov(60.0f, (float)mWindow->getProperties().width, (float)mWindow->getProperties().height, 1.0f, 100.0f);
glm::mat4 inverseTransposeMVMatrix = glm::inverseTranspose(viewMatrix*modelMatrix);

GLuint mMatrixLocation = glGetUniformLocation(mShaderProgram->getID(), "uModelMatrix");
GLuint vMatrixLocation = glGetUniformLocation(mShaderProgram->getID(), "uViewMatrix");
GLuint pMatrixLocation = glGetUniformLocation(mShaderProgram->getID(), "uProjectionMatrix");
GLuint itmvMatrixLocation = glGetUniformLocation(mShaderProgram->getID(), "uInverseTransposeMVMatrix");

glUniformMatrix4fv(mMatrixLocation, 1, GL_FALSE, glm::value_ptr(modelMatrix));
glUniformMatrix4fv(vMatrixLocation, 1, GL_FALSE, glm::value_ptr(viewMatrix));
glUniformMatrix4fv(pMatrixLocation, 1, GL_FALSE, glm::value_ptr(projectionMatrix));
glUniformMatrix4fv(itmvMatrixLocation, 1, GL_FALSE, glm::value_ptr(inverseTransposeMVMatrix));

// Similiar to the shader program, mMesh.gl_vaoID is simply the handle of a vertex array object
glBindVertexArray(mMesh.gl_vaoID);

glDrawArrays(GL_TRIANGLES, 0, mMesh.faces.size()*3);

使用上面的代码，我会在 Radeon 上得到错误的输出。 注意：我使用 GLFW3 来创建上下文，使用 GLEW 来创建函数指针（显然 GLM 用于数学计算）。 顶点数组对象包含三个属性数组缓冲区，分别用于位置、uv 坐标和法线。每一个都应该正确配置并发送到着色器，因为在每帧启用深度测试时一切正常。

我还应该提到，Radeon 机器运行 Windows 8，而 nVidia 机器运行 Windows 7。

编辑：根据要求，这里是用于加载网格和创建属性数据的代码。我没有创建任何元素缓冲区对象，因为我没有使用元素绘制调用。

std::vector<glm::vec3> positionData;
std::vector<glm::vec2> uvData;
std::vector<glm::vec3> normalData;
std::vector<meshFaceIndex> faces;

std::ifstream fileStream(path);
if (!fileStream.is_open())
    std::cerr << "ERROR: Could not open file '" << path << "!\n";
    return;

std::string lineBuffer;
while (std::getline(fileStream, lineBuffer))
    std::stringstream lineStream(lineBuffer);
    std::string typeString;
    lineStream >> typeString;   // Get line token
    if (typeString == TOKEN_VPOS)  // Position
        glm::vec3 pos;
        lineStream >> pos.x >> pos.y >> pos.z;
        positionData.push_back(pos);
    
    else
        if (typeString == TOKEN_VUV)   // UV coord
            glm::vec2 UV;
            lineStream >> UV.x >> UV.y;
            uvData.push_back(UV);
        
        else
            if (typeString == TOKEN_VNORMAL)   // Normal
                glm::vec3 normal;
                lineStream >> normal.x >> normal.y >> normal.z;
                normalData.push_back(normal);
            
            else
                if (typeString == TOKEN_FACE)  // Face
                    meshFaceIndex faceIndex;
                    char interrupt;
                    for (int i = 0; i < 3; ++i)
                        lineStream >> faceIndex.positionIndex[i] >> interrupt
                            >> faceIndex.uvIndex[i] >> interrupt
                            >> faceIndex.normalIndex[i];
                    
                    faces.push_back(faceIndex);
                
            
        
    

fileStream.close();     

std::vector<glm::vec3> packedPositions;
std::vector<glm::vec2> packedUVs;
std::vector<glm::vec3> packedNormals;

for (auto f : faces)
    Face face;  // Derp derp;
    for (auto i = 0; i < 3; ++i)
        if (!positionData.empty())
            face.vertices[i].position = positionData[f.positionIndex[i] - 1];
            packedPositions.push_back(face.vertices[i].position);
        
        else
            face.vertices[i].position = glm::vec3(0.0f);
        if (!uvData.empty())
            face.vertices[i].uv = uvData[f.uvIndex[i] - 1];
            packedUVs.push_back(face.vertices[i].uv);
        
        else
            face.vertices[i].uv = glm::vec2(0.0f);
        if (!normalData.empty())
            face.vertices[i].normal = normalData[f.normalIndex[i] - 1];
            packedNormals.push_back(face.vertices[i].normal);
        
        else
            face.vertices[i].normal = glm::vec3(0.0f);
    
    myMesh.faces.push_back(face);


glGenVertexArrays(1, &(myMesh.gl_vaoID));
glBindVertexArray(myMesh.gl_vaoID);

GLuint positionBuffer;  // positions
glGenBuffers(1, &positionBuffer);
glBindBuffer(GL_ARRAY_BUFFER, positionBuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec3)*packedPositions.size(), &packedPositions[0], GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);

GLuint uvBuffer;    // uvs
glGenBuffers(1, &uvBuffer);
glBindBuffer(GL_ARRAY_BUFFER, uvBuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec2)*packedUVs.size(), &packedUVs[0], GL_STATIC_DRAW);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, (void*)0);

GLuint normalBuffer;    // normals
glGenBuffers(1, &normalBuffer);
glBindBuffer(GL_ARRAY_BUFFER, normalBuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec3)*packedNormals.size(), &packedNormals[0], GL_STATIC_DRAW);
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);


glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);

.obj 加载例程主要改编自这个： http://www.limegarden.net/2010/03/02/wavefront-obj-mesh-loader/

【问题讨论】：

问题已经解决，感谢 datenwolf。为了进一步参考，在 glAttribPointer 调用中显式设置 stride 参数解决了这个问题。

我当然指的是 glVertexAttribPointer 调用。

【参考方案1】：

对我来说，这看起来不像是深度测试问题，而更像是顶点/索引数组数据中的未对齐问题。请向我们展示加载顶点缓冲区对象和元素缓冲区对象的代码。

【讨论】：

那是我的直觉，但我也认为如果调用 glEnable(GL_DEPTH_TEST) 会有所不同，可能存在数组溢出或提前释放或类似情况，因此依赖于经典的未定义行为？这是我能想到的唯一方法，即改变逻辑上不相关的因素的经验观察可能会改变不正确的输出。可能我正抓着稻草。

我将用于创建顶点缓冲区对象的代码添加到我的帖子中。我也怀疑顶点数据存在一些问题，但由于它在我的 nVidia 上看起来非常好，并且在 Radeon 上也可以使用提到的 glEnable 调用，我认为这不太可能。

@JWki：众所周知，NVidia 驱动程序对不遵循所需 OpenGL 实践的应用程序非常宽容。因此，它们不是查看 OpenGL 程序是否正常工作的好测试对象。 AMD 驱动程序在稳定性和有时性能方面的不足，由 OpenGL 合规性弥补；他们一字不差地遵循 OpenGL 规范，然后还有更多。因此，如果一个程序在 AMD 上被破坏，它可能会出现一些问题。如果一个程序在 AMD 的 OpenGL 实现中按预期工作，你知道，它会在任何地方工作。

@JWki：您的代码实际上看起来非常好。这很奇怪，因为您的“损坏”屏幕截图显然看起来像顶点排序中的某些东西（有些面连接顶点，它们在正确渲染的帧中没有共享面）。我认为禁用深度测试并不能“解决”问题，它只会让人更难注意到。我的建议是提供明确的步幅。这是一个意外的机会，但我现在想不出其他任何事情。

@JWki：步长是数组中向量之间的距离（以字节为单位）。一个万无一失的方法是执行以下((char*)&packed…[1]) - ((char*)&packed…[0])。此操作的结果是 ptrdiff_t 类型，它通常会转换为 GLsizei。

【参考方案2】：

这是因为ChoosePixelFormat函数。

在我的例子中，ChoosePixelFormat 返回一个值为 8 的像素格式 ID，它提供了一个 16 位的深度缓冲区，而不是所需的 24 位。

一个简单的解决方法是手动将 ID 设置为 11 而不是 8 的值，以获得适合具有 24 位深度缓冲区的应用程序的像素格式。

【讨论】：

此外，这个错误似乎只发生在 AMD 显卡上。在 NVIDIA 和 Intel UHD 示例中，它会从驱动程序中选择正确的像素格式 ID。