Making an iterative example of ray_color function.

[jaysonpowers-zz]

So I'm trying to make a compute shader in opengl to run ray tracing in one weekend inspired code, but I'm finding it hard to turn ray_color into an iterative function. Shaders in GLSL or HSL can't do recursion, and in college I was never taught how to transform them. I know the most common way is to make a stack array, but honestly this is very confusing how to apply it to ray_color, any help would be appreciated!

[jaysonpowers-zz]

Someone suggested tail recursion to do the function, but isn't the end of the tail of ray_color some combination of the background color? Why would the background color be a factor in the ray of the sphere, and if it's not doing that, then the tail is black, and black multiplied by any color is black. So I'm just guess the contribution of the background is so little it's irrelevant. Am I missing something?

[trevordblack]

If you can read cuda, I would recommend reading the section within

https://developer.nvidia.com/blog/accelerated-ray-tracing-cuda/

entitled Iteration vs. Recursion

[jaysonpowers-zz]

Thanks I'll take a look at it, not too familiar with cuda, but I've looked at its samples before.

[jaysonpowers-zz]

Perfect, that was exactly what I was looking for, thanks!

[ranjian0]

Faced this exact problem some while back. Found the solution in another repo which had a raytracer implemented as a fragment shader. Can't quite rediscover the repo now.

You can take a look at my solution here:
https://github.com/ranjian0/python-compute-shaders/blob/master/shaders/pathtracer/tracer_cs.glsl

@trevordblack Thanks for the article. Wish I had stumbled upon that when I was struggling with this.
@jaysonpowers Good luck.

[jaysonpowers-zz]

Thanks, just took a look at your code, it looks nice!

[D-K-E]

I brought this up in one of the issues.
At the time, I managed to render diffuse spheres scene without recursion and without a need for a call stack whose level is defined by a macro.
I have also done a similar project in the past with compute shaders. However as the number of objects increases, the use of acceleration structures becomes an imperative.
For that I can recommend the list, but even with that I would not be so sure if compute shaders would give you a decent performance.

[Morozov-5F]

I'm not sure if this is still relevant, but I've got implementation of iterative ray_color function. As it turns out, recursion in that case means just a fancy way of writing a for-loop. I had the proof somewhere that the code is equivalent but I've lost it. Basic idea of the proof is to build a recursion tree of the recursive ray_color and basically see that it doesn't branch much and could be converted to the iterative loop.