When it comes to rendering 3-dimensional computer-generated images there are 2 possible approaches: “Rasterization”, which is used by almost all graphic engines because
of its efficiency and “Ray Tracing.”
The “Ray Tracing” method, developed for the first time in 1968 (but improved upon
since) is even today more expensive in computation than the “Rasterization” method.
As a result, it is not yet fully adapted to real time use-cases but it produce a much higher
degree of visual realism.
Ray tracing is a sophisticated computer graphics technique that replicates the behavior of light in a virtual environment to produce highly realistic and detailed images. It operates by initiating rays from a virtual camera through each pixel on an image plane. These rays are then traced through the scene, testing for intersections with objects. Upon intersection, the properties of the surface are evaluated, including its interaction with light sources and environmental factors. Secondary rays are often cast to simulate effects like reflections, refractions, shadows, and global illumination. This recursive process captures intricate light interactions. The resulting color and intensity information carried by the rays is accumulated and blended to compute the final pixel colors. This culminates in the rendering of the scene, showcasing how light interacts with virtual objects and surfaces. While immensely capable of generating stunning visuals, ray tracing is computationally demanding, necessitating powerful hardware and often involving optimization methods to manage its complexity.
Light transport is a fundamental principle in ray tracing, enabling the simulation of realistic lighting interactions within a virtual environment. Ray tracing starts by casting rays from a virtual camera through each pixel on the image plane, simulating the paths that light rays would take. These rays are traced as they travel through the scene, checking for intersections with objects. When an intersection is found, the properties of the surface are assessed, taking into account its interaction with various light sources and environmental conditions. To capture intricate lighting effects, secondary rays are often cast, representing reflections, refractions, shadows, and global illumination. These secondary rays can themselves generate more rays in a recursive process, simulating complex light behaviors. As rays traverse the scene, they accumulate color and intensity information, which is then blended to compute the final colors for each pixel. This comprehensive process ultimately yields a rendered image that portrays how light interacts with virtual objects and surfaces, delivering a high degree of visual realism. However, due to its computational complexity, achieving accurate light transport often requires advanced optimization techniques and robust hardware resources.
 |
 |
| Reflection | Refraction |
|---|---|
 |
 |
| Example |
|---|
 |
 |
 |
 |
 |
 |
 |
|
| --------- |
 |
To clone and run this application, you'll need Git and Minilibx installed on your computer.
From your command line:
# Clone this repository
$ git clone https://github.com/jrayoub/miniRT42.git
# Go into the repository
$ cd miniRT42
# Build the Project
$ Make bonus
# Run the app
$ ./miniRTBONUS ./scene/Bonus/<scene_name.rt>
## replace <scene_name.rt> with the name of scene you want to render - Minilibx 42 -MiniLibX is a tiny graphics library which allows you to do the most basic things for rendering
something in screens without any knowledge of X-Window and Cocoa. It provides so-called simple window creation,
a questionable drawing tool, half-ass image functions and a weird event management system.
Ray tracing from scratch [C++ & SDL2]
Ray-Tracing Rendering Technique
- raytracing - a ray tracer created from scratch in C++ using the SDL2 library
MIT
jrayoub.github.io · GitHub @jrayoub · Twitter @Ayoub_Aitouna