RayTracing | Simple ray tracing library in Python for optical design

I am trying to port the "RayTracing in One Weekend" into metal compute shader. I encounter this strip artifacts in my project:

Is it because my random generator does not work well?

Does anyone have a clue?

I use this reverse-bit method of iteration for rendering tasks in one dimension, the goal being to iterate through an array with the bits of the iterator reversed so that instead of computing an array slowly from left to right the order is spread out. I use this for instance when rendering the graph of a 1D function, because this reversed bit iteration first computes values at well-spaced intervals a representative image appears only after a very small fraction of all the values are computed.

So after only a partial rendering we already have a good idea of how the final graph will look. Now I want to apply the same principle to 2D rendering, think raytracing and such, the idea is having a good overall view of the image being rendered even from an early stage. The problem is that making the same idea work as a 2D iteration isn't trivial.

Here's how I do it in 1D:

How do I find all pixels overlapping a parabola (supercover) in an interval defined by two points on the parabola efficiently? All coordinates are integers, grid cells are 1x1 in size. The parabola is given by f(x) = ax^2 + bx where a and b are known (assume c = 0)

I found this implementation of finding all grid cells overlapping a line. How could it be adapted to use a parabola? http://playtechs.blogspot.com/2007/03/raytracing-on-grid.html

I was working on my ray tracer written in C++ following this series of books: Ray Tracing in One Weekend. I started working a little bit on my own trying to implement features that weren't described in the book, like a BVH tree builder using SAH, transforms, triangles and meshes.

NOTE: The BVH implementation is based on two main resources which are this article: Bounding Volume Hierarchies and C-Ray (A ray tracer written in C).

After I implemented all of that I noticed that there was some weirdness while trying to use some materials on meshes. For example, as the title says, the metal material looks completely black:

In the first image you can see how the metal material should look like and in the second one you can see how it looks like on meshes.

I spent a lot of time trying to figure out what the issue was but I couldn't find it and I couldn't find a way of tracking it.

If you want to take a look at the code for more clarity the ray tracer is on GitHub at https://github.com/ITHackerstein/RayTracer. The branch on which I'm implementing meshes is meshes.

To replicate my build environment I suggest you follow this build instructions:

$ git clone https://github.com/ITHackerstein/RayTracer

$ cd RayTracer

$ git checkout meshes

$ mkdir build

$ cd build

$ cmake ..

$ make

$ mkdir tests

At this point you're almost ready to go except you need the TOML scene file an the OBJ file I'm using which are these two:

• boh.toml (Scene file)
• teapot.obj (Teapot OBJ file)

Download them and place them in the build/tests and after that make sure you are in the build folder and run it using the following command:

$ ./RayTracer tests/boh.toml

After it finishes running you should have a tests/boh.ppm file which is the resulting image file stored using PPM format. If you don't have a software that let's you open it there are multiple viewers online.

NOTE: My platform is Linux, I didn't test it on Windows or Mac OS.

EDIT

Does the mesh work with other materials?

So as you can in the first image and especially in the second one we have we have some darker rectangular spots, and also the lighting seems kinda messed up. In the third image you have an idea of how it works on a normal primitive.

I have created a three.js element to show a number of points on the screen and I have been tasked with clicking on two and calculating the distance between them. I am doing this in a Angular (8) app and have all the points visible and mouse events (pointerup/down) set up correctly. My idea is to ray trace from the mouse point when clicked and highlight a vertex (I do only have points no lines or faces). So I have attempted to set up Three.js RayTRacing on my scene but every time I call setFromCamera the camera is undefined even though I srill have the points visible on the screen at all times.

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.