Coding Labs
- 2011/2013 -

Archetipo Archetipo is the last engine I've been working in my spare time. This engine is significantly more advanced and complicated if compared to the previous ones, mainly because once I've started working in the industry I've been in touch with so many skilled people that my knowledge has improved extremely fast.
Click the expand button below to read a list that presents in a compact way the features I've managed to implement in Archetipo

Note: All the features in the list have been developed from scratch, no external library is used.
Runtime Engine
  • C++ and DirectX 11 engine
  • Data driven and runtime reloadable rendering pipeline
  • Post Process integrated in the rendering pipeline
  • Flexible and runtime reloadable resources (shaders, textures, meshes, audio files, etc.) with dependencies resolution
  • C++ Data Reflection and Introspection
  • Support for GPGPU via compute shaders
  • Data oriented CPU Particle System
  • GPU Particle System
  • LUA script binding via Reflection for fast prototyping
  • Data driven reloadable 2D GUI System
  • Internal profiler that samples function times and renders a graph at runtime
  • Data driven runtime reloadable audio pipeline
  • Full automatic exposure system written in C# (allows to automatically expose an object from the runtime engine using C++ reflection)
  • Material Editor in C#
  • Colour grading lookup 3D Texture generator in C#
  • Font generator for the runtime in C#
  • Binary XML editor
  • 3dStudio Max exporter written using Max SDK
  • Particle Editor written in C# which uses the C++ engine runtime to preview the effects

- 2009 -

Character Control Character Control project is my Master Thesis work which is presents the theory and practice of an advanced animation method designed to generate user guided walk animations for digital characters.

The whole project is very broad touching several different topics:
  • Skeletal Animation
  • Motion Capture
  • Seemless animation blending
  • Artificial intelligence - Reinforcement learning
  • Linear programming

Character Control is the topic of my Master's Degree thesis. The thesis's idea comes from "Near-optimal Character Animation with Continuous User Control" Treuille, A. Lee, Y. Popović, Z. ACM Transactions on Graphics 26(3).

The work itslef is very broad, therefore it is quite difficult to explain every single part of it in details within the space of this page. If you are interested in this topic you can download the thesis from this link.

You can watch the video below to get an idea of the final result, and I've also copied the abstract of the thesis here so that you can read it to get a grasp of what you see in the video.

"The present work discusses theory and practice of a powerful animation method designed to generate walk animations for digital characters. Our system permits to interact with the animation, allowing the user to change at run-time several animation’s parameters, such as the motion direction or the gait style, influencing the final animation. Our work starts presenting the skeleton animation system and the motion capture system; then we explain how we can, thanks to these two techniques, generate a database of walk animation clips. The so obtained animations are provided to the animation system which links them together in a sequence. Linking is obtained generating a smooth transition from one clip to the next one through the use of the animation blending technique. Since we want to interact with the animation at run-time, the clip’s sequence is not given a priori, instead it is generated in real-time in respect to the user’s desires. To this aim we create a controller in charge of choosing the next clip in respect to the task that it is given, which can be simulating a walk along a line, or simulating a walk where motion direction and character’s orientation are required by the user. The controller leans on a selection policy in order to choose the next clip; in our work we propose two possible policies, a greedy one and a near-optimal one. The former goes through every animation contained in the database and evaluates the direct cost of adding the clip in exam to the sequence. The latter policy, instead, chooses the next clip evaluating an approximation of the optimal choice, which is obtained through the implementation of a reinforcement learning algorithm. The optimal choice estimates both the direct cost of choosing a clip as well as all the future costs that the system will pay for that choice. Unfortunately we can’t effectively implement the optimal policy, therefore we content ourselves with an approximation that leads to the nearoptimal policy. We lastly show how both these policies produce controllers capable of responding, in realtime, to the change of several animation parameters due to the user’s interaction as well as the environmental constraints."

Lastly let's see some screenshot of the work as well as of the tools we developed.

The tool we developed to handle the clips and their constraints The tool we developed implements some algorithms to convert C3D files into the proprietary EXO file format. Motion Capture session Mesh, markers and bones Approximated Value function


- 2008/2010 -

Psyche Psyche is a multi-thread cross-platform engine developed in C++, SDL and OpenGL.
It uses other cross platform libraries like NVidia PhysX and AGAR, and runs on both Windows and Linux.
Among the other things I've used this engine to study advanced rendering techniques such as HDR Lighting, Deferred Rendering or SSAO, just to mention some of them.
The engine was also used to develop my Master Thesis work, Character Control. You can see some screenshots and videos if you expand the Character Controls' block.

- 2007/2008 -

Character Control Orbital is a sci-fi game where the player impersonates a space-station commander, who fights for the control of a planet.
The game is a management simulation where the player is charged of building a modular orbital base, inclusive of attack turrets, in order to face an opponent sited on the opposite side of the planet.
Orbital Orbital is based on Zenith Engine which uses OpenGL and OpenAL for video and audio rendering. The game idea is very simple and it is inspired from the old Metal Marines game.
In Orbital two opponents challenge themselves from the opposing sides of a planet, building a space base while managing several resources and planning both defence and attack.

The main purpose of Orbital's design was to keep the development stage simple. A lot of other projects died becouse of their design complexity. With that well stuck in mind I've designed the game to be easy enought for two people to develop. The game has been under development for a couple of years (considering the Zenith development time too) leaning on only two people.

The aspects I took care of are:

  • All the codework
    • Rendering Engine
    • Game Mechanics
    • GUI system
    • Network code
    • Artificial Intelligence
    • Audio stuff
    • Code optimization
    • All the other stuff a game needs
  • Game Design and Concept
  • Power Plant 3D modeling and texturing
  • Cargo 3D modeling
  • Main menu 3D modeling, texturing and rendering
  • Construction GUI design and 2D painting

Orbital in-game screenshot
Orbital in-game screenshot  

Orbital features some interesting rendering technique as exhibited in the screenshots below. The gallery here shows also a wallpaper and the tech-tree.


- 2007 -

Arkam Arkam is a game I've developed for my Bachelor's Degree thesis project.
The main topic of the thesis was to implement a framework in C++ to support a Data Glove device. To show off the framework I decided to write a small wizard game to go with it.
The Data Glove framework consist of a server that connects to the device itself using the drivers provided with the glove. Once the server is connected it runs a multi-threaded service on the network for anyone to read.

Arkam is my Bachelor's Degree project. It is based over the Zenith engine for the graphical stuff. The thesis was focused on the programming of a Data Glove device and on the implementation of a small wizard game. To achieve the goal several programs and algorithms have been developed.

The main features developed for the project are:

  • Multi-thread server application for data acquisition and LAN propagation
  • Client classes to read glove acquired data from the LAN
  • Gestures recogniction algorithms
  • Inverse Kinematic algorithms for arm animation
  • Forward Kinematic algorithms for hand animation
  • Simple AI algorithm for the opponent wizard
  • Modeling, texturing and rigging for the game assets

Since the game relies on Zenith engine the whole project has been developed in C++. The multi-thread server application reads the data from two different devices, the Polhemus tracker and the 5DT Data Glove 14 Ultra using one thread per device.

Glove in use

Read data is stored and then retrived from the network-thread which generate packets for LAN propagation (using TCP/IP protocol). Several clients may connect to the server.

The game client uses the data provided from the server to animate the hand. If the hand is in pointing stance a spell starts to be casted. During the casting sequence the gesture recognition algorithm searches for any pattern to be matched. To complete a spell three patterns must be matched, and in every stage the player may choose which pattern he prefers to reproduce.
When the spell is ready it may be casted opening the hand toward the opponent.


This video has been taken before Arkam being finished.
The giant monitor is from the virtual theatre I've worked on sited in the "Laboratorio di Eidomatica", University Of Milan.
The opponent wizard is still and doesn't react since, at the time the video was captured, the AI system wasn't ready yet. Gesture recognition system was almost done while some problems where still present in the data glove calibration system.
The video is anyway a good rappresentation of the work itself.


- 2006/2008 -

Zenith Zenith is my first engine based on OpenGL. The engine was developed to study the OpenGL rendering library as well as other extensions such OpenAL or the OGG/Vorbis. This engine is at the very base of Orbital and of my Bachelor Degree's work Arkam.

- 2004/2006 -

Pool-O-Matic Pool-O-Matic is an unusual biliard game. The engine (named FX-Drome) has been written using C++ and DirectX 9.
This game was developed after I finished my experimentations in writing a full physics engine; once the engine was capable of calculating motions and collisions, it seemed natural to develop a game based on phisycs, thus we gave birth to Pool-O-Matic.

Pool-O-Matic main features are the full physics engine, robot arm animation using inverse kinematic, motion blur effects and an artificial intelligence.
The engine was provided of a basic GUI system and audio manager.



The flag is from a real-time application written in java for Geometric Computation's exam. The project consisted in writing a cloth simulation program developing a softwere rendering engine that implements Bezier surfaces and mesh rendering.

The second image refers to another university's exam. Rendering is done via RenderMan and all the shaders were written from scratch using RSL (RenderMan Shading Language).

The low poly screenshot is about a software rasterization engine, named Tarma, written for exercise. The engine is able to render models exported from 3DStudio and to do flat and gouraud rendering. The engine supports colored lights and matrix based animation. It is very simple, but it was written entirely from scratch.