Details, pictures and a demo application right after the jump...

MD2 file format

Quake 2 uses the MD2 file format  to store animated 3D models. It is a quite simple file format: each MD2 file stores a single mesh and its animations. Each animation is just copy of the original mesh with different positions for each vertex. The number of vertices and the indices are the same for each frame. Therefore, the MD2 file format is easy to adapt to the Flash Platform because no complicated shaders/bones are required to animate the model: you just have to display the right vertices!

But it is not THAT simple. Each animation is actually subdivided into frames (vertices really). Because storing a fluid animation would take a lot of frames (and a lot of memory), only a few keyframes are stored. When rendering, one must compute the interpolation coefficient between the current and the next keyframe and use it to get the interpolated vertices. The following code does it all:

var frame1	: Vector.<Number>	= _currentFrame.vertices;
var frame2	: Vector.<Number>	= _nextFrame.vertices;
var c2		: Number		= _frame - int(_frame);
var c1		: Number		= 1 - c2;
var length	: Number		= frame1.length;
 
for (var i : uint = 0; i < length; ++i)
	_vertices[i] = frame1[i] * c1 + frame2[i] * c2;

... and here is the demo application :

Flash 10 MD2 loader

What it does...

• load Quake 2's MD2 files
• basic z-sorting using faces barycenter
• add a "frame" property to the mesh to handle animations
• interpolate and update vertices only when necessary
• wireframe material (press "w")
• "free chase" camera (mouse click + drag'n'drop to turn around the model)

What it doesn't do...

• use BSP trees to handle z-sorting (1 BSP tree / frame takes a lot of time and memory...)
• loop through a specific animation
• read Quake 2's animation files

Known issue(s)

None. If you find one please let me know! Performance seems to be very good actually...

There are so many reasons why loading Quake 2 files inside the Flash player would be considered as just "impossible". Performance would be the first and main one. One would just consider that Flash is not fast enough to display complex 3D graphics, not even those of a game as old as Quake 2 (published in 1996!). But using Flash 10 latests features such as the Vector and GraphicsTrianglePath classes, it is actually quite doable!

Details, pictures and a demo application right after the jump!

Quake 2's maps file format

But the really big advantage here is inside the Quake 2 maps file format itself. Each map is a *.BSP file and the BSP file format might be the best ratio in terms of ease of implementation against performance optimization. As you might have guessed, *.BSP files actually store a pre-compiled Binary Space Partitionning tree of the map itself. For those who don't already know about BSP trees, just imagine that it is actually the best known method to handle a polygon-perfect z-sorting in Flash when dealing with 3D. But computing a good BSP tree of a large and complex 3D model such as a map takes a lot of time... that is why having a pre-compiled and ready to load BSP tree is just great!

You can find a lot of good documents on the Quake 2 BSP file format. The one hosted on flipcode is quite complete and easy to understand. It is actually the one I used to create my BSP loader. Reading the file formats specifications shows that *.BSP files also include "visibility information". This data is also very important because it makes the user able to know which area of the map is visible from any other area. This way, only the areas visible from the area where the player stands have to be displayed which is an incredible performance boost!

The following application is a proof of concept of a Flash powered Quake 2 *.BSP loader :

Click on the picture to launch the demo application.

Here are some screenshots of the same application loading much more complex maps (those screenshots have been made with the Flash debugger which explains the higher memory consumption) :

actcity2

aqnitro

What it does...

• load Quake 2's *.BSP files
• build the corresponding geometry (vertices, indices and UV data) using Flash 10 native types such as Vector and GraphicsTrianglePath
• frustum culling and clipping using bounding boxes and bounding spheres
• mouse controlled "free chase" camera (click + drag'n'drop to look around, mouse wheel to zoom in/out)

What's next...

• use the embed BSP data to handle z-sorting
• use visibility information to display only visible clusters
• load WAL textures (Quake 1 and 2 textures file format, already done just have to post it )  and use them properly to display the map
• load MD2 animated 3D models (again, already done and just have to post it!)

Known issue(s)

If you zoom enough to place the camera "inside" the map geometry, you will notice a severe framerate drop down. It is very logical since frustum clipping will have to check and eventually clip each polygon of the geometry against the relevant view frustum planes. Because visibility information tells us what is actually visible or not, handling it properly should offer a huge performance boost: instead of having to clip the whole geometry, only the visible areas will be treated.