Cool Projects

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

Vortex 3D Engine

Vortex Engine is a custom 3D Engine built for the specific objective of rendering native cross-platform realtime 3D graphics. At its most basic level, Vortex can be seen as a set of proven, reusable components that enable delivering 3D applications and games on a disparate array of platforms, including iOS, Android, Windows, Linux and Mac.

Some of the most prominent features of Vortex Engine include:

  • Developed in standard C++, completely object-oriented.
  • Fast and portable.
  • Non-intrusive and flexible.
  • Minimal external dependencies.
  • Dynamic scene management.
  • Automatic resource life-cycle management through reference counting.
  • Rendering through the Fixed and the Programable pipelines.
  • Supports OpenGL, OpenGL ES 1.1 and OpenGL ES 2.0.

The following scenes were rendered using Vortex 3D:

A Lightscattering Implementation powered by the Vortex 3D Engine.

Vortex Framebuffer Object Support: a knight is rendered on a texture that is then mapped on a cube. All rendering is done on the GPU, avoiding expensive copies to RAM.

A demonstation of Vortex’s Stencil Shadow Volumes implementation: A Knight being lit by a green light, casting a shadow on a tiled floor.

Angel with Generated Normals

Automatic Normal Generation: an Angel Model is lit using normal data generated automatically by the Vortex Engine.

Dual Pipeline support: a Comparison of the Rendering Pipelines available in Vortex Engine. The image on the left represents the Fixed Pipeline. The image on the right represents the Programmable Pipeline.

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 Screenshot

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.


Phong Shaded Konoko

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.


Julia-Fatou set at iOS Hackathon

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

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.