我正在尝试使用带有实时光线行进的 revelles 算法在 GLSL（v450）中的计算着色器中遍历我的八叉树。我设法遍历它并获得了图像，但我的 fps 非常低，大约 0-5 fps。由于算法伪代码是递归的，因此我使用堆栈将其转换为循环（因为 GLSL 不允许递归）。问题是，一旦我使这个循环非动态统一，我就会得到大约 30-40 的巨大 fps 下降。
如果我在我的堆栈上使用shared属性，我可以得到这个 fps 备份，仅在全局变量的计算着色器中可用：
shared struct stack{
float tx0;
float tx1;
float ty0;
float ty1;
float tz0;
float tz1;
float txm;
float tym;
float tzm;
int currNode;
int node;
}travStack[10];
使其能够在我的工作组中的所有线程之间共享和使用。问题是我无法将这些与barrier()和/或memoryBarrierShared()函数同步，因为它们似乎需要循环动态统一（参见共享变量 www.opengl.org/wiki/Compute_Shader）。由于我无法同步，图像变得像素化并闪烁。
有没有办法将此算法转换为动态统一循环？当循环变得非动态均匀时，为什么fps会下降？
下面是我的主循环代码。
void traverse(vec3 rayOrigin, vec3 direction){
rayParameter(rayOrigin, direction); //Set parameters
stackRoot = true;
bool backfire = false;
//----
float tx0;
float tx1;
float ty0;
float ty1;
float tz0;
float tz1;
float txm;
float tym;
float tzm;
//----
int v;
int v1;
int v2;
int v3;
int v4;
int v5;
int v6;
int v7;
// Test variables
int itrCount = 0;
int itrCheck = 3;
int limit = 200;
stackPointer = 0;
if ((max(max(travStack[0].tx0, travStack[0].ty0), travStack[0].tz0)) < (min(min(travStack[0].tx1, travStack[0].ty1), travStack[0].tz1))){
travStack[0].currNode = procSubtree(travStack[0].tx0, travStack[0].ty0, travStack[0].tz0, travStack[0].tx1, travStack[0].ty1, travStack[0].tz1, travStack[0].node);
while (stackPointer >= 0 ){ //itrCount < limit){
//----
tx0 = travStack[stackPointer].tx0;
tx1 = travStack[stackPointer].tx1;
ty0 = travStack[stackPointer].ty0;
ty1 = travStack[stackPointer].ty1;
tz0 = travStack[stackPointer].tz0;
tz1 = travStack[stackPointer].tz1;
txm = travStack[stackPointer].txm;
tym = travStack[stackPointer].tym;
tzm = travStack[stackPointer].tzm;
//----
switch (travStack[stackPointer].currNode){
case 0:
{
if (!backfire){
stackPointer++;
int index = travStack[stackPointer - 1].node + a + a4 + a2;
v = procSubtree(tx0, ty0, tz0, txm, tym, tzm, treeArray[index]);
if (v == -1){ //Go up one level. Either hit empty, an edge or a leaf.
stackPointer--;
travStack[stackPointer].currNode = newNode(txm, 4, tym, 2, tzm, 1);
}
else{
travStack[stackPointer].currNode = v;
}
}
else{
travStack[stackPointer].currNode = newNode(txm, 4, tym, 2, tzm, 1);
backfire = false;
}
break;
}
case 1:
{
if (!backfire){
stackPointer++;
int index1 = travStack[stackPointer - 1].node + (1 - a) + a4 + a2;
v1 = procSubtree(tx0, ty0, tzm, txm, tym, tz1, treeArray[index1]);
if (v1 == -1){ //Go up one level. Either hit empty, an edge or a leaf.
stackPointer--;
travStack[stackPointer].currNode = newNode(txm, 5, tym, 3, tz1, 8);
}
else{
travStack[stackPointer].currNode = v1;
}
}
else{
travStack[stackPointer].currNode = newNode(txm, 5, tym, 3, tz1, 8);
backfire = false;
}
break;
}
case 2:
{
if (!backfire){
stackPointer++;
int index2 = travStack[stackPointer - 1].node + (2 + a) + a4 - a2;
v2 = procSubtree(tx0, tym, tz0, txm, ty1, tzm, treeArray[index2]);
if (v2 == -1){ //Go up one level. Either hit empty, an edge or a leaf.
stackPointer--;
travStack[stackPointer].currNode = newNode(txm, 6, ty1, 8, tzm, 3);
}
else{
travStack[stackPointer].currNode = v2;
}
}
else{
travStack[stackPointer].currNode = newNode(txm, 6, ty1, 8, tzm, 3);
backfire = false;
}
break;
}
case 3:
{
if (!backfire){
stackPointer++;
int index3 = travStack[stackPointer - 1].node + (3 - a) + a4 - a2;
v3 = procSubtree(tx0, tym, tzm, txm, ty1, tz1, treeArray[index3]);
if (v3 == -1){ //Go up one level. Either hit empty, an edge or a leaf.
stackPointer--;
travStack[stackPointer].currNode = newNode(txm, 7, ty1, 8, tz1, 8);
}
else{
travStack[stackPointer].currNode = v3;
}
}
else{
travStack[stackPointer].currNode = newNode(txm, 7, ty1, 8, tz1, 8);
backfire = false;
}
break;
}
case 4:{
if (!backfire){
stackPointer++;
int index4 = travStack[stackPointer - 1].node + (4 + a) - a4 + a2;
v4 = procSubtree(txm, ty0, tz0, tx1, tym, tzm, treeArray[index4]);
if (v4 == -1){ //Go up one level. Either hit empty, an edge or a leaf.
stackPointer--;
travStack[stackPointer].currNode = newNode(tx1, 8, tym, 6, tzm, 5);
}
else{
travStack[stackPointer].currNode = v4;
}
}
else{
travStack[stackPointer].currNode = newNode(tx1, 8, tym, 6, tzm, 5);
backfire = false;
}
break;
}
case 5:
{
if (!backfire){
stackPointer++;
int index5 = travStack[stackPointer - 1].node + (5 - a) - a4 + a2;
v5 = procSubtree(txm, ty0, tzm, tx1, tym, tz1, treeArray[index5]);
if (v5 == -1){ //Go up one level. Either hit empty, an edge or a leaf.
stackPointer--;
travStack[stackPointer].currNode = newNode(tx1, 8, tym, 7, tz1, 8);
}
else{
travStack[stackPointer].currNode = v5;
}
}
else{
travStack[stackPointer].currNode = newNode(tx1, 8, tym, 7, tz1, 8);
backfire = false;
}
break;
}
case 6:
{
if (!backfire){
stackPointer++;
int index6 = travStack[stackPointer - 1].node + (6 + a) - a4 - a2;
v6 = procSubtree(txm, tym, tz0, tx1, ty1, tzm, treeArray[index6]);
if (v6 == -1){ //Go up one level. Either hit empty, an edge or a leaf.
stackPointer--;
travStack[stackPointer].currNode = newNode(tx1, 8, ty1, 8, tzm, 7);
}
else{
travStack[stackPointer].currNode = v6;
}
}
else{
travStack[stackPointer].currNode = newNode(tx1, 8, ty1, 8, tzm, 7);
backfire = false;
}
break;
}
case 7:
{
if (!backfire){
stackPointer++;
int index7 = travStack[stackPointer - 1].node + (7 - a) - a4 - a2;
v7 = procSubtree(txm, tym, tzm, tx1, ty1, tz1, treeArray[index7]);
if (v7 == -1){ //Go up one level. Either hit empty, an edge or a leaf.
stackPointer--;
travStack[stackPointer].currNode = 8;
}
else{
travStack[stackPointer].currNode = v7;
}
}
else{
travStack[stackPointer].currNode = 8;
backfire = false;
}
break;
}
}
//itrCount++;
if (noiseAlpha >= 1.0){
break;
}
if (!(travStack[stackPointer].currNode < 8)){
stackPointer--;
backfire = true;
}
}
}
}