"Bald Eagle" <cre### [at] netscapenet> wrote:
> Alain Martel <kua### [at] videotronca> wrote:
>
> > > I keep on watching the speed at which real time GPU ray tracing / light
> > > transport technology advances.
> > > It seems quite amazing.
>
> > GPU render assume that everything will use the same code : The code for
> > a mesh of polygons. That assumption comes from the obligation to use the
> > same code for all cores.
> > POV Ray use many primitives. All of the primitives need to use their own
> > code. So, a GPU version of POV Ray could only deal with one primitive
> > type at a time. Render all the spheres, then, render all the boxes, then
> > the torus, then the cones and cylinders, then...
>
> Well that, or code a fork that converts all the primitives into polygon meshes
> before rendering.  Or just add in mesh alternatives for all of the primitives in
> case someone wants to use them...  It probably can't be that hard to copy most
> of the primitives into macro-driven mesh alternatives, especially since most of
> them could just be rendered as parametric surfaces that are made with triangle{}
> or mesh{} or mesh2{} objects, not the parametric{}.   Then you could just use
> the same macro code and pass in the relevant equations for x, y, and z as
> arguments.

If you had asked me this back in 2022, my answer would have been: "Yes, it is
technically possible, but it would be extremely expensive. It would require a
significant amount of engineering effort, and experienced graphics programmers
are not cheap."

It is important to note that modern GPUs can use RT Cores to accelerate Bounding
Volume Hierarchies (BVHs), including structures based on Axis-Aligned Bounding
Boxes (AABBs). The scene primitives themselves do not necessarily need to be
converted into polygons; their ray-intersection routines can be implemented
directly on the GPU and executed by the shader/CUDA cores. Vulkan API 1.4
extensions are capable of supporting this kind of architecture.

Today, in 2026, the situation is different. AI-assisted and agentic programming
can dramatically reduce development costs and accelerate implementation. What
previously required a large team of highly specialized engineers may now be
achievable by a small group of volunteers or enthusiasts.

I plan to experiment with these ideas in my spare time using POV-Ray 1, since
its codebase is much smaller and easier to understand:

https://github.com/OscarChavarro/povCpp

That said, if I continue working on it alone, it will likely still take several
months to produce meaningful results. Let's see what I can do for a proof of
concept.

Post a reply to this message