raytracer | Raytracer written in Rust following https

I am writing a raytracer using Java, but I ran into an issue with intersections between rays and triangles. I am using the algorithm given at Scratchapixel, but it is not working properly.

I am testing it using the following code:

I have a raytracer that I need to use in combination with traditional triangle projection techniques, I need to make the raytraced image be able to occlude projected triangles. The easiest way would be to write depth values directly to a depth buffer.

Apparently imageStore can only work with color images. Is there a mechanism I can use? The only alternative is to store depth in a color image and then make a dummy shader that sets the depth in a fragment shader.

Hello I build a raytracer in java and everything works fine but if i set 3 spheres on the same z axis the reflection doesnt work and if I change the z axis from the spheres it will work fine. In the following you can see the picture. There you can see the one sphere does the reflection correctly if it is not on the same z axis.

[Raytracer] [1]: https://i.stack.imgur.com/MSeCp.png

In the following is my code for calculate the Intersection.

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.

Copying a VkImage that is being used to render to an offscreen framebuffer gives a black image.

When using a rasterizer the rendered image is non-empty but as soon as I switch to ray tracing the output image is empty:

I have a simple fasm program, in this program I get some zeroed memory from windows through VirtualAlloc. I then have a procedure where I simply set up the parameters and make a call to StretchDIBits passing a pointer to the empty memory buffer. I therefore expect the screen should be drawn black. This however is not the case, and I can't for the life of me figure out why.

Below is the code.

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.

I've been trying to write a raytracer but I came across a problem when trying to implement simple diffuse calculations (trying to replicate the first ones from Ray Tracing in One Weekend but without a guide)

Here's the relevant code:

Intersection/diffuse calculations:

I am making a raytracer, im trying to use pthread to divide the rendering. i noticed that isnt helping with the speed because the function pthread_join is to slow, if i use a loop to make the 'await' is way faster and works almost every time fine. But i cant use that because the time of rendering changes with the scene. Is there a way to check if a thread is finished, on a more efficient way. This is the code. `