c++ - nVidia と ATI の OpenGL レンダリングの違い

Question

最近、ATI ドライバー (HD7970 を使用しています) を最新のものに更新したところ、OpenGL プロジェクトのオブジェクトの一部が機能しなくなりました。さらに、nVidia の最新ドライバー (960m でテスト済み) で動作します。ATI と nVidia レンダリングパイプラインの間に知っておくべき違いはありますか?

追加情報：

glGetError() からのエラーなし、
適切にコンパイルおよびリンクされたシェーダー
他のレンダーオブジェクトは問題なく動作しますが、VBO の入力コマンドと描画コマンドは異なります。*.obj ファイルから読み込み、glDrawArrays() で描画します。壊れた人の VBO は、ストレージに使用される image2D から頂点を取得し、glDrawElements() によって描画されるポリゴン化ツール (計算シェーダー) によって取り込まれます。
最も単純な GPU デバッガーで、頂点シェーダーとフラグメントシェーダーが起動していることを確認しました。

三角形で描画しようとすると何も表示されませんが、GL_POINTS に切り替えると、緑色のドット (フラグメントシェーダーからの出力は純粋な緑色のチャネル) が表示され、正常に移動します。これは、MVP 乗算が発生しているため、頂点シェーダーが起動していることを示している可能性があります。これらは 1 つの大きな VBO を持つ惑星の LOD オブジェクトなので、1 つの関数を使用してすべてのバッファーをバインドし、他の関数を使用して必要な高さマップを描画します。VBOのサイズは128MB

初期化:

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

c++ - nVidia と ATI の OpenGL レンダリングの違い

1 に答える 1

Related

Reference