voxelizer片段着色器：

Question

注意：此问题已从其原始表格中进行了彻底的编辑

我试图通过实现与体素化相结合的oct树数据结构来创建对数光线跟踪器，以实现快速光线跟踪。

目前我遇到了光线碰撞检测问题。

预期的输出应该是具有法线贴图的体素化斯坦福龙。

问题在于，某些地区是透明的：

完整的龙：

透明区域：

从这些图像中可以清楚地看出几何图形是正确的，但碰撞检查是错误的。

此过程涉及2个片段着色器：

voxelizer片段着色器：

#version 430

in vec3 f_pos;
in vec3 f_norm;
in vec2 f_uv;

out vec4 f_color;
struct Voxel
{
    vec4 position;
    vec4 normal;
    vec4 color;
};

struct Node
{
    int children[8];
};

layout(std430, binding = 0) buffer voxel_buffer
{
    Voxel voxels[];
};
layout(std430, binding = 1) buffer buffer_index
{
    uint index;
};
layout(std430, binding = 2) buffer tree_buffer
{
    Node tree[];
};
layout(std430, binding = 3) buffer tree_index
{
    uint t_index;
};

out vec4 fragment_color;

uniform int voxel_resolution;
uniform int cube_dim;

int getVIndex(vec3 position, int level)
{
    float size = cube_dim / pow(2,level);

    int bit2 = int(position.x > size);
    int bit1 = int(position.y > size);
    int bit0 = int(position.z > size);

    return 4*bit2 + 2*bit1 + bit0;
}

void main()
{

    uint m_index = atomicAdd(index, 1);

    voxels[m_index].position = vec4(f_pos*cube_dim,1);
    voxels[m_index].normal = vec4(f_norm,1);
    voxels[m_index].color = vec4(f_norm,1);

    int max_level = int(log2(voxel_resolution));
    int node = 0;
    vec3 corner = vec3(-cube_dim);
    int child;

    for(int level=0; level<max_level-1; level++)
    {
        float size = cube_dim / pow(2,level);
        vec3 corners[] =
            {corner,                    corner+vec3(0,0,size),
            corner+vec3(0,size,0),      corner+vec3(0,size,size),
            corner+vec3(size,0,0),      corner+vec3(size,0,size),
            corner+vec3(size,size,0),   corner+vec3(size,size,size)};

        vec3 offsetPos = (vec3(voxels[m_index].position));
       child = getVIndex(offsetPos-corner, level);

        int mrun = 500;
        while ((tree[node].children[child] <= 0) && (mrun > 0)){
            mrun--;
            if( (atomicCompSwap( tree[node].children[child] , 0 , -1) == 0 ))
            {
                tree[node].children[child] = int(atomicAdd(t_index, 1));
            }
        }

        if(mrun < 1)
            discard;

        if(level==max_level-2)
            break;

        node = tree[node].children[child];

        corner = corners[child];
    }

    tree[node].children[child] = int(m_index);

}

我理解逻辑可能不清楚所以让我解释一下：

我们从3D psoition voxels[m_index].position = vec4(f_pos*cube_dim,1);开始我们知道有一个维度的多维数据集（-cube_dim，-cube_dim，-cube_dim）到（cube_dim，cube_dim，cube_dim）所以一个立方体的对角线在原点相交，边长为2 * cube_dim。它被分成多个小方块，边长为2 * cube_dim / voxel_resolution。基本上这只是一个立方体细分n次以制作笛卡尔网格。

使用此坐标，我们从大立方体开始，将其细分为8个相等大小的子空间，并检测这些子空间中的哪些子空间符合坐标。

我们这样做直到找到包含该位置的最小框。

光线跟踪器

 #version 430

in vec2 f_coord;

out vec4 fragment_color;

struct Voxel
{
    vec4 position;
    vec4 normal;
    vec4 color;
};

struct Node
{
    int children[8];
};

layout(std430, binding = 0) buffer voxel_buffer
{
    Voxel voxels[];
};
layout(std430, binding = 1) buffer buffer_index
{
    uint index;
};
layout(std430, binding = 2) buffer tree_buffer
{
    Node tree[];
};
layout(std430, binding = 3) buffer tree_index
{
    uint t_index;
};

uniform vec3 camera_pos;
uniform float aspect_ratio;
uniform float cube_dim;
uniform int voxel_resolution;

float planeIntersection(vec3 origin, vec3 ray, vec3 pNormal, vec3 pPoint)
{
    pNormal = normalize(pNormal);
    return (dot(pPoint,pNormal)-dot(pNormal,origin))/dot(ray,pNormal);
}

#define EPSILON 0.001
bool inBoxBounds(vec3 corner, float size, vec3 position)
{
    bool inside = true;
    position-=corner;

    for(int i=0; i<3; i++)
    {
        inside = inside && (position[i] > -EPSILON);
        inside = inside && (position[i] < size+EPSILON);
    }

    return inside;
}


float boxIntersection(vec3 origin, vec3 dir, vec3 corner0, float size)
{
    dir = normalize(dir);
    vec3 corner1 = corner0 + vec3(size,size,size);

    vec3 normals[6] =
    { vec3(-1,0,0), vec3(0,-1,0), vec3(0,0,-1), vec3(1,0,0), vec3(0,1,0), vec3(0,0,1) };

    float coeffs[6];

    for(uint i=0; i<3; i++)
        coeffs[i] = planeIntersection(origin, dir, normals[i], corner0);
    for(uint i=3; i<6; i++)
        coeffs[i] = planeIntersection(origin, dir, normals[i], corner1);

    float t = 1.f/0.f;

    for(uint i=0; i<6; i++){
        coeffs[i] = coeffs[i] < 0 ? 1.f/0.f : coeffs[i];
        t = inBoxBounds(corner0,size,origin+dir*coeffs[i]) ? min(coeffs[i],t) : t;
    }

    return t;
}

void sort(float elements[8], int indices[8], vec3 vectors[8])
{
    for(uint i=0; i<8; i++)
    {
        for(uint j=i; j<8; j++)
        {
            if(elements[j] < elements[i])
            {
                float swap = elements[i];
                elements[i] = elements[j];
                elements[j] = swap;

                int iSwap = indices[i];
                indices[i] = indices[j];
                indices[j] = iSwap;

                vec3 vSwap = vectors[i];
                vectors[i] = vectors[j];
                vectors[j] = vSwap;
            }
        }
    }
}

int getVIndex(vec3 position, int level)
{
    float size = cube_dim / pow(2,level);

    int bit2 = int(position.x > size);
    int bit1 = int(position.y > size);
    int bit0 = int(position.z > size);

    return 4*bit2 + 2*bit1 + bit0;
}

#define MAX_TREE_HEIGHT 11
int nodes[8*MAX_TREE_HEIGHT];
int levels[8*MAX_TREE_HEIGHT];
vec3 positions[8*MAX_TREE_HEIGHT];
int sp=0;

void push(int node, int level, vec3 corner)
{
    nodes[sp] = node;
    levels[sp] = level;
    positions[sp] = corner;
    sp++;
}
void main()
{
    vec3 r = vec3(f_coord.x, f_coord.y, 1.f/tan(radians(40)));
    r.y/=aspect_ratio;
    vec3 dir = r;
    r += vec3(0,0,-1.f/tan(radians(40))) + camera_pos;

    fragment_color = vec4(0);
    //int level = 0;
    int max_level = int(log2(voxel_resolution));
    push(0,0,vec3(-cube_dim));
    float tc = 1.f;
    int level=0;
    int node=0;
    do
    {
        sp--;
        node = nodes[sp];
        level = levels[sp];
        vec3 corner = positions[sp];

        float size = cube_dim / pow(2,level);
        vec3 corners[] =
            {corner,                        corner+vec3(0,0,size),
            corner+vec3(0, size,0),         corner+vec3(0,size,size),
            corner+vec3(size,0,0),          corner+vec3(size,0,size),
            corner+vec3(size,size,0),       corner+vec3(size,size,size)};

        float t = boxIntersection(r, dir, corner, size*2);
        if(!isinf(t))
            tc *= 0.9f;

        float coeffs[8];
        for(int child=0; child<8; child++)
        {
            if(tree[node].children[child]>0)
                coeffs[child] = boxIntersection(r, dir, corners[child], size);
            else
                coeffs[child] = 1.f/0.f;
        }
        int indices[8] = {0,1,2,3,4,5,6,7};
        sort(coeffs, indices, corners);

        for(uint i=7; i>=0; i--)
        {
            if(!isinf(coeffs[i]))
            {
                push(tree[node].children[indices[i]],
                    level+1, corners[i]);
            }
        }
    }while(level < (max_level-1) && sp>0);

    if(level==max_level-1)
    {
        fragment_color = abs(voxels[node].normal);
    }

    else
    {
        fragment_color=vec4(tc);
    }

}
}

在这里，我们从最大的立方体开始，测试每组8个孩子的交叉点（通过细分立方体得到的8个立方体）。每次我们成功检测到碰撞时，我们都会向下移动树，直到达到描述实际几何体的最低级别，然后根据该颜色为场景着色。

调试和问题

重要的部分是有2个缓冲区，一个用于存储除树叶之外的树，另一个用于存储树叶。

因此，在体素化和光线追踪中，最后一层需要区别对待。

我注意到有关透明度的问题如下：

仅在与笛卡尔网格对齐的平面上发生
当光线向负方向移动（向下）时，似乎会发生这种情况或左边）。（至少那是我的推动，但它不是100％的一定）

我不确定我做错了什么。

编辑：

最初的问题似乎已得到修复，但光线跟踪仍然存在问题。我已经编辑了这个问题，以解决问题的当前状态。

Answer 1

错误来自排序功能，正如所提及的评论中的某人，尽管不是出于同样的原因。

发生的事情是，我认为sort函数会修改传递给它的数组，但它似乎是在复制数据，所以它不会返回任何内容。

换句话说：

void sort(float elements[8], int indices[8], vec3 vectors[8])
{
    for(uint i=0; i<8; i++)
    {
        for(uint j=i; j<8; j++)
        {
            if((elements[j] < elements[i]))
            {
                float swap = elements[i];
                elements[i] = elements[j];
                elements[j] = swap;

                int iSwap = indices[i];
                indices[i] = indices[j];
                indices[j] = iSwap;

                vec3 vSwap = vectors[i];
                vectors[i] = vectors[j];
                vectors[j] = vSwap;
            }
        }
    }
}

不会在元素，索引和向量中返回正确的值，因此调用此函数只会浪费计算周期。

oct树生成错误的最后一步

voxelizer片段着色器：

光线跟踪器

调试和问题

1 个答案: