OpenGL отображает разницу между nVidia и ATI

Недавно я обновил драйверы ATI (я использую HD7970) до новейшего, и некоторые из объектов моего проекта OpenGL перестали работать. Более того, они работают на новейших драйверах nVidia (протестировано на 960м). Есть ли какая-то разница между ATI и конвейером рендеринга nVidia, о которых я должен знать?

Дополнительная информация:

• Нет ошибки от glGetError (),
• Шейдеры правильно скомпилированы и связаны,
• Другие объекты рендеринга работают нормально, но команды заполнения и рисования VBO отличаются. Рабочие загружаются из файла * .obj и рисуются с помощью glDrawArrays (). Сломанный VBO заполняется полигонизатором (вычислительным шейдером), который берет вершины из image2D, используемого для хранения, и рисует с помощью glDrawElements (),
• с моим самым простым gbu debbuger я проверил, что запускается вершинный и фрагментный шейдеры.

Когда я пытаюсь рисовать треугольниками, я ничего не вижу, но когда я переключаюсь на GL_POINTS, я вижу зеленые точки (вывод из шейдера фрагмента — чистый зеленый канал), которые движутся так, как должны. Это может указывать на то, что вершинный шейдер запускается, потому что происходит умножение MVP.
Это планетарные объекты LOD с одним большим VBO, поэтому я использую одну функцию для связывания всех буферов, а другую — для рисования необходимых карт высот. Размер VBO составляет 128 МБ

Инициализация:

glGenBuffers(1, &VBO);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, VBO);
glBufferData(GL_SHADER_STORAGE_BUFFER, size * sizeof(vec4), NULL, GL_DYNAMIC_COPY);

glGenBuffers(1, &IndexBuffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IndexBuffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexSize * sizeof(unsigned int), NULL, GL_DYNAMIC_DRAW);

glGenBuffers(1, &Normals);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, Normals);
glBufferData(GL_SHADER_STORAGE_BUFFER, size * sizeof(vec4), NULL, GL_DYNAMIC_COPY);

Заполнение VBO полигонизатором (вычислительный шейдер):

    #version 430 core
layout( std430, binding=1 ) buffer ParamsBuffer
{
float size;
uint index;
int parentIndex;
uint textureSize;
vec4 upVector;
vec4 Position;
vec4 quadrant;
};
layout( std430, binding=2 ) buffer VertBuffer
{
vec4 VBO[ ];
};

layout( std430, binding=3 ) buffer NormalsBuffer
{
vec4 Normals[ ];
};

layout(std430, binding = 4) buffer IndexBuffer
{
uint Index[];
};

layout( std430, binding=10 ) buffer DebugBuffer
{
vec4 debug;
};
layout (rgba32f)  uniform image2D HeightMap;
layout (rgba32f)  uniform image2D NormalMap;
layout( local_size_x = 1, local_size_y = 1, local_size_z = 1) in;

void main(void)
{
uint  WGidY=(gl_WorkGroupID.y);
uint  WGidX=(gl_WorkGroupID.x);
uint mapVBOOffset=index*textureSize*textureSize;
uint indexOffset=6*index*textureSize*textureSize;
VBO[WGidY*textureSize+WGidX+mapVBOOffset]=imageLoad(HeightMap, ivec2(WGidX, WGidY));
Normals[WGidY*textureSize+WGidX+mapVBOOffset]=imageLoad(NormalMap, ivec2(WGidX, WGidY));
// debug=VBO[0];
if(WGidX==textureSize-1 || WGidY==textureSize-1)
return;

uint localIndex = 6*(WGidY*textureSize+WGidX)+indexOffset;
Index[localIndex+0]=(WGidY+1)*textureSize+WGidX  +mapVBOOffset;
Index[localIndex+1]=WGidY*textureSize    +WGidX+1+mapVBOOffset;
Index[localIndex+2]=WGidY*textureSize    +WGidX  +mapVBOOffset;
Index[localIndex+3]=WGidY*textureSize    +WGidX+1+mapVBOOffset;
Index[localIndex+4]=(WGidY+1)*textureSize+WGidX  +mapVBOOffset;
Index[localIndex+5]=(WGidY+1)*textureSize+WGidX+1+mapVBOOffset;

}

Переплет:

    glUseProgram(RenderProgram);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, PerFrameBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 5, ConstantBuffer);

glEnableVertexAttribArray(2);
glBindBuffer(GL_ARRAY_BUFFER, Normals);
glVertexAttribPointer(
2,
4,
GL_FLOAT,
GL_FALSE,
0,
(void*)0
);glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glVertexAttribPointer(
0,
4,
GL_FLOAT,
GL_FALSE,
0,
(void*)0
);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IndexBuffer);

Рисование:

float discardFactor = 0;
GLint drawMode;
if(renderMode==0)
drawMode = GL_TRIANGLES;
if (renderMode == 1)
{
drawMode = GL_PATCHES;
GLint vert= 3;
glPatchParameteri(GL_PATCH_VERTICES, 3);
}
if (tile->quadrant_x == nullptr)
{
HeightMap hp = tile->quadrantX;
if (CornersInFrustum(hp.Corners))
{
int mapOffset = tile->quadrantX.index * 6 * heightMapSize*heightMapSize * sizeof(unsigned int);
glDrawElements(drawMode, 6 * heightMapSize*heightMapSize, GL_UNSIGNED_INT, (void*)mapOffset);
}

}

if (tile->quadrant_y == nullptr)
{
HeightMap hp = tile->quadrantY;
if ( CornersInFrustum(hp.Corners))
{
int mapOffset = tile->quadrantY.index * 6 * heightMapSize*heightMapSize * sizeof(unsigned int);
glDrawElements(drawMode, 6 * heightMapSize*heightMapSize, GL_UNSIGNED_INT, (void*)mapOffset);}
}

if (tile->quadrant_z == nullptr)
{
HeightMap hp = tile->quadrantZ;
if (CornersInFrustum(hp.Corners))
{
int mapOffset = tile->quadrantZ.index * 6 * heightMapSize*heightMapSize * sizeof(unsigned int);
glDrawElements(drawMode, 6 * heightMapSize*heightMapSize, GL_UNSIGNED_INT, (void*)mapOffset);
}}

if (tile->quadrant_w == nullptr)
{
HeightMap hp = tile->quadrantW;
if (CornersInFrustum(hp.Corners))
{
int mapOffset = tile->quadrantW.index * 6 * heightMapSize*heightMapSize * sizeof(unsigned int);
glDrawElements(drawMode, 6 * heightMapSize*heightMapSize, GL_UNSIGNED_INT, (void*)mapOffset);
}}

Вершинный шейдер:

#version 430 //core
layout(location = 0) in vec4 vertexPosition_modelspace;
layout(location = 2) in vec4 vertexNormal_modelspace;

layout(std430, binding = 4) buffer PerFrame
{
mat4 ViewMatrix;
vec4 CameraPosition;
vec4 CameraForward;
mat4 ModelMatrix;
float time;
float perFrametab[3];
};

layout(std430, binding = 5) buffer Constant
{
mat4 ProjectionMatrix;
vec4 SeedBuffer;
vec2 screenSize;
};
layout( std430, binding=10 ) buffer DebugBuffer
{
vec4 debug;
};out vec3 Position_worldspace;
out vec3 Normal_cameraspace;
out vec3 EyeDirection_cameraspace;
out vec3 LightDirection_cameraspace;
out vec3 LightPosition_worldspace;
out vec3 NormalWorldSpace;

void main()
{
gl_Position =ProjectionMatrix*
ViewMatrix*ModelMatrix*
vec4(vertexPosition_modelspace.xyz,1);

float C = 1,
near = 0.1,
far = 10000000.0f;
gl_Position.z = (2*log2(C*gl_Position.w + 1) / log2(C*far + 1) - 1) * gl_Position.w;
Position_worldspace = (ModelMatrix*vec4(vertexPosition_modelspace.xyz,1)).xyz;
Normal_cameraspace = ( ViewMatrix *(vec4(vertexNormal_modelspace.xyz,0))).xyz;
vec4 normalTemp=ModelMatrix*vertexNormal_modelspace;
NormalWorldSpace=normalize(normalTemp.xyz);
}