In the best company of the world and with the most talented team (Belgians are famous for their self-derision), it is mandatory to use the most advanced technologies for creating our games. Of course just for your pleasure.

This is why we decided to automate our “Game Content Pipeline” with a continuous integration process. To do this, we used “Hudson” simply because it wasn’t too difficult to implement within the Mojito Engine and secondly because the solution is quite complete.

One of the first step I had to undertake within this pipeline was to import all assets from a graphical software and export them to a format our engine will be able to use. Collada is perfect for this job and this is why we went on to create a Collada importer and a viewer which runs in the Mojito Engine.

For the first time we are proud to present you, the star of all stars, “Mr. Duck” from Mojito’s viewer.

It’s been a while since I post something technical here. We are currently really busy on our new secret project, but I have something to share.

Some compilers have an interesting property : __declspec(thread) for Microsoft cl.exe, __thread for Gcc. By using this declaration on a global variable, a copy of the variable is created for each thread. This is known as a Thread Local Storage (TLS). You can always use direct calls to the system’s API ( TLSGetValue and TLSSetValue for Windows, pthread_getspecific and pthread_setspecific for POSIX systems), but using automatic TLS variable is very comfy. As you may know, Mojito is available on several platforms, some of them does not provide those kind of variables. And if provided, those variables are limited to POD (Plain Ol’ data) variables. So we search for a solution that is close to what compiler can offer.

(more…)

Order of static and global variables initialization is a well-known uncontrolled phenomena. There is no way you can change it, variables will be initialized in an order the compiler is the sole to decide. The singleton fixes this problem by postponing the initialization at the first time the object is used. But then creation time is unknown and multi-threading issues may appear. This article propose a simple technique to force order of initialization.
(more…)

Console has recently pushed a new paradigm in the hand of game programmers. Multi-thread programming is now in our everyday life. The transformation of a sequential game engine into a multi-threaded engine is far from being trivial, and no references exists on this particular topic. Even if multithread programming is far from being new, few books are focused on concept and theory. Books about API are good, but they don’t teach you the good way to use the APIs from a design point of view. This book introduces theory and then apply it with code samples. Everything is programmed in java, but it applies to C++ as well.

The first chapters introduce abstract theoretical concepts, such as memory models. The next chapters cover concrete datas structures that help understanding concepts exposed earlier. The approaches and concepts used will help the reader to understand the phase one must follow to transform a sequential algorithm into a multi-threaded one. Most of the book is oriented around collection, but the result is good: each collection touches a new problem and exposes a new solution. Going from lock-based to lock-free algorithm, the process shows step by step transformations of collections such as set, list, hash map. To finish, work distribution and transactional memory are explained. Those chapters also introduce concepts that may appear in future architectures. The book closes with a huge appendix that exposes platform specific knowledge that one must know to address unexplained behaviors.

Elegantly written, this book is a bible, the code provided is clear, and the difficulty increases smoothly chapter after chapter. This book must be putted into every game programmer’s hands. But if they do not have any multiprocessor knowledge, the dive may be hard to stand.

Amazon
Elsevier