RayTracing | Realtime GPU Path tracer based on OpenCL and OpenGL | GPU library

As far as I know, all the techniques mentioned in the title are rendering algorithms that seem quite similar. All ray based techniques seem to revolve about casting rays through each pixel of an image which are supposed to represent rays of real light. This allows to render very realistic images.

As a matter of fact I am making a simple program that renders such images myself based on Raytracing in one Weekend.

Now the thing is that I wanted to somehow name this program. I used the term “ray tracer” as this is the one used in the book.

I have heard a lot of different terms however and I would be interested to know what exactly is the difference between ray tracing, ray matching, ray casting, path tracing and potentially any other common ray-related algorithms. I was able to find some comparisons of these techniques online, but they all compared only two of these and some definitions overlapped, so I wanted to ask this question about all four techniques.

After watching videos and reading the documentation on DXR and DX12, I'm still not sure how to manage resources for DX12 raytracing (DXR).

There is quite a difference between rasterizing and raytracing in terms of resource management, the main difference being that rasterizing has a lot of temporal resources that can be bound on the fly, and raytracing being in need of all resources being ready to go at the time of casting rays. The reason is obvious, a ray can hit anything in the whole scene, so we need to have every shader, every texture, every heap ready and filled with data before we cast a single ray.

So far so good.

My first test was adding all resources to a single heap - based on some DXR tutorials. The problem with this approach arises with objects having the same shaders but different textures. I defined 1 shader root signature for my single hit group, which I had to prepare before raytracing. But when creating a root signature, we have to exactly tell which position in the heap corresponds to the SRV where the texture is located. Since there are many textures with different positions in the heap, I would need to create 1 root signature per object with different textures. This of course is not preferred, since based on documentation and common sense, we should keep the root signature amount as small as possible. Therefore, I discarded this test.

My second approach was creating a descriptor heap per object, which contained all local descriptors for this particular object (Textures, Constants etc..). The global resources = TLAS (Top Level Acceleration Structure), and the output and camera constant buffer were kept global in a separate heap. In this approach, I think I misunderstood the documentation by thinking I can add multiple heaps to a root signature. As I'm writing this post, I could not find a way of adding 2 separate heaps to a single root signature. If this is possible, I would love to know how, so any help is appreciated.

Here the code I'm usign for my root signature (using dx12 helpers):

I was hit with the possibly-uninitialized variable error, although I'm convinced that this should never be the case.
(The rustc --version is rustc 1.51.0 (2fd73fabe 2021-03-23))

When you create a BLAS (bottom level acceleration structures) you specify any number of vertex/index buffers to be part of the structure. How does that end up interacting with the shader and get specified in the descriptor set? How should I link these structures with materials?

How is texture mapping usually done with raytracing? I saw some sort of "materials table" in Q2RTX but the documentation is non-existent and the code is sparsely commented.

Whenever I am rendering a window for a test raytracer in opengl with the GLFW library for C++ , the window works fine up to a point where if I just hover , not outside of the window , but over its white top handle , whether it is to move the window or minimize it , the window and the whole program just crashes with no error output , even tho I am not using any try-catch block or any noexcept keyword inside the whole program , and I'm using std::shared_ptr for pointer management.

Here's the main function (variables written in caps that aren't from glfw or opengl are defined in another file , but not initialized):

I've been following along in the (very awesome) nvpro raytracing tutorial and have a question about the way the CameraProperties uniform buffer is bound using layout(binding = 0, set = 1) - I understand the binding = 0, but why set = 1?

The tutorial says "The set = 1 comes from the fact that it is the second descriptor set passed to pipelineLayoutCreateInfo.setPSetLayouts", but when I look at HelloVulkan::createGraphicsPipeline() I see the layout count is one, and this is where m_descSetLayout (what binds the camera uniform buffer) is used. What am I missing?

The related section of the tutorial is here.

Thanks!

Is it possible to do AFR in D3D12 with two RTX 2060 graphics cards?

I have a custom rendering framework that supports AFR with D3D12 but just read Nvidia dropped SLI support however I'm having trouble finding a clear answer as to what this means when it comes to D3D12 / Vulkan APIs. Did they drop just SLI driver support but Linked-GPU support still works as normal in D3D12?

If I buy two RTX 2060 graphics cards can I set them up as a "GPU 0 (Link 0) & GPU 1 (Link 0)" in Windows and then in D3D12 use them as a node group?

I want to add RayTracing into my API but want to test AFR / mGPU support with it & Nvidia has made this very unclear about what this means for D3D12 / Vulkan.

I have an application (based on the vulkan-tutorial.com) in which I use the titular raytracing extension for vulkan. In it, an acceleration structure is created for some geometry. This geometry then changes (vertices are displaced dynamically, per frame), and thus I update the appropriate BLAS by calling vkCmdBuildAccelerationStructureKHR with VkAccelerationStructureBuildGeometryInfoKHR::update = VK_TRUE. This works fine (although the update ignores my changing the maxPrimitiveCount and similar parameters - It uses as many primitives as I specified during the first build; somewhat makes sense to me and is not part of my question).

I've researched a bit and came across some best practices here: https://developer.nvidia.com/blog/best-practices-using-nvidia-rtx-ray-tracing/ In there, they mention this: "Consider using only rebuilds [of the BLAS] with unpredictable deformations." This seems like something I want to try out, however, I can't find any sample code for rebuilding BLAS, and if I simply set update to VK_FALSE, I get massive amounts of validation layer errors and no image on screen. Specifically, I get a lot of "X was destroyed/freed but was still in use" where X is command buffers, VkBuffers, memory, fences, semaphores... My guess is the rebuild is trying to free the BLAS while it's still in use.

My question is therefore: How do you properly perform a "rebuild" of a BLAS, as mentioned in the above article?

I was considering using some std::shared_ptr to keep track of the BLAS being still in use by a given swapchain image but that seems excessively complicated and somewhat unclean, besides, I would need as many BLAS as I have swapchain images, multiplying required graphics memory by the swapchain size... that can't be practical in real life applications, right?

I create an OpenGL texture/CUDA surface pair from some RGB data with a function. The cudaSurfaceObject_t can be used in a CUDA kernel for GPU-accelerated image processing, and the GLuint can be used to render the results of the CUDA kernel. The function is provided in the program below: