Building Pegasus

Pegasus is a cross-platform native application written in C++ and built mainly on top of the Qt libraries. Manually building has the following requirements:

• C++11-supporting compiler (eg. G++ 4.9 or Visual Studio 2017)
• Qt 5.15 or later, with the following modules:
  • QML module
  • Qt Quick 2 module
  • Multimedia module
  • Svg module
  • Gamepad module, optional¹
• SDL 2.0.4 or later, optional¹
• Git, optional²
• CMake 3.16 or later, optional³

To install Qt, you can follow the guide on this page.
To install SDL2, you can use your platform's package manager or you can download the library directly from its official site.
To install Git, use your platform's package manager, or the official installer, and make sure it's available in your PATH.
To install CMake, use your platform's package manager, or the official release, and make sure it's available in your PATH.

Get the source code

You can find the sources at https://github.com/mmatyas/pegasus-frontend. Download it using your favorite Git client, or as a zip file from the webpage.

If you are using the command line, make sure you also get the submodules:

git clone --recursive https://github.com/mmatyas/pegasus-frontend

In case you forgot, you can do it after clone too:

git submodule update --init

Build

Pegasus is a Qt project. Qt provides a graphical IDE, called Qt Creator, which you can use building such projects, or you can call Qt's qmake tool directly from the command line.

Alternatively, if you have Qt 5.15 or later, you can also use CMake, of which at least version 3.16 is required. You can find the official CMake releases here.

Using Qt Creator

1. Open Qt Creator and open the project file (pegasus.pro)
2. Qt Creator will ask you which Qt setup ("kit") you want to use (in case you've installed multiple versions), and where you want to place the generated build files. If everything's OK, click Configure Project.
3. (optional) Change the configuration (see below)

4. In the bottom left corner, on the sidebar of Qt Creator, you can find 4 buttons:

   with the button that looks like a desktop monitor, you can change the build type (optimized Release build or development-friendly but slower Debug build) the green arrow will build and run the program the green arrow with a bug will also open several debug toolbars the hammer will build the project but won't start the application

5. Change the build type to Release, and press the green arrow to build and run the project.

Using qmake

1. Create a build directory somewhere, and step into it
2. Call qmake like this: /path/to/qmake path/to/pegasus [options].
   • If you have multiple Qt versions installed, make sure you call the right qmake.
     If you've installed using the official release from the Qt site, you can find it in [qt-installdir]/Qt5/[version]/gcc_64/bin. You can add it to your PATH if you want, but it's not necessary.
   • You can also change some configuration options, which you can find below.
3. Call make
4. (optional) Call make check to run tests.
5. (optional) Call make install

Using CMake

This section assumes you have some experience with CMake, as you can build Pegasus just like any other CMake project:

1. Create a build directory somewhere, and step into it
2. Call cmake like this: /path/to/cmake path/to/pegasus [options], or use the CMake GUI for configuration; you can find the details below
3. Call your build tool (eg. make) to build the project
4. (optional) Call ctest to run tests
5. (optional) Call the install/strip target of your build tool for deployment

Configuration options

Using qmake

For qmake, the Qt configuration tool, you can change build parameters by appending KEY=VALUE pairs to its command line call. If you're using Qt Creator, you can find these settings on the Projects -> Build settings tab, where you can modify the Additional arguments option (see here).

The following parameters are supported:

If SDL_LIBS and SDL_INCLUDES are both empty, but an SDL-option is enabled (eg. USE_SDL_GAMEPAD), then pkg-config will be used to find it, on platforms where it is available. Note that only the gamepad module is used from SDL, so if you're building it on your own, you can turn off many of its features during configuration. You should not link to SDL2main.

Deployment

Some platforms optionally support installing and deploying builds. In practice, this means preparing the final executable and copying it to a particular location. The behaviour can be controlled through the following parameters:

Example

qmake path/to/sources \
    USE_SDL_GAMEPAD=1 \
    SDL_LIBS="-L/path/to/sdl/lib/ -lSDL2 -Wl,--no-undefined" \
    SDL_INCLUDES=/path/to/sdl/include/SDL2/
    INSTALL_BINDIR=/usr/bin \
    INSTALL_DOCDIR=/usr/share/doc/pegasus-frontend \
    INSTALL_ICONDIR=/usr/share/icons/hicolor \
    INSTALL_DESKTOPDIR=/app/share/applications \
    INSTALL_APPSTREAMDIR=/app/share/metainfo

Using CMake

For CMake, you can either use its GUI, or add -Dkey=value option to the command line call. In addition to the standard CMake parameters, the following Pegasus-specific options are supported:

To explicitly tell where Qt and SDL is located, you can use CMAKE_PREFIX_PATH, which is a semicolon-separated list of search paths.

For deployment, the standard GNUInstallDirs module is used, ie. on Linux most paths should have a correct default value. You can use CMAKE_INSTALL_PREFIX to set the root deployment directory. If you wish to customize the paths, use the following parameters:

Example

cmake path/to/sources  \
  -DCMAKE_PREFIX_PATH="/opt/Qt5;/opt/SDL2"  \
  -DCMAKE_INSTALL_PREFIX=/usr/  \
  -DPEGASUS_ENABLE_APNG=ON  \
  -DPEGASUS_ENABLE_LTO=OFF