Using Magnum with custom buildsystems
Guide and troubleshooting when you don't want to use CMake.
While Magnum uses CMake as its primary buildsystem, it's possible to use Magnum with a custom buildsystem as well. The following guide will highlight the most important concepts for both using and building Magnum.
Using already built Magnum with a custom buildsystem
The easier situation is building Magnum itself with CMake, as explained in Downloading and building, and then integrating the installed libraries and headers into your buildsystem. For Magnum built this way, every library has a name corresponding to the namespace name and the headers are also in a directory with the same name.
Library dependency order
Preserving library linking order is important to avoid linker errors. For Corrade and libraries in the main Magnum repository the order is the following. The light blue libraries are the core, which you need to link every time, the dark blue libraries are extra functionality. Some libraries have cyclic dependencies, in which case they are both compiled into a single library, the other part of the cyclic dependency marked with a dotted rectangle. Deprecated libraries that are scheduled for removal are marked with a dim color. In some cases a dependency is optional (marked with a dotted line) and you can remove the dependency by disabling parts or configuration options that require given dependency. See documentation of each library for more information.
So, for example, in order to use the Primitives library, you need to link the libraries in this order, the leaf libraries first and the root dependencies last:
MagnumPrimitives MagnumTrade Magnum CorradePluginManager CorradeUtility
Note that some libraries have dependencies outside of Magnum and the above diagram doesn't include them — again, see documentation of each library for more information.
Static plugins
While dynamic plugins work without buildsystem integration, static plugins are handled automagically with CMake and you need to replicate the magic manually when using a custom buildsystem. This is just about compiling an additional *.cpp
file together with your final app, see Static plugins for more information.
For linking static plugins, there's the following dependency order. Most plugins have just a single dependency on its interface lib, however there are some exceptions:
Resource compilation
The CMake macro corrade_add_resource()
provides a convenience wrapper macro around the Resource compiler executable. For the following CMake code:
corrade_add_resource(MyApp_RESOURCES resources.conf) add_executable(MyApp main.cpp ${MyApp_RESOURCES})
The following is an equivalent shell invocation:
corrade-rc MyApp_RESOURCES resources.conf resources.cpp # Now compile resources.cpp into your app
In both cases, MyApp_RESOURCES
can be used for importing the resources at runtime with CORRADE_corrade_add_resource()
is doing dependency tracking by introspecting the resources.conf
file. For a custom buildsystem you have to implement that by parsing the file yourself.
Cross-compilation
Magnum maintains a set of CMake toolchains for cross-compiling. Each toolchain typically sets custom linker and compiler flags and you may want to replicate the behavior 1:1 to avoid issues. The toolchain files are available at https:/
Building Magnum with a custom buildsystem
Magnum Plugins
The Magnum Plugins repository follows the same plugin dependency rules as the core Magnum repository, with the following special cases:
Magnum Integration
The Magnum Integration repository has the following dependency order:
Magnum Extras
The Magnum Extras repository has the following dependency order: