трассировщик пути openCl создает странные шаблоны шума - PullRequest
Новая
       17

трассировщик пути openCl создает странные шаблоны шума

0 голосов
/ 07 декабря 2018

Я сделал трассировщик пути, используя openCl и c ++, следуя базовой структуре в этом уроке: http://raytracey.blogspot.com/2016/11/opencl-path-tracing-tutorial-2-path.html. Насколько я могу судить, нет ничего плохого в самом алгоритме трассировки пути, но я получаю странноеузоры полос на изображении, которые не соответствуют обычному шуму трассировки. полосатое изображение

Существуют четкие вертикальные полосы и более узкие горизонтальные полосы, которые делают изображение зернистым независимо от того, сколько образцов я беру на пиксель.Опять же, пиксель за пикселем, трассировщик пути, кажется, работает (контуры объектов правильны даже там, где они появляются в середине полосы), как показано здесь: крупным планом .

Единственное различие между моим кодом и тем, что в учебнике, на который я ссылаюсь, состоит в том, что Сэм Лапере, кажется, использует оболочку c ++ для openCl, и я добавил несколько функций, таких как перемещение.Есть также несколько отличий в том, как я справляюсь с легкими скачками.

Я новичок в openCl.Что может быть причиной этого?Кажется, что это не имеет отношения к моему самому трассировщику лучей, но каким-то образом я реализую openCl.Я также использую SDL-текстуру и средство визуализации, чтобы показать изображение на экране

вот код трассировщика, если он помогает:

kernel: 

__kernel void render_kernel
(__constant struct Sphere* spheres, const int width, const int height, 
const int sphere_count, __global int * output, __global float3* 
pixel_buckets, __global int* counter, __constant struct Ray* camera, 
__global bool* reset){

int gid = get_global_id(0);

//for movement
if (*reset){
    pixel_buckets[gid] = (float3)(0,0,0);
    counter[gid] = 0;
}

int xcoord = gid % width;
int ycoord = gid / width;

struct Ray camray = createCamRay(xcoord, ycoord, width, height, counter[gid], camera);

float3 final_color = trace(spheres, &camray, sphere_count, xcoord, ycoord);

counter[gid] ++;

//average colors
pixel_buckets[gid] += final_color;
output[gid] = colorInt(clampColor(pixel_buckets[gid] / counter[gid]));


}

trace: 

float3 trace(__constant struct Sphere* spheres, struct Ray* camray, const int sphere_count,
         unsigned int seed0, unsigned int seed1){

struct Ray ray = *camray;

struct Sphere sphere1;
sphere1.center = (float3)(0, 0, 3);
sphere1.radius = 0.7;
sphere1.color = (float3)(1,1,0);

const int bounce_count = 8;
float3 colors[20];
float3 emiss[20];

for (int bounce = 0; bounce < bounce_count; bounce ++){

    int sphere_id = 0;
    float hit_distance = intersectScene(spheres, &ray, &sphere_id, sphere_count);
    struct Sphere hit_sphere = spheres[sphere_id];
    float3 hit_point = ray.origin + (ray.direction * hit_distance);

    float3 normal = normalize(hit_point - hit_sphere.center);
    if (dot(normal, -ray.direction) < 0){
        normal = -normal;
    }

    //random bounce angles
    float rand_theta = get_random(seed0, seed1);
    float theta = acos(sqrt(rand_theta));
    float rand_phi = get_random(seed0, seed1);
    float phi = 2 * PI * rand_phi;

    //scales the tnb vectors
    float x = sin(theta) * sin(phi);
    float y = sin(theta) * cos(phi);
    float n = cos(theta);

    float3 hemx = normalize(cross(ray.direction, normal)) * x;
    float3 hemy = normalize(cross(hemx, normal)) * y;
    normal = normal * n;

    float3 new_ray = normalize(hemx + hemy + normal);

    ray.origin = hit_point + (normal * EPSILON);
    ray.direction = new_ray;

    colors[bounce] = hit_sphere.color;
    emiss[bounce] = hit_sphere.emmissive;

}

colors[bounce_count] = (float3)(0,0,0);
emiss[bounce_count] = (float3)(0,0,0);
for (int i = bounce_count - 1; i >= 0; i--){
    colors[i] = (colors[i] * emiss[i]) + (colors[i] * colors[i + 1]);
}
return colors[0];

}

генератор случайных чисел: 

float get_random(unsigned int *seed0, unsigned int *seed1) {

/* hash the seeds using bitwise AND operations and bitshifts */
*seed0 = 36969 * ((*seed0) & 65535) + ((*seed0) >> 16);
*seed1 = 18000 * ((*seed1) & 65535) + ((*seed1) >> 16);

unsigned int ires = ((*seed0) << 16) + (*seed1);

/* use union struct to convert int to float */
union {
    float f;
    unsigned int ui;
} res;

res.ui = (ires & 0x007fffff) | 0x40000000;  /* bitwise AND, bitwise OR */
return (res.f - 2.0f) / 2.0f;

}

спасибо

...