All geek questions in one place

OpenGL visualizes the difference between nVidia and ATI

I recently updated the ATI drivers (Iam using HD7970) to the newest, and some of my OpenGL objetcs projects stopped working. Moreover, they are working on the latest nVidia drivers (tested on 960 m). Is there a difference between ATI and the nVidia rendering pipeline I should know?

Additional Information:

  • There is no error in glGetError (),
  • Shaders are compiled and linked correctly,
  • Other rendering objects work fine, but the VBO fill and draw commands are different. The worker is loaded from the * .obj file and drawn using glDrawArrays (). A broken one VBO is filled with a polygonizer (computational shader), which takes the vertices from image2D used for storage and draws glDrawElements (),
  • with my easiest possible debuguger gpu, I checked that the vertex and fragment shader are starting.

When I try to draw with triangles, I don’t see anything, but when I switch to GL_POINTS, I see green dots (the output from the shader fragment is a clean green channel), which move as they should. This may indicate that the vertex shader is shining because MVP animation is taking place. These are planetary LOD objects with one large VBO, so I use one function to bind all buffers and others to draw the necessary height maps. VBO size is 128 MB

Initialization:

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);

Filling VBO with a polygonizer (computational shader):

  #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; }

Binding:

  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);

Picture:

 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); } }

Vertex Shader:

 #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); }
+5
source share
1 answer

Ok, I found a solution. The problem was imageStore () and imageLoad () in computational shaders. Even if I used image2D to store purpuse, I needed to add

 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

after texture generation. That was the difference between ATI na nVidia.

+1
source

Source: https://habr.com/ru/post/1271697/

More articles:


All Articles