Building Spring Cross Compiled
- 1 Obtaining the Source
- 2 CMake cross compiling
- 2.1 Setting up the cross compiler
- 2.2 Getting Spring's windows dependencies
- 2.3 Setting up your directories
- 2.4 Create your cmake toolchain
- 2.5 Run CMake
- 2.6 Package Maintainers Note:
- 2.7 Buildbot
Cross-compiling allows you to build for other platforms than the machine you are building on. You can, for example, compile Windows 32-bit binaries on a Linux 64-bit machine.
Obtaining the Source
(For playing online official games on lobby.springrts.com - the spring lobby server)
Note: Do NOT use the zip-files from github, they are missing important data to compile Spring.
See Building spring for build instructions.
Branches of interest:
- master - latest stable, enforced for official games on lobby.springrts.com
- maintenance - fixes for the latest stable
- develop - major developments (most active, larger developments)
Assuming the GIT command line client is installed, you can clone (get locally) the repository with the commands below.
Latest Stable (master branch)
git clone --recursive git://github.com/spring/spring.git -b master
To later update it (get the changes other people did) with:
git pull --rebase
Maintenance (maintenance branch)
git clone --recursive git://github.com/spring/spring.git -b maintenance
Bleeding-edge (develop branch)
git clone --recursive git://github.com/spring/spring.git -b develop
Working with git
Please note that patches to the code must be done for either develop or maintenance. Such patches can be then sent to one of the developers with repository access. If you are new to git and github, you may want to have a look at this guide to get you started.
Note: you can switch
branches this way:
# (optional) backup your current code changes git stash # switch branch git checkout $MY_OTHER_BRANCH # sometimes needed # note, it deletes all your unstashed changes and all non-pushed commits on the new branch, # but it doesn't delete untracked files. #git reset --hard # update/sync with remote repo git pull --rebase # (optional) if you want to apply the code changes backed-up in the first step #git stash pop # reapplies your changes and DELETES the backup # or #git stash apply --index 0 # reapplies your changes and keep the backup (see `git stash list`)
To obtain the submodules you should clone the repository with --recursive as mentioned above. If you haven't done this, you can execute the following code
git submodule sync git submodule update --init
To update the submodules, you have to execute the same commands again or pull normally.
CMake cross compiling
Setting up the cross compiler
The compiler is called MinGW, which is a port of GCC to windows. The version are going to need is MinGW GCC 4.4.0 (which is MinGW 2.7) or later. Most Linux distributions come with MinGW-GCC 4.1.2 only in their standard repos (Summer 2009), so you have to do extra work to get 4.4.0+.
emerge crossdev EXTRA_ECONF="--with-dwarf2 --disable-sjlj-exceptions" crossdev -t i686-mingw32
Use the repository specified mingw ppa, and then install the required packages:
sudo add-apt-repository ppa:tobydox/mingw sudo apt-get update sudo apt-get install mingw32-x-binutils mingw32-x-gcc mingw32-x-runtime mingw-x-w32api
You have to find a way yourself, or use these instructions to get the sources and compile it yourself. When doing so, make sure to use these build flags for gcc:
--with-dwarf2 --disable-sjlj-exceptions --enable-shared --enable-version-specific-runtime-libs
you can add them under src/gcc-core.mk.
Note: This method will most likely not work anymore, as the checksum of the build files is checked by the makefile.
Alternatively, use this line to compile all the deps (which will then be used instead of mingwlibs):
make zlib boost devil ogg vorbis openal freetype sdl glew gcc
Getting Spring's windows dependencies
These are called mingwlibs. How to get them is described below.
official MinGW - dwarf2 (default)
You can get it here (Download Source button, or use git):
TDM MinGW - sjlj (alternative)
Setting up your directories
Here is my recommended layout
~/spring-xcompile/ (or wherever you want to put it all) ___ spring/ (the spring source) ___ win32/ (your target platform) _______ build/ (the build files for your target will go here) _______ final/ (the compiled binaries and libs will be installed here) _______ libs/ (mingwlibs, the target libraries you just downloaded) _______ win32.cmake (see below)
Create your cmake toolchain
Create the toolchain file:
Example toolchain file
An example should be self-explanatory:
# the name of the target operating system SET(CMAKE_SYSTEM_NAME Windows) # which compilers to use for C and C++ SET(CMAKE_C_COMPILER i686-mingw32-gcc) SET(CMAKE_CXX_COMPILER i686-mingw32-g++) # here is the target environment located SET(CMAKE_FIND_ROOT_PATH /usr/i686-mingw32) # the spring mingw32 dependencies SET(MINGWLIBS ~/spring-xcompile/win32/libs) # the path that make install will use to put the final binaries SET(CMAKE_INSTALL_PREFIX ~/spring-xcompile/win32/final)
Pass this with
-DCMAKE_TOOLCHAIN_FILE=~/spring-xcompile/win32/win32.cmake to cmake or select it in the gui to make a cross-compilation (see below).
Some Options Explained
- MINGWLIBS: absolute path to the directory where mingwlibs are located
- CMAKE_INSTALL_PREFIX: installation prefix (defaults to /usr/local) defines the base directory for installing
- DATADIR, LIBDIR, BINDIR: where to install data, libraries or binaries (relative paths are based on CMAKE_INSTALL_PREFIX, absolute paths are absolute (DESTDIR is still respected))
- APPLICATIONS_DIR, MIME_DIR, PIXMAPS_DIR: where to install freedesktop-files (icons, mime-types and application-description)
The GUI method
CMake offers a nice Qt4 gui to ease the following steps (to use the gui explained here, cmake must be at least version 2.6.1). Doing so should be straightforward:
- select source directory
- select (and/or create) build directory where temporary files are stored
- hit configure button
- choose your build type:
- Unix makefile if you are using linux and want to compile linux executables
- mingw makefiles if you are working on windows
- Unix makefile with cross compiler setup to cross-compile mingw32 executables, you have to select the toolchain file you want to use (see below)
- configure variables to your need (move the mouse over the options and read the tooltip for further informations on them and or see Section "Options")
- push generate button
- open commandline and do "make" and "make install"
The commandline method
- cd to build directory
cmake <path to source tree> <options>where:
<path to source tree>is the path to the spring source directory
<options>are defined like
- IMPORTANT: depending on your settings you may need to run this command twice. It can't hurt so I recommend doing it anyway.
cmake "~user/spring-xcompile/spring" "-DCMAKE_TOOLCHAIN_FILE=~user/spring-xcompile/win32/win32.cmake"
make spring && make install-spring DESTDIR=~user/spring-xcompile/win32/final
to show other build targets type:
Package Maintainers Note:
make install DESTDIR=/some/pathwill install spring in the specified place, putting files in subdirectories like configured. This may be helpful when making packages so Spring don't get installed on your system for real (see also CMake FAQ []).
- You need to update the mime database (
update-mime-database) and the kde database (
kbuildsycoca) after installing to make the system aware of the newly installed mime types and desktop shortcuts.
For setting up a buildbot slave, see: buildbot/README.markdown