I will not explain how everything is structured, because it's kind of pointless. Especially because there will be a full-fledged documentation. I already documented hltypes myself and I will probably do the same with AprilUI somewhere soon. But you should know the outline concept behind our engine.
The engine consists our of 6 libraries. 2 of those libraries have a utility library as well and 2 of them have a sublibrary.
C++ High Level Types (hltypes):
This library is based on STL and provides more high level functionality for commonly used types such as string, dynamic size array, dictionary/map, etc. This allows C++ code too look almost as nice as any other high level language code. Simple example of adding a couple of elements into a harray with iteration:
a += 2;
b += 3;
foreach (int, it, a)
printf("%d, ", (*it)); // prints "2, 3, "
foreach is a macro that allows you to do a default iteration through all elements without having to type down the whole line for an std::vector iteration like this:
for (std::vector<int>::iterator it = a.begin(); it != a.end(); it++)
One of the most useful classes is probably the hstring class that adds a lot of useful methods, even implicit type conversions:
hstr a = "";
a += 2;
a += " ";
a += 5.0f;
printf("%s\n", a.c_str()); // prints "2 5.000000"
hltypes has a set of unit tests that makes sure everything is actually working fine. It is a stable and very useful library. I recommend it for usage even outside of April & Friends.
We also use hlxml, a sublibrary of hltypes, which is used for XML parsing. This is basically needed by the overlying library aprilui.
C++ Geometry Types (gtypes):
This library features a few smart geometry types that are often used in 2D graphics and 3D graphics such as Matrix3, Matrix4, Quaternion, Vector2, Vector3, etc.. There's not much to say here except that we're trying to make this library as fast as possible, because it is the backbone of the actual 2D engine and the actual 3D engine.
Awesome Portable Rendering Interface Library (april):
The name requirements were "portable" (or "multiplatform") and "render". We went through a bunch of possible names and then we just said "fuck it" and called it "awesome". xD
The main concept behind this library is to have a unified interface for drawing stuff on the screen. As an actual back-end, any system can be used. You just have to implement that system and compile april with that system as the active one. Technically you can even compile them all and decide what you want to use during runtime. We prefer compiling it specifically with one back-end to keep the binaries smaller and more stable.
That drawing interface is split into two categories. One category is the rendering interface of which DirectX and OpenGL (and OpenGL ES in case of iOS and Android) are the most famous. I'm not even sure anybody uses anything else than that. The other category are window systems. Current window systems that are supported are Win32, SDL, GLUT and the iOS window system.
April also provides commonly used types in graphics rendering such as Color, Texture, ImageSource, etc.
April also possesses a utility library with useful tools. Currently the only tools are a class for blur effects and a class for 3D meshes. Soon more things will be added such as bone animation for meshes and with that a new minimalistic and optimized format for 3D models and skeletons.
This library is based on hltypes and gtypes.
Advanced Text Rendering System (atres):
This library is able to render text from a bitmap font. Currently there is no support for true type fonts due to various limitations. This will be available in future somewhere.
The features this library supports are interesting especially the text formatting. You can change font name, font size, text color, turn off and on shadows or borders with a syntax similar to BBCode.
[c=0000FF]This[/c] word is blue. And [f=normal:0.5]this[/f] word is half the size.
This library is based on april, gtypes and hltypes.
We also use atresttf, a sublibrary of atres, which is uses the freetype library to read fonts from .ttf files.
April User Interface (aprilui):
This library provides GUI functionality. You can either create a GUI on the fly, or you can predefine a complete GUI structure in advance in XML. It supports many different and often used GUI elements as well as so-called Animators that allow you define animation on your GUI elements. The Animators system has been refactored recently and is not fully done yet, but the already present features are already very powerful. If you played any recent games of Cateia Games (such as "Kaptain Brawe" or "Frogs vs. Storks"), you have seen a fragment of the capabilities these animators are capable of. (If you want, you can compile the "demo_gui" project and check out what animators can do.)
This library is based on atres, april, gtypes, hltypes and hlxml.
Extensible Audio Library (xal):
This library provides audio and sound functionality. Similarly to April, it offers one of three sound system for usage (DirectSound, OpenAL, SDL). Threaded update has been implemented and tested and should be working fine.
XAL also possesses a utility library with useful tools. Currently the only tools are a Playlist structure and a ParallelSoundManager. I will not go into details explaining them.
This library is based on hltypes.