OpenGL: драйвер Radeon, похоже, не справляется с глубинным тестированием

Question

У меня действительно странная проблема с глубинным тестированием. Я рендерил простую сетку в контексте профиля ядра OpenGL 3.3 в Windows с включенным тестированием глубины и значением glDepthFunc GL_LESS. На моей машине (ноутбук с nVidia Geforce GTX 660M) все работает как положено, тест глубины работает, вот как это выглядит:

Теперь, если я запускаю программу на другом ПК, башне с 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 для математики). Объект массива вершин содержит три буфера массива атрибутов для позиций, ультрафиолетовых координат и нормалей. Каждый из них должен быть правильно настроен и отправлен в шейдеры, так как все работает нормально при включении проверки глубины каждого кадра.

Следует также отметить, что на машине 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/

Answer 1

Для меня это не похоже на проблему глубинного тестирования, но больше похоже на смещение в данных массива вершин / индексов. Пожалуйста, покажите нам код, в котором вы загружаете объекты буфера вершин и объекты буфера элементов.

Answer 2

Это из-за функции ChoosePixelFormat.

В моем случае ChoosePixelFormat возвращает идентификатор пиксельного формата со значением 8, который обеспечивает буфер глубины с 16 битами вместо требуемых 24 бит.

Одно простое исправление заключалось в том, чтобы вручную установить для идентификатора значение 11 вместо 8, чтобы получить подходящий формат пикселей для приложения с 24 битами буфера глубины.