我和一个 friend 正在开发一个编辑器(类似 CAD)以用于我们 future 的游戏。 我们正在使用 Qt 框架和 OpenGL。 我们遇到的问题是，在他的带有集成 nVidia 卡的笔记本电脑上，阴影按预期工作并且渲染良好。在我的带有集成 ATI 卡的笔记本电脑上，以及在我的带有 Radeon HD5850 的台式机上，phong 照明的行为略有不同。有更多的亮点和暗点，图像看起来不太好。此外，我们正在使用卡通着色器在边缘绘制轮廓并限制颜色可以具有的阴影量。

卡通着色器使用 2-pass 渲染 - 第一个 pass 渲染对象为黑色，比原始对象稍大(在其法线方向稍微移动每个顶点)以制作轮廓，然后第二个 pass 正常渲染对象(仅限制阴影光谱，所以它看起来更像漫画)。

我们两台电脑上的图像是一样的。我上面提到的第一个区别，第二个是轮廓被拉长了，因为它应该在我 friend 的电脑上，所以它在物体周围形成一个均匀的轮廓，但在我的电脑上稍微向上移动，在我的电脑上形成一条粗线顶部，底部没有线。

另一件事是 phong 照明，照亮在其中编辑对象的立方体。同样，在我 friend 的计算机上渲染效果很好，但在我的计算机上几乎全黑或全白。

第一张图片(nVidia 卡):

第二张图片(ATI 卡):

我知道代码很长，也许问题出在某些 Qt 设置中，而不是在着色器中，但如果您发现任何让您觉得不好的做法，请回答。

phong 着色的代码如下

    #version 400

    in vec4 aVertex;
    in vec4 aNormal;
    in vec2 aTexCoord;

    uniform mat4 uPVM;
    uniform mat4 uViewModel;
    uniform mat4 uNormal;
    uniform int  uLightsOn;

    out vec2 vTexCoord;
    out vec3 vNormal;
    flat out vec3 mEye;
    flat out vec3 mLightDirection;

    flat out vec4 mAxisColor;

    void main(void)
    {
        if(uLightsOn == 1) {
            mEye = (uViewModel * aVertex).xyz;
            mLightDirection = vec4(2.0,-2.0,1.0,0.0).xyz;
            vNormal = (uNormal * aNormal).xyz;
        }

        gl_Position = uPVM * aVertex;
        vTexCoord = aTexCoord;
        mAxisColor = aNormal;
    }

phong 片段着色器:

    #version 400

    uniform sampler2D uTexture0;
    uniform int  uLightsOn;
    uniform vec3 uHighlightColor;
    uniform int uTextured;
    uniform int uAxisRender;

    in vec2 vTexCoord;
    in vec3 vNormal;
    flat in vec3 mEye;
    flat in vec3 mLightDirection;

    out vec4 fragColor;

    flat in vec4 mAxisColor;

    struct TMaterial {
        vec4 diffuse;
        vec4 ambient;
        vec4 specular;
        float shininess;
    };

    TMaterial material;

    void setup() {
        // setupMaterials

        material.ambient = vec4(0.4);
        material.diffuse = vec4(0.9);
        material.specular = vec4(0.0);
        material.shininess = 0.3;

    }

    void main(void)
    {
        setup();

        vec3 finalHighlightColor = uHighlightColor;

        if(finalHighlightColor.x <= 0.0) finalHighlightColor.x = 0.1;
        if(finalHighlightColor.y <= 0.0) finalHighlightColor.y = 0.1;
        if(finalHighlightColor.z <= 0.0) finalHighlightColor.z = 0.1;

        if(uLightsOn == 0) {
            if(uAxisRender == 1) fragColor = mAxisColor;
            else fragColor = vec4(finalHighlightColor,1.0);
            return;
        }

        vec4 diffuse;
        vec4 spec = vec4(0.0);
        vec4 ambient;

        vec3 L = normalize(mLightDirection - mEye);
        vec3 E = normalize(-mEye);
        vec3 R = normalize(reflect(-L,vNormal));

        ambient = material.ambient;

        float intens = max(dot(vNormal,L), 0.0);

        diffuse = clamp( material.diffuse * intens  , 0.0, 1.0 );
        if(intens > 0.0) spec = clamp ( material.specular * pow(max(dot(R,E),0.0),material.shininess) , 0.0, 1.0 );

        if(uTextured == 1) fragColor = (ambient + diffuse + spec) * texture(uTexture0,vTexCoord);
        else fragColor = (ambient + diffuse + spec) * vec4(finalHighlightColor,1.0);

    }

还有卡通着色器:

    #version 400

    in vec4 aVertex;
    in vec4 aNormal;
    in vec2 aTexCoord;

    uniform mat4 uPV;
    uniform mat4 uM;
    uniform mat4 uN;
    uniform vec3 uLightPosition;
    uniform vec3 uCameraPosition;
    uniform int  uSilhouetteMode;
    uniform float uOffset;
    // if this uniform is passed, all the toon rendering is going off and only simple axis are rendered
    // last data in aNormal are colors of those axis if everything was ser properly.
    uniform int  uAxisRendering;
    flat out vec4 fAxisColor;

    out vec4 vNormal;
    out vec2 vTexCoord;
    out vec3 vDirectionToCamera;
    out vec3 vDirectionToLight;


    void silhouetteMode() {
        gl_Position = uPV * uM * vec4(aVertex.xyz + aNormal.xyz * uOffset,1.0f);
    }

    void toonMode() {
        vec4 worldPosition = uM * aVertex;

        vDirectionToCamera = uCameraPosition - worldPosition.xyz;
        vDirectionToLight = uLightPosition - worldPosition.xyz;
        vNormal = uN * aNormal;

        gl_Position = uPV * worldPosition;
    }

    void axisMode() {
        fAxisColor = aNormal;

        gl_Position = uPV * uM * aVertex;
    }

    void main(void)
    {
        vTexCoord = aTexCoord;

        if(uSilhouetteMode == 1) {
            silhouetteMode();
        } else {
            if(uAxisRendering == 1) axisMode();
            else toonMode();
        }
    }

和片段着色器

    #version 400

    uniform sampler2D uTexture;
    uniform vec3 uBaseColor;
    uniform float uNumShades;
    uniform int  uSilhouetteMode;

    uniform int  uAxisRendering;
    flat in vec4 fAxisColor;

    in vec4 vNormal;
    in vec2 vTexCoord;
    in vec3 vDirectionToCamera;
    in vec3 vDirectionToLight;

    out vec4 outFragColor;

    void main(void)
    {

        if(uSilhouetteMode == 1) {
            outFragColor = vec4(uBaseColor,1.0);
            return;
        }

        if(uAxisRendering == 1) {
            outFragColor = fAxisColor;
            return;
        }

        float l_ambient = 0.1;
        float l_diffuse = clamp(dot(vDirectionToLight,vNormal.xyz),0.0,1.0);
        float l_specular;
        vec3 halfVector = normalize(vDirectionToCamera + vDirectionToLight);

        if(dot(vDirectionToLight,vNormal.xyz) > 0.0) {
            l_specular = pow(clamp(dot(halfVector,vNormal.xyz),0.0,1.0),64.0);
        } else {
            l_specular = 0.0;
        }

        float intensity = l_ambient + l_diffuse + l_specular;
        float shadeIntesity = ceil(intensity * uNumShades)/ uNumShades;

        outFragColor = vec4(texture(uTexture,vTexCoord).xyz * shadeIntesity * uBaseColor,1.0);
    }

最后，我们的 OpenGLWindow 初始化(在 Qt 中)

    OpenGLWindow::OpenGLWindow(QWindow *parent) :
        QWindow(parent),m_animating(false), m_initialized(false), m_animationTimer(NULL)
    {
        setSurfaceType(QWindow::OpenGLSurface);

        QSurfaceFormat format;
        format.setDepthBufferSize( 24 );
        format.setMajorVersion( 4 );
        format.setMinorVersion( 0 );
        format.setSamples( 4 );
        format.setProfile( QSurfaceFormat::CoreProfile );
        setFormat( format );
        create();

        if(!m_context) {
            m_context = new QOpenGLContext(this);
            m_context->setFormat(requestedFormat());
            m_context->create();
            m_context->makeCurrent(this);

            initializeOpenGLFunctions();
        }

        m_animationTimer = new QTimer(this);
        connect(m_animationTimer, SIGNAL(timeout()), this, SLOT(renderer()));
        m_animationTimer->setInterval(16);
    }

最佳答案

在我看来，nVidia 图像似乎使用了 alpha，而 AMD 图像则没有。我也看不到

format.setAlpha(true);

在您的 Qt 设置中可能是这样。

关于c++ - 相同的着色器在 Nvidia 和 ATI 卡上表现不同，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/23417515/