Selected School Projects
From WhiteStar 02
This is a selection of the school projects I have found interesting and representative of my skills and interests. All projects here are from classes I took in my first year of Masters studies, since my bachelor's degree curriculum had no Computer Graphics classes.
[edit] INF4702: Compléments d'infographie (Computer Graphics 2)
[edit] Assignment #6: Landscape
Landscape generation using the diamond-square algorithm. Vertex coloring according to height. Perlin noise textures used for clouds and water, with texture coordinate animation.
The landscape was randomly generated according to a given seed; to reproduce a landscape you could save the seed used and re-use it, which would give the same result.
The final landscapes seen in the images to the right are composed of 65536 and 262144 polygons respectively. In the first case, performance was refresh-limited at 75fps. In the second case, I reached my video card's polygon throughput limit (around 3-4 million polygons per second, it seems) as performance fell to around 15 fps. Note that there is no culling or LOD in this case. That would have greatly improved the situation, obviously.
[edit] End-of-term assignment: Non-photorealistic rendering
Non photorealistic rendering using different styles (pencil strokes, pointillism, etc.)
This was rendered in two passes, one for the color and the other for the pointillism pattern.
The color pass was a normal raytracing using 64 samples per pixel, simulated area lights and fuzzy reflections (using distributed raytracing). The scene was comprised of two spheres and two mirror walls.
The pattern just used the intensity (black to white) of the pixel to determine the probability of having a point there.
Then, the two images were blended together using the same formula as for Photoshop's "overlay" blend mode.
The raytracer used to render this was the same as was used for the other assignments in the class, modified to be able to do several non photorealistic rendering techniques by simply changing the scene file. It supported horizontal, vertical and diagonal hatching, pointillism, brush strokes (which were pretty ugly due to time constraints) and object silhouettes. The blending mode used to combine the two passes could also be specified in the scene file. Some modes implemented were addition, difference, multiply and overlay which was used for the image shown.
[edit] INF4715: Ingénierie des applications multimédia interactives (Interactive Multimedia Application Engineering)
[edit] Battle for Atlantis
3D underwater exploration game developed over the course of the whole term. Written in a team with 5 other people. My primary jobs were gameplay programming and physics programming, but I ended up doing some 3D work, some graphics engine work (the frustum culling mostly), the terrain engine and terrain generation, the level and terrain file loaders, etc.
See Battle for Atlantis for further details.
[edit] INF6800: Conception géométrique assistée par ordinateur et visualisation (Computer Aided Geometric Design and Visualisation)
[edit] End-of-term project: Loop subdivision on the GPU
The program implemented Loop's subdivision scheme in two ways:
- On the CPU
- On the GPU (not totally functional)
as well as an ad-hoc scheme described in Generic Mesh Refinement on GPU which worked really well.
[edit] Trade-offs
Loop subdivision on the CPU:
- Subdivision is done once and stored, so no additional processing is required at each frame.
Generic Mesh Refinement on the GPU (as well as Loop on GPU if it had worked):
- Less triangle data has to be transferred on the bus. Currently, that would be a big advantage, since current graphics cards have ample memory but sending data to that memory takes time.
[edit] Image quality
It's important to realize when looking at the images that Loop on the CPU doesn't necessarily give better results. If you wanted a sphere from a cube, then yes, Loop on the CPU would give that automatically. However, an artist will always have to tweak the model to give the result he/she wants after the subdivision, and so the appearance of a subdivided cube is a poor benchmark of final visual result. It's much more important in this case to look at the performance, and in that respect, Generic Mesh Refinement on GPU gave about the same performance as subdivision on the CPU for a pretty large mesh (30000 polygons in the subdivided mesh) while sending much less data across the bus and also without taking any time to do the actual subdivision (which took about 5 seconds on the CPU at that subdivision level).
[edit] INF6802: Réalité virtuelle: Principes et applications (Virtual Reality: Principles and Applications)
[edit] Bow and arrow simulation
Virtual reality bow and arrow simulation on a boat. Done in a team with my good friend Matthew Khouzam. Ran in a CAVE environment.
You (the player) are on a boat traveling on a path. You can only move within the confines of the boat. There are targets which are either floating in the air or on islands that the boat goes by. Your goal is to shoot an arrow into as many targets as possible. The difficulty comes from the fact that the boat is moving and that the targets also sometimes move (the floating ones oscillate up and down at different speeds).
The inspiration for being in a boat was that we found that the CAVE environment was very immersive except if the player had to move around a lot. If movement was required beyond the cave's size, the application had to provide "forward" and "backward" buttons on the wand (the 3D joystick used in the virtual reality environment), and using those buttons really killed the immersion of being able to move freely in a 3D virtual environment. So we decided that the player would only be able to move in the confines of a boat (which had the same dimensions as the CAVE environment) and the boat would move on the water.
The result was very good, although in the CAVE, actually shooting the targets while the boat was moving was difficult. We don't know if it's because the screens or the wand were not calibrated correctly or something else, but shooting when simulating the environment on a computer screen was much easier.
No screenshot of the project itself is available.
[edit] IFT6042: Synthèse d'images (Computer Graphics)
[edit] Shading Cache
Implementation of the Shading Cache. Was never fully functional.
The general principle is that while one thread processes user interaction and renders the scene using normal real-time hardware rendering, a few other threads decide which parts of the image could benefit the most from an increase in image quality and then sample those parts using a high quality renderer (a bidirectional path tracer in the original article; a photon mapper in my implementation). The results of the high quality sampling are then applied to the scene using vertex coloring. If there is a need to further refine the image in some parts of the scene, the mesh can be subdivided and more high quality samples can be taken for the new vertices.
I used the Pane Global Illumination Raytracer to try and implement something like the Shading Cache. Unfortunately, I started working on it two weeks before the hand-in date and could never finish the work. However, the integration of real-time rendering and raytracer worked well.
No screenshot of the project itself is available.
