Question

我正在尝试在OpenGL / GLSL中实现平铺延迟渲染，但我仍然坚持轻剔除。

我的GPU有点老了（AMD Radeon 6490m），出于奇怪的原因，当在共享变量中调用原子操作时，计算着色器在无限循环中运行，因此我无法使用计算着色器计算最小和最大深度。无论如何，这不是很耗时的操作，所以我在片段着色器中这样做。

然后，对于每个可见点光（在视图空间中），我计算边界四边形的屏幕空间。现在我想使用单个计算着色器进行灯光剔除和着色。问题是，如上所述，我无法对共享变量使用原子操作，因此我无法构建平铺灯列表并存储平铺的灯数。

问题是我无法找到任何其他方法如何做到这一点。任何想法如何剔除＆amp;使用非原子构建tile light list？

这是我的计算着色器的伪代码：

#version 430

#define MAX_LIGHTS  1024
#define TILE_SIZE   32
#define RX  1280
#define RY  720

struct Light {
    vec4 position;
    vec4 quad;
    vec3 color;
    float radius;
}

uint getTilesXCount(){
    return uint(( RX + TILE_SIZE - 1) / TILE_SIZE);
}

uint getTilesYCount(){
    return uint((RY + TILE_SIZE - 1) / TILE_SIZE);
}

layout (binding = 0, rgba16f) uniform readonly image2D minMaxTex;
layout (binding = 1, rgba16f) uniform readonly image2D diffTex;
layout (binding = 2, rgba16f) uniform readonly image2D specTex;

layout (std430, binding = 3) buffer pointLights {
    Light Lights[];
};


//tile light list & light count
shared uint lightIDs[MAX_LIGHTS];
shared uint lightCount = 0;

uniform uint totalLightCount;

layout (local_size_x = TILE_SIZE, local_size_y = TILE_SIZE) in;

void main(void){

        ivec2 pixel = ivec2(gl_GlobalInvocationID.xy);
        vec2 tile = vec2(gl_WorkGroupID.xy * gl_WorkGroupSize.xy) / vec2(1280, 720);

        //get minimum & maximum depth for tile
        vec2 minMax = imageLoad(minMax, tile).xy;

        uint threadCount = TILE_SIZE * TILE_SIZE;
        uint passCount = (totalLightCount + threadCount - 1) / threadCount; 

        for(uint i = 0; i < passCount; i++){

            uint lightIndex = passIt * threadCount + gl_LocalInvocationIndex;

            // prevent overrun by clamping to a last ”null” light
            lightIndex = min(lightIndex, numActiveLights);

            Light l = pointLights[lightIndex];

            if(testLightBounds(pixel, l.quad)){

                if ((minMax.y < (l.position.z + l.radius))
                    && 
                    (minMax.x > (l.position.z - l.radius))){


                    uint index;
                    index = atomicAdd(lightCount, 1);
                    pointLightIndex[index] = lightIndex;
                }
            }
        }

    barrier();

    //do lighting for actual tile
    color = doLight();

    imageStore(out, pos, color);
}

Answer 1

我还没有真正实现平铺延迟，但我认为你可以通过类似于为模拟构建粒子相邻列表的方式来处理它。

让您的计算着色器构建一个包含灯光和单元格ID的元组，并使用当前线程作为索引将其存储在缓冲区中。
使用您最喜欢的GPU算法（基数排序或比特排序）按单元格ID对缓冲区进行排序。
对缓冲区进行排序后，构建直方图并进行前缀和扫描，以查找每个单元格在缓冲区内的起始位置。

实施例

(Cell, Light)
1st pass: Cell Buffer -> [ 23, 0 ] [ 7, 1 ] [ 9, 2 ] ....
2nd pass: Cell Buffer -> [ 7, 1 ] [ 9, 2 ] [ 23, 0 ] ....

(Start, End)
3rd pass: Index Buffer -> [0 0] [0 0] [0 0] [0 0] [0 0] [0 0] [0 1] [1 1] [1 2] ...

有关详细信息，该方法在Simon Green＆＃34;粒子模拟使用CUDA＆＃34;：http://idav.ucdavis.edu/~dfalcant/downloads/dissertation.pdf

中描述。

原始方法假定粒子只能放在一个单元格中，但您应该能够通过使用更大的工作量轻松解决这个问题。

平铺渲染计算着色器光剔除和阴影

1 个答案: