This portfolio isn't maintained anymore, please my website for an updated portfolio.
Physically based Monte Carlo path tracer written with the HIP RT and Orochi libraries. HIPRT is AMD's equivalent to OptiX. It allows the use of the ray tracing accelerators of RDNA2+ AMD GPUs and can run on NVIDIA devices as well (although it wouldn't take advatange of RT cores) as it is not AMD specific. Thanks to the Orochi library, device kernels are compiled at run time and the application doesn't have to be recompiled to be used on a different device.
Being interested in hardware architecture and software performance, I am following Casey Muratori's online course "Performance Aware Programming": https://www.computerenhance.com/ .
The lectures he gives focus on giving an understanding on modern CPU architecture. The underlying goal is to provide insight on the expected performance of an application and how to profile and optimize it.
What I learnt thanks to his course:
- CPU Cycles wastes in modern software
- Intel 8086 Assembly (instructions encoding/decoding, 8086 registers).
Path tracing rendering engine (Monte Carlo integration) written with the Owl library, a wrapper around OptiX 7 which NVIDIA's general (not reserved to rendering) ray tracing framework that can make use of the ray tracing hardware accelerators of NVIDIA GeForce RTX™ GPUs.
Implemented features:
- Direct lighting
- Indirect lighting
- Cook Torrance BRDF
- Diffuse textures
- Smooth normals
- ImGui Integration
- Integration of NVIDIA's OptiX™ AI-Accelerated Denoiser
Personnal project made with CUDA in pure C that implements the Canny edge detection filter.
Steps of the detection:
- Gaussian blur pass to reduce high frequencies in the image (reduces the risk of false positive edge detections due to the noise in the image)
- Sobel filter to detect edges (gradients)
- Apply a threshold to eliminate edges (gradients) that are too weak
- Double thresholding: separates "weak" from "strong" edges according to 2 thresholds given at execution.
- Hysteresis to keep only significant edges : "strong" edges or "weak" edges connected to a strong edge (8-connexity)
Image source: wikipedia
Path tracing engine written in C++. This project was initially written using SYCL. SYCL is a standard written by the Khronos Group that allows one C++ code to be ran on multiple devices including CPUs, GPUs and even FPGA accelerators. Unfortunately, I have been facing issues (discussions with Intel can be found here and here) with SYCL that lead me to reimplement it in pure C++ (the task was pretty much effortless as a SYCL code is already very close to pure C++).
This project has been superseded by my HIPRT-Path-Tracer written with the HIPRT GPU Ray Tracing API and largely expanded in functionalities.
Implemented features:
- Direct lighting
- Indirect lighting
- Microfacet BRDF (Cook Torrance BRDF) : Roughness and metallic
- Cook Torrance BRDF Importance Sampling
- HDR Environment Map
- Environment Map Importance Sampling
- Multiple Importance Sampling
- Tone mapping HDR (gamma and exposition)
- Octree based BVH + 7 planes bounding volumes
- Linear BVH adapted for GPU computations
- Intel® Open Image Denoise integration
Real-time rendering engine written in C++ and OpenGL 4.3.
Implemented features:
- ImGui integration
- Frustum culling
- Shadow mapping (Percentage closer filtering)
- Microfacet BRDF : Metallic and roughness
- Textures : Diffuse, mettalic, roughness, normals (normal mapping)
- Normal mapping (left with, right without)
- Irradiance Mapping (precomputation of the diffuse irradiance component from an environment map)
- Skyspheres & skyboxes support
- HDR tone mapping (gamma et exposition)
This project implements the representation of implicit surfaces using SDFs and their meshing using a marching cube algorithm. Some boolean operators are also defined on the SDFs (union, smooth union, intersection, difference, ...). Signed distance functions are very powerful tools (cf. Inigo Quilez' Shadertoy profile). This project also implements revolution surfaces, generation of a mesh from a Bezier surface description and mesh local deformations.
Implemented features:
- Signed distance functions
- Boolean operators on SDFs (union, smooth union, intersection, difference, ...)
- Ray marching algorithm for meshing an SDF
-
Meshing of a Bezier surface with arbitrary precision
-
Local deformation of a mesh
-
Revolution surfaces using a Bezier curve as the revolution profile
-
Mesh twisting operator
Computational geometry project that manipulates a data structure representing meshes and that allows efficient implementations of computational geometry algorithms.
Implemented features:
- Insertion of a point outside or inside the convex hull of a triangulation + automatic meshing of the point into the existing triangulation
- Lawson algorithme to improve the quality of an existing triangulation by making a Delaunay triangulation
- Rupert algorithm (triangulation of a planar straight-line graph)
CPU ray-tracer + rasterizer entirely done in C++ and Qt6 for the interface.
Implemented features:
- Qt6 C++ Interface
- Ray tracing rendering
- Rasterization rendering
- Hybrid rendering (rasterization of the visibility + ray tracing for the shading)
- Clip-space clipping algorithme
- Hard shadows (shadow rays)
- Octree based BVH + 7 planes bounding volumes
- Rough reflexions (random ray cast around the normal)
- Normal mapping
- Diffuse texture, roughness map, ambient occlusion mapping
- Parallax occlusion mapping
- Skyspheres support
The mesh of the sphere is perfectly flat (analytic sphere). The perceived geometry is only due to the parallax mapping algorithm. - Skyboxes support
- Super Sampling Anti Aliasing (SSAA)
- AVX2 Screen Space Ambient Occlusion (SSAO) implementation
- Hair modelisation
Group project that implements some edge and line detection algorithms in an image. OpenCV was used only for loading and displaying images.
Implemented features:
- Local thresholding method (useful when the same image contains variations in brightness):
The top right of the sudoku grid is brighter than the bottom left part of the image. A global thresholding approach is thus ineffective:
Half of the edges aren't detected because one single threshold can only match half of the image.
A local thresholding approach is much more effective:
Le thresholding level is ajusted according to the local brightness of the image. Global brightness changes barely affect this method and the results are way better than those obtained with a global thresholding.
- Hough Transform (line detection):
From left to right:
- Edge detection of a cube with a Kirsch filter
- Visualization of the
$\rho$ and$\theta$ parameters of the detected lines in Hough space - Lines retained after thresholding the Hough space and delimiting the lines.
Ray tracing rendering engine (direct lighting, no rendering equation estimation) entirely written in Java. The interface was written using JavaFX.
Implemented features:
- Skysphere (non HDR)
- Procedural checkerboard texture
- Analytical planes and spheres
- Rough reflexions
- SSAA Anti-aliasing
- Fresnel effect
- Refractif materials
- Mirror materials
- Diffuse materials
