Change of architecture for multiple rays

[niccolot]

I wanted to implement dielectrics that both reflects and refract, i' ve came up with

Color color_from_scatter = Color();
    for (const auto& ray_t : srec.scattered_rays) {
        if (ray_t.skip_pdf || ray_t.pdf == nullptr) {
            color_from_scatter += srec.attenuation * ray_color(ray_t.skip_pdf_ray, depth-10, world, lights);
        } else {
            auto light_ptr = std::make_shared<HittablePDF>(lights, rec.point());
            MixturePDF p(light_ptr, ray_t.pdf);
            Ray scattered = Ray(rec.point(), p.generate(), r.time());
            auto pdf_value = p.value(scattered.direction());
            double scattering_pdf = rec.material()->scattering_pdf(r,rec,scattered);
            Color sample_color = ray_color(scattered, depth-1, world, lights);
                
            color_from_scatter += (srec.attenuation * scattering_pdf * sample_color) / pdf_value;
        }
    }

the loop goes over all scattered rays (which are just 1 for every other material except dielectrics which will have 2 rays) but the double recursion is very slow (indeed im subtracting a big number from depth instead of just 1), i wanted to ask what is the go-to approach for this kind of functionality and also if i should attenuate the rays (in the dielectrics the attenuation is just Color(1,1,1,)).

The result seems to be decent: on the glass ball you can see some reflection while still being transparent

[hollasch]

Nice approach. Personally, I agree with you that it would be good to attenuate by some non-zero amount, just to keep things real.

[hollasch]

I don't think the "double recursion" is getting you -- you're just firing off an additional ray for every reflection/refraction. That would give you more rays, but not necessarily more depth (as you noted). What you're probably seeing is that you now have a scene with two reflective objects, which gives rise to rays that bounce back and forth many many times (the depth part).

For example, make the sphere material a perfect mirror with no refraction, and I suspect you'll see a similarly greater render time. Fill a scene with many mirrored spheres and render times will take a significant hit.

One simple way to fix this is to use a material with non-zero attenuation. In addition, you could add code to halt recursion once all resulting color components are below 1/255. Or just manually cap the maximum depth (the quality drop would be quite small).

[hollasch]

Wait, never mind that last paragraph. This would need a bit more finesse — you want to halt recursion if the returned ray color, after subsequent attenuation from the scatter attenuation and PDF attenuation could not be more then some low threshold (like 1/255). This also implies that you have some understandable maximum ray color. For example, if you know that no material could ever give you a result of greater intensity than Color(1.0, 1.0, 1.0). This is a common trick for simple ray tracers, so I hadn't quite appreciated the fact that we don't have such logic. It might not be worth it, as it would slow down all scenes a bit in order to speed up other scenes (with deep recursion) a lot.

[niccolot]

If i understood well, you are suggesting to substitute

color_from_scatter += srec.attenuation * ray_color(ray_t.skip_pdf_ray, depth-10, world, lights);

with something like

auto sum = srec.attenuation * ray_color(ray_t.skip_pdf_ray, depth-10, world, lights);
if (sum.color ~ black) { // very pseudocode
    return color_from_emission + color_from_scatter;
else {
    color_from_scatter += sum;
}

with attenuation something like Color(0.9, 0.9, 0.9) instead of just Color(1,1,1) which would stop the recursion if the ray from a dielectric or lambertian is too dissipated? (i might be saying wrong things since i'm not too used to recursion) Also i'm not entirely sure where the 'maximum color' would take part in it

[hollasch]

Yeah, something like that. Or just set the maximum depth to something that yields roughly the same image. Just try specifying different max depths to see how it changes the image.

[niccolot]

Thanks a lot, i ll try implementing an additional control on the blackness of the color since i think capping the depth would have the same effect to choosing a lower depth and keeping the if (depth below 0). For the rest i ll keep the double recurion untill i came up with someting better, maybe at startert is best to have more interesting features like a triagle mesh and at the end trying to refactor the code to gain speed (?), but i might be wrong