Question

我正在尝试在片段着色器中对网格执行光线跟踪。我已经编写了下面的着色器来执行此操作（顶点着色器只绘制一个screenquad）。

#version 150

uniform mat4 mInvProj, mInvRot;
uniform vec4 vCamPos;

varying vec4 vPosition;

int test(vec3 p)
{
    if (p.x > -4.0 && p.x < 4.0
     && p.y > -4.0 && p.y < 4.0
     && ((p.z < -4.0 && p.z > -8.0) || (p.z > 4.0 && p.z < 8.0)))
        return 1;
    return 0;
}

void main(void) {
    vec4 cOut = vec4(0, 0, 0, 0);

    vec4 vWorldSpace = mInvRot * mInvProj * vPosition;
    vec3 vRayOrg = vCamPos.xyz;
    vec3 vRayDir = normalize(vWorldSpace.xyz);

    // http://en.wikipedia.org/wiki/Xiaolin_Wu%27s_line_algorithm
    vec3 adelta = abs(vRayDir);
    int increaser;
    vec3 gradient, sgradient;
    if (adelta.x > adelta.y && adelta.x > adelta.z)
    {
        increaser = 0;
        gradient = vec3(vRayDir.x > 0.0? 1.0: -1.0, vRayDir.y / vRayDir.x, vRayDir.z / vRayDir.x);
        sgradient = vec3(0.0, gradient.y > 0.0? 1.0: -1.0, gradient.z > 0.0? 1.0: -1.0);
    }
    else if (adelta.y > adelta.x && adelta.y > adelta.z) 
    {
        increaser = 1;
        gradient = vec3(vRayDir.x / vRayDir.y, vRayDir.y > 0.0? 1.0: -1.0, vRayDir.z / vRayDir.y);
        sgradient = vec3(gradient.x > 0.0? 1.0: -1.0, 0.0, gradient.z > 0.0? 1.0: -1.0);
    }
    else 
    {
        increaser = 2;
        gradient = vec3(vRayDir.x / vRayDir.z, vRayDir.y / vRayDir.z, vRayDir.z > 0.0? 1.0: -1.0);
        sgradient = vec3(gradient.x > 0.0? 1.0: -1.0, gradient.y > 0.0? 1.0: -1.0, 0.0);
    }
    vec3 walk = vRayOrg;
    for (int i = 0; i < 64; ++i)
    {
        vec3 fwalk = floor(walk);
        if (test(fwalk) > 0)
        {
            vec3 c = abs(fwalk) / 4.0;
            cOut = vec4(c, 1.0);
            break;
        }
        vec3 nextwalk = walk + gradient;
        vec3 fnextwalk = floor(nextwalk);

        bool xChanged = fnextwalk.x != fwalk.x;
        bool yChanged = fnextwalk.y != fwalk.y;
        bool zChanged = fnextwalk.z != fwalk.z;

        if (increaser == 0)
        {
            if ((yChanged && test(fwalk + vec3(0.0, sgradient.y, 0.0)) > 0)
             || (zChanged && test(fwalk + vec3(0.0, 0.0, sgradient.z)) > 0)
             || (yChanged && zChanged && test(fwalk + vec3(0.0, sgradient.y, sgradient.z)) > 0))
                {
                    vec3 c = abs(fwalk) / 4.0;
                    cOut = vec4(c, 1.0);
                    break;
                }
        }
        else if (increaser == 1)
        {
            if ((xChanged && test(fwalk + vec3(sgradient.x, 0.0, 0.0)) > 0)
             || (zChanged && test(fwalk + vec3(0.0, 0.0, sgradient.z)) > 0)
             || (xChanged && zChanged && test(fwalk + vec3(sgradient.x, 0.0, sgradient.z)) > 0))
                {
                    vec3 c = abs(fwalk) / 4.0;
                    cOut = vec4(c, 1.0);
                    break;
                }
        }
        else
        {
            if ((xChanged && test(fwalk + vec3(sgradient.x, 0.0, 0.0)) > 0)
             || (yChanged && test(fwalk + vec3(0.0, sgradient.y, 0.0)) > 0)
             || (xChanged && yChanged && test(fwalk + vec3(sgradient.x, sgradient.y, 0.0)) > 0))
                {
                    vec3 c = abs(fwalk) / 4.0;
                    cOut = vec4(c, 1.0);
                    break;
                }
        }

        walk = nextwalk;
    }

    gl_FragColor = cOut;
}

只要我查看接近的网格项目，硬编码的帧数，帧速率看起来可以接受（Geforce 680M上400 + fps）（虽然比我目前所写的其他着色器的预期低，但是当我看到空洞（所以循环一直到64）时，帧速率很糟糕（40fps）。当看到如此接近网格时，我得到大约1200 fps，每个像素都在相同的关闭网格项中结束。

虽然我明白为每个像素执行此循环是一些工作，但它仍然是一些简单的基本数学，特别是现在我已经删除了纹理查找并且刚刚使用了一个简单的测试，所以我不明白为什么这必须让一切都变得如此艰难。我的GPU有16个内核，运行速度为700 + Mhz。我渲染为960x540,518400像素。它应该能够处理比我想象的更多的东西。

如果我删除了上面的抗锯齿部分（代码部分，我将根据增加器值测试一些额外的相邻点），它会好一点（100fps），但是通过这些计算，它来了不应该有太大的区别！如果我拆分代码以便不使用增量器但是下面的代码是针对每个不同的部分完成的，则帧速率保持不变。如果我将一些int更改为浮点数，则没有任何更改。

之前我做过更多密集和/或复杂的着色器，为什么这个非常慢？谁能告诉我做什么计算会让它走得那么慢？

我没有设置未使用的制服或类似的东西，C代码也只是做渲染。这是我以前成功使用过的代码。

任何？

Answer 1

简短的回答是：着色器中的分支和循环是（可能）邪恶。但它远不止于此：请阅读此主题以获取更多信息：Efficiency of branching in shaders

它来了：

图形适配器有一个或多个GPU，GPU有几个核心。每个核心都设计为运行多个线程，但这些线程只能运行完全相同的代码（取决于实现）。

因此，如果10个线程必须执行不同的循环，那么只要最大的循环将运行，这10个线程都必须运行（取决于实现，循环可能会继续超出必要或线程可能停滞不前。

与分支相同：如果线程有if，则可能（取决于实现）执行两个分支并使用其中一个分支的结果。

因此，总而言之，如果你想根据某些条件删除一些计算，那么可能（并且可能主要是）更好地进行数学运算并使用0因子，而不是写条件本身和分支。

例如：

(using useLighting = 0.0f or 1.0f)
return useLighting * cLightColor * cMaterialColor + (1.0 - useLighting) * cMaterialColor;

可能比以下更好：

if (useLighting < 0.5)
  return cMaterialColor;
else
  return cLightColor * cMaterialColor;

但有时它可能不会......性能测试是关键......

为什么这个GLSL着色器这么慢？

1 个答案: