Flow field simulation

• I did this project in a High Performance computing class I took during my exchange at the Institute of Technology of Tokyo.
• The simulation algorithm was written in C++ (using Navier Stokes equations with incompressible fluid hypothesis). We had to implement it using CUDA API and test it on the university's GPU cluster, Tsubame.
• I made a few optimizations when switching to CUDA, including using CUDA streams and shared memory which made the code 7 times faster than the basic version with global memory. However, it had some drawbacks: with the use of shared memory, I was limited by the size of particles I could set.

Raytracer

• This project consisted in improving a basic raytracer given by the teacher with various features which were up to us to choose.
• I decided to implement direct and indirect illuminations with two BRDFs: Cook-Torrange and Blinn-Phong, Monte-Carlo sampling (to reduce noise when generating random rays) and caustics.
• Note that the framerate is significantly decreased when using both Cook-Torrance BRDF and caustics.
• You can find a picture of the raytracer provided by the teacher in the last picture, so you can observe what I added to the project.

< >

Cloth Simulation from scratch

• This is a simulation of cloth I chose to tackle for a class I was taking as an external student (which is why I consider this more as a personal project).
• I used CUDA to perform the numerical integration of the cloth model and the collisions with an object, and OpenGL for the render part (which is very simple). OpenGL/Cuda interoperability has been used to allow keeping all buffers on GPU side.
• I did this project to learn more about physically based simulations (especially collisions detection/response for soft shells), acceleration structures for collisions and their practical use on GPU.
• Unfortunately, this project is unfinished and they are many elements I wish I could improve now: some collisions are not quite stable over time, especially with dynamic colliders that require a BVH update each collision step. Also, the cloth model is based on the mass-spring model which is quite simple but physically inaccurate. Still, I quite enjoyed working on it and plan on taking it up again in the future to fix the current bugs and properly add the cloth/cloth collisions in real-time (a small glimpse is given at the last image).
• If you wish to learn more about the project, you can definitely check out the report I submitted for the class (link below). Note that some things may have changed since I wrote this report but the general idea is the same.

< >

Particle system

• School project to make us learn how to program in C++. We built a particles system from scratch (including a n-dimensional vector library).
• The particles evolve in a n-dimensional univers (could be 1D, 2D or 3D) under three types of constraint (reflexion, absorption and transportation from a wall to its symmetric). Particles are also subjected to gravity and to Lennard-Jones potential which is initially really expensive as it corresponds to a double sum over the whole set of particles.
• In order to optimize the computation, we had to create a grid which helped us reduce Lennard Jones' potential computations to the ones obtained with the neighbors of each particle. We also made other optimizations regarding data structures as well.
• The positions of the particles in the set were written in a file that can be opened in Paraview.

Software development project: building a compiler for a subset of Java

• In a team of 5, we implemented a complete compiler for a sub language of Java (called Deca, specifically created by our school for this project) which contains basic concepts of Java, such as : loops (iterative, conditional), object oriented concepts (child, parent) and operations. Our job also included to add a huge database of tests to make sure our implementation of the compiler was robust.
• This project lasted a whole month during which we had to go through several precise steps, including: a parser, a lexer (semantics) and generating assembly code and write the corresponding tests before coding or in the meantime.
• During this whole month, we worked in Agile method and had weekly meetings with a school tutor who was following our advancement.
• We also got to implement an extension for this sub-language which involved the use of static arrays (of N dimensions). Our final note for this project was 16.5/20

3D reconstruction and modification of a face using geometry modeling

• Given a 3D mesh of a human head made of an important amount of points, we had, as a team, to reconstruct a simpler version of a part of that face using geometry modeling (Bézier curves, B-splines and least square method).
• The first step was to select a zone of the head for which we constructed an approximation of that area using B-splines surfaces. (1st picture)
• A least square approximation with constraint at the borders was performed to get the control points of the Bézier surface, which could then be modified using the mouse (2nd and 3rd pictures).
• The last step was to knit the surface back onto the face using a Poisson surface reconstruction algorithm in MeshLab (4th and 5th pictures).

Robot game

• Project consisting in creating a small simulation of robots firefighters in order to learn properly object oriented programming.
• Robots share both common and indivual properties (speed, water capacity, etc) and are directed by a chef robot which is invisible in the simulation.
• The chef robot is supposed to be intelligent as it needs to place the robots in order to put out the fires as quickly as possible. Therefore, the project also contains an optimization part: for instance, we used Djikstra algorithm to compute the smallest path between an input point (robot position) and a set of target points (fires or puddles).

Library for graphical interfaces

• Library coded entirely in C, similar to tkinter in python. Can be used to build simple games or applications.
• Uses the concept of widgets (buttons, frames, toplevels) and geometry managers to place elements on the screen. The library handles the addition of new types of widgets or geometry managers by the user.
• This project enabled me to manipulate many aspects of programmation such as event programming or polymorphism in C structures (used for object-oriented programming). It really helped me enhance my level in C as a huge part of the project consisted in debugging, finding memory errors and leaks and optimizing the code to gain fluidity when moving the top levels.

< >

Modelisation of Monte Carlo's method

• Computation of pi's approximation using Monte Carlo's method with the given parameters in the command line.
• Generation of an animated image (GIF) showing the evolution of pi's approximation, using .ppm images format (each pixel is given an RGB code). The writing of each approximation is done with a 7-segment display for each digit that changes the pixel in black.
• This project built from scratch helped me work on python and on optimization using various data structures (dictionnary, iterators, tables, etc).

3D multiplayer game and game engine from scratch

• BlackSeas is a navigation/exploration game taking place in an infinite procedural world made mostly of archipelagos and deep water.
• The purpose of this project was to learn how to build a fully functional 3D multiplayer game with some friends, which means that the game (BlackSeas) has been implemented from scratch as well as the game engine (Gear) on which it is based on.
• Gear had been started in summer 2022 by one of our team mate, Virgile. We began the development of BlackSeas in early 2023.
• Even though this project was a huge challenge for the four of us as it used many complicated and diverse concepts of video games development, we still really had fun doing it.
• The repartition of the work was the following: Paul COLINOT was in charge of handling the 3D collisions (physics), Virgile HENRY continued to work on the game engine and also implemented the "multiplayer" part of the game. Another friend, Brice PERES, generated and rendered every element related to the sky and archipelagos in BlackSeas. As for me, I implemented everything related to the ocean (generation, shading, buoyancy).
• Note: We did not have a great application to record our screen so the video might start with a little bit of delay and shows some lags. The game in itself runs in real-time (more than 120 fps with an RTX 3050, for instance).

< >

3D volcano scene from scratch

• Scene of a volcanic island made from scratch, using various computer graphics concepts.
• It contains a procedural island which heightmap is generated using compute shaders. The form of the island is obtained by combining fractional Brownian motion and a sum of gaussian functions which are flattened by a smoothstep function. The color is obtained by doing a linear interpolation of multiple colors given the height of the island (I did not have time to make proper colors using the normal instead).
• The ocean is generated by computing the Fast Fourier transform algorithm via a pipeline of compute shaders. This method is heavily inspired by Tessendorf's article and some other articles regarding the use of compute shaders to parallelize the FFT. I also added some reflection of the skybox on the ocean (visible on the waves' crest). The ocean grids are displayed using GPU instancing (one draw call for the whole ocean).
• Volcano eruptions are made using two particle systems which are initialized on CPU and updated on GPU (using compute shaders and SSBOs).
• The scene contains also other elements such as fog (done via post-processing with the use of FBOs), keyframe animated windmills and animals, a skybox (simple cubemap)...
• I implemented every element in the scene except the keyframe animations. Some elements might be highly improved (the eruption, for example which is not quite realistic) as we did this whole project in only 2-3 weeks.

Shaders

• Below you'll find one of my first shaders, created after one to two weeks of learning about shaders (scattered between school and my part-time job).
• This was realized by using simple raymarching techniques and fBm (fractional Brownian motions) for everything that concerns waves and for the dirt on the hill. I added some textures and displacement to the dirt to give it a stony aspect.
• Don't hesitate to check my other shaders on Shadertoy!

Simple raycaster

• Graphical interface built from scratch allowing the user to cast light (rays) on edges and curves.
• The user can draw curves by placing points on the screen. Each fragment of curve drawn correspond to a cubic Bézier curve which is connected to the following curve with a C² junction. Therefore, the global curve (made of all the fragments) drown actually represents a spline. It is possible to draw several splines on the screen by switching to another button of the panel and going back to the 'Curves' button.
• It is also possible to move the curve and change its appearance by sliding the white point (see examples below).
• The number of rays displayed in the screen can be set up to 3000 using only edges, and up to 250 using Bézier curves.
• This project allowed me to apply directly my mathematical knowledge (regarding geometry modeling) to a concrete project. It also enabled me to work again on evenemential programming, optimization and other aspects of programming.

< >

Personal website

• Small website built from scratch to present my CV and my projects.
• I learned the very basics of HTML, CSS, and some Javascript notions to make animations or control input events.
• I also used webgl to display the julia set in my index page (3D projection of a 4D julia set in quaternion space) :-). This has been done using raymarching, the corresponding shader is available on my shadertoy account: helenhsn!
• I know the code is not that clean or optimized as I just wanted something to display my projects. Still, I hope you will find it useful!