Cool Projects

This section presents screenshots of different cool projects I’ve worked on either for a specific project or in my free time.

Quake 2 BSP Renderer

This project consists in a custom renderer for Quake 2 maps. It was written completely from scratch in C++, using OpenGL and a couple of GLSL Shaders for graphics.

All map data (BSP files, WAL textures and Lightmaps) are loaded directly from Quake 2′s original PAK files. Quake 2 is Copyright (C) Id Software.

Destroyed bridge in base2.bsp.

Windows and sky at the elevator room in base1.bsp.

Final room in Quake2's base1.bsp.

A Hidden room in base1.bsp.

The hidden room in base1.bsp, rendered from another angle.

Quake 2 Gunner

This project was developed using C++, OpenGL and GLUT. The model is loaded directly from the Quake2 file format: md2.

Animation Keyframes are interpolated to produce a very smooth animation at the cost of minimal model deformation.

Vector Field

A vector field rendered, developed for an article that was to be published in an important Linux magazine.

The codebase is pure Python, using PyOpenGL for rendering and Pygame for creating the window and loading the texture files from disk.

Vector Field Renderer. Developed entirely in Python and rendered using PyOpenGL.

Konoko

Loading and rendering of VRML models using Phong Shading. Rendering is performed using OpenGL and a vertex and a fragment shader for implementing texture mapping and Phong Shading. The codebase is pure C++, except for the Shaders, which were developed using GLSL.

Julia-Fatou Set

A rendering of the Julia-Fatou set, implemented in Objective-C using Cocoa Touch and OpenGL ES 2.0. The fractal is dynamically calculated. Most of the work is done in parallel by the fragment shader.

The Julia-Fatou set, rendered on an actual iPad during a presentation at Globant's 2010 iOS Hackathon

IFS Fractals

An iterated function fractal representing a leaf. All calculations were performed using Cython. Rendering was performed using Pygame.

IFS fractal computed using Cython and rendered using Pygame.

Python Particle System, circa 2006

The Particle System was a fire simulation program developed entirely in the Python programming language using Pygame and OpenGL to draw the graphics.

In the implemented system, second grade emitters were also coded. A second grade emitter (or meta emitter) is an emitter-emitter, which can be used to emit emitters as if they where particles. This (emitted) emitters will also emit particles, which allows to create even more complex visual effects, such as a fireball launcher, as you can see in the following image.

Meta-emitter for the Particle System. The meta-emitter is located in the center, at the bottom of the screen.

C++ Raytracer, circa 2005

I wrote a raytracer in the final quarter of 2005 as part of a Computer Graphics course taught by Gabriel Gambetta, founder and lead developer of Mystery Studio. The application was developed using C++ on Debian GNU/Linux.

Instructing the compiler to optimize the code (inlining functions, running the for’s backwards, etc) reduces exection time to a mere 4.6 seconds for a 600×600 image, a very significant improvement when compared to over a minute for a Java implementation, and over two minutes on a C#/.NET implementation.

Raytracer sample run. Image was generated in 4.6 seconds on a 2GHz Celeron CPU.