Godeffroy Valet

This OpenGL recorder is a thin OpenGL shared library that intercepts calls, records them, and forwards them to the system library. I developed this project solo within one year.

The company had frequent OpenGL bugs that were difficult to debug. By recording an OpenGL trace, then removing, adding, or modifying calls and/or data, and replaying the results, fast and precise debugging was possible. Another goal was to alter the OpenGL trace on the fly to enable advanced VR on any OpenGL software (like CAD).

One challenge was implementing all OpenGL calls (with extensions) involving thousands of functions. By parsing the GL headers with a Python script and using C++ metaprogramming, I automatically made a default implementation for all those calls. Relatively few overloads were left for exceptional cases.

Another challenge was to record all the necessary data. Many API calls take raw pointers to some data. Getting the correct size of this data in all possible situations and with as little code as possible was the main challenge. With a relatively small codebase, the code was fast and maintainable. Most bugs were found and solved in a few minutes.

I had been looking for real-time, physically accurate lighting with ray tracing in my previous renderers, but shadows were too sharp to look natural. The real world has penumbra, and the reason for this is that lights are all area lights, not point lights.

Unfortunately, ray tracing requires casting a lot of rays, and area lights make it much worse. In particular, a general area of light is the sky. Casting rays from every point in the sky is not an option for real-time lighting. So, I designed my lighting algorithm to handle area lights with physical accuracy in real-time. I implemented a proof of concept on the CPU to ease debugging and compared the result with an identical scene rendered in Blender with the Cycle.js renderer.

My algorithm was ten times faster, despite running on CPU and having the whole sky as a light, whereas Blender had a finite square. However, Blender's ray had a few bounces, while my algorithm didn't implement secondary lights—but they are area lights so that it could be done! I developed this project on my own within a few weeks.

A library that uses C++20 concepts extensively to precisely constrain math operations overloads. This makes it possible to make many optimizations at compile time, exploiting compile-time information as much as possible in every expression. In fact, the library can effectively act as a compile-time symbolic math library. For example, a succession of rotations and/or translations will be simplified at compile time and trigonometry formulas will be detected to simplify the expressions.

The types are generated in a bottom-top approach. No vector type is defined explicitly; they are generated by adding and multiplying numbers and directions. Therefore, any element of the universal algebra can be expressed, and only the necessary amount of memory will be used to store it. In this way, defining new algebras is easy. For example, define a type imaginary_t, overload the square function on it to return -one, and you have just defined your own copy of the complex numbers.

This approach also makes frames explicit, which removes a huge source of bugs. By writing 2m*north+1m*east, there is little chance of flipping north and east by mistake, and units are explicit. In comparison, writing Vector2d{1.0,2.0} easily leads to hidden bugs.

A hobby project for SLAM and SfM. I had been repeatedly disappointed by the OpenCV API because it's not flexible and it consistently leads to unpredictable bugs. This led me to make my own SLAM library in C++, using Eigen for maths, and to reimplement about half of the computer vision algorithms, such as epipolar geometry, triangulation, pose estimation, and RANSAC.

In the middle of development, OpenSfM was born, exactly filling the hole left by OpenCV in this field, so I decided to abort my project. Before ending the project, it performed the following steps:

1. Calibrated the camera.
2. Undistorted the images.
3. Computed optical flow, feature points, and their descriptors.
4. Indexed descriptors for matching.
5. Matched feature points.
6. Estimated the pose of the first camera.
7. Triangulated first points.
8. Estimated subsequent camera poses based on triangulated points.

The final steps were not yet very stable, but the reprojection error looked good.

An autonomous robot that detects and collects objects in a 1.5-meter x 2-meter playfield where another robot competes for the same objectives. The mechanical structure had to be designed especially for the contest's requirements.

The robot I built had a small embedded computer that gathered information from sensors and a webcam, made decisions, and sent commands to the motors to take action. The computer communicated with the microcontrollers via the CAN protocol. The robot knew its current position by integrating speed data from free wheel sensors and then computing its absolute position via the webcam data by recognizing known play area features. To go from one point to another quickly, the trajectories were made of pieces of clothoid, which are physically achievable curves that can turn without reducing speed too much.

This plugin allows you to add VR controls to any existing project while maintaining the ability to use keyboard and mouse controls. All controls are fully compatible with each other and can even be active at the same time.

1. Walk around in VR, see your motion controllers, and see a red dot where you point your right pointer and a green dot where you point your left pointer.

2. Rotate your VR space with the thumbstick on your left controller, and move it with the thumbstick on your right controller. These motions are discontinuous to reduce motion sickness.

3. Teleport to pointed location.

4. Grab the object pointed by your Motion Controller, remotely.

5. Grab objects with your VR hands: get close until your motion controller disappears, leaving your VR hand empty, then close your hand.

6. Drop hold objects by opening your hand. This way, you can also throw objects naturally. (Some controllers have a button on the side for grabbing. In this case, release this button to drop objects.)

7. Interact with the object pointed by your Motion Controller. The object needs to implement "InteractableInterface" provided by this plugin for this to do anything. You can also define EnterFocus/LeaveFocus events.

A real-time face-filtering engine for video chat. I developed the C++ and OpenGL parts, including shaders, loading, rendering 3D static or animated meshes and textures, face landmark detection, and background segmentation.

An off-line multi-scale Earth viewer supporting both raster and vector geographic data. A flexible configuration file enables specifying the location and type of data to display, e.g., satellite or political maps, country borders, rivers, among others. I developed it alone as a personal project. VR is enabled via my Cinder-VR library. It uses global elevation data and parallax occlusion mapping.

This C++ Unreal Engine plugin provides a secure way to communicate with the NEAR blockchain. It offers simple Blueprint functions to interact with smart contracts and query and transfer fungible and non-fungible tokens.

This UE plugin synchronizes 3D data between Unreal Engine and a web server, holding a representation of a digital universe. This data includes meshes, materials, positions, and object-specific attributes.