The coolest engine in the world!


ICE is the codename for my development "framework". It started as a collection of routines and useful pieces of code, and slowly evolved into a fully functional game engine. It contains all the C++ code I ever wrote at home, and last time I checked it was close to 600.000 lines.

I try to keep its design as simple, efficient and elegant as possible. It's not perfect by any means, but it has proven to be surprisingly stable and robust over the years. ICE was the basis for numerous projects (including Flexporter, Opcode, etc) and after some years working with "real" game engines used to ship "real" games, I can tell you something: ICE is cooler :)

The design is straightforward. I use several modules, clearly defined libraries, whose dependencies are kept minimal. It's relatively easy to extract one library out of the whole thing, and release it as an independent, re-usable module. I think Opcode proved this quite nicely! The same could be done for pretty much all the other ICE elements.

ICE so far includes :

- the core module: serialization, reflexion, reference tracking, memory management, containers, sorting, threads, profiling, files, strings, parsing, data compression, system-specific things, and all the other "basic" utilities one always needs.

- the maths module: vectors, quaternions, angle-axis, matrices, PRS, AABBs, OBBs, spheres, capsules, cylinders, planes, polygons, rays, inertia tensors, FFT, various noise functions, splines, fractal curves, "screwings", gauss maps, etc, all the "simple" math elements are here.

- the computation geometry module ("Meshmerizer"): BSP, CSG, edge lists, adjacencies, valencies, strips generation, LOD, mesh building & cleaning, subdivision surfaces, convex decomposition, convex hulls, silhouettes, implicit surfaces, mesh compression, normal masks, surface clipping, etc, all the more involved geometrical operations are located here.

- the contact module, specialized in collision-related routines. This basically contains all the overlap, distance and sweep tests between various shapes (e.g. capsule-vs-capsule, capsule-vs-mesh, capsule-vs-box, box-vs-box, sphere-vs-box, etc, most of them in 3 flavors - "overlap", "distance" and "sweep").

- the image module, dealing with all bitmap-related operations : resizing, filtering, loading, quantizing, mipmap generation, etc. This also includes some texture synthesis code (Efros 99, etc).

- the character module: skinning, motion blending, motion state machines, and all character-related algorithms. This module was able to fully replicate the character animation system from ONI, which was said to be very advanced and complete.

- the rendering modules: a rendering abstraction layer, exposing "all" the usual features from OpenGL / D3D (I mean lights, cubemaps, render states, state blocks, vertex buffers, you name it). This module also contains rendering-related algorithms like a scanline renderer, some software rasterizers, billboard & decal managers, texture projectors, etc. For hardware rendering, 3 extra DLLs (OpenGL / DX7 / DX9) implement the rendering interface.

- the prelighting module: this is a small lighting-related module which precomputes various lighting solutions (lightmaps, vertex lighting, spherical harmonics)

- the input module: a simple wrapper around DirectInput.

- the physics module: contains my own rigid body engine, particle systems and cloth simulation. The physics is a bit obsolete since I use Novodex now (of course). But this module is still used for the fast (hierarchical) particle systems.

- the collision module ("Opcode"): deals with all "midphase" issues, but also with visibility & scene queries (e.g. raycasts, sweep tests against the scene, portals, etc).

- the terrain module: procedural generation, texture synthesis, weather elements, chunk-LODs, etc.

- the GUI module: Win32 GUI helpers for tools or editors.

- the game engine ("Flexine"): the "glue" using all of this at the same time.


Some old modules are now obsolete:

- the sound module, for all sound-related questions. Slightly obsolete, I just use FMOD those days.

- Z-Collide, the collision detection module (now replaced with Opcode). It still contains some old algorithms that I don't use anymore.


On top of this, there are a number of plug-ins containing importers / exporters for various formats, standard 3D objects (you know... bunnies...!), etc. Pretty much everything is plugable here.

There is a game (codenamed "Konoko Payne") currently using all of the above, and making sure that the system is good / robust / fast enough for real-world game data. This game uses various AI elements (pathfinding, hand-to-hand combat logic, micro-threads, etc) which will probably be moved to a new "AI module" in the future.



Various (old & obsolete!) ICE screenshots :


Back to main