Raytracer | CPU Raytracer algorithm with shadows reflections | Graphics library

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. `

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 am currently working on a raytracer project and I just found out a issue with the triangle intersections.

Sometimes, and I don't understand when and why, some of the pixels of the triangle don't appear on the screen. Instead I can see the object right behind it. It only occurs on one dimension of the triangle and it depends on the camera and the triangle postions (e.g. picture below).

Triangle with pixels missing

I am using Möller-Trumbore algorithm to compute every intersection. Here's my implementation :

I'm stuck with how I should best make a world in Rust (it's for a raytracer). I've tried to make a small example here.

See playground here. I get lots of different lifetimes errors so maybe it's easier for you to just look at the code.

If I try and compile the makefile in this plea for help, the terminal gives me the following for all my object files:

I know there are a lot of resources on this, but none of them have worked for me.
Some are: webgl readpixels is always returning 0,0,0,0,
and this one: https://stackoverflow.com/questions/44869599/readpixels-from-webgl-canvas\ as well as this one: Read pixels from a WebGL texture
but none of them have been either helpful or successful.

The goal: Render an offscreen canvas with a WebGL shader, then use that as a texture in a separate WebGL shader.

Notes:

• For these WebGL shaders, I'm using a generic vertex shader used for pixel shaders, specifically, a raytracer/raymarcher. This is: attribute vec2 a_position; void main() { gl_Position = vec4(a_position.xy, 0.0, 1.0); }. This vertex shader is inputted two triangles that cover the screen, so basically the fragment shader is doing all the work.

Problem: In order to get the image data off of the offscreen canvas, I've tried these methods:

1. The WebGL gl.readPixels function