The Eternity Engine

Eternity is an advanced http://doomwiki.org/wiki/Doom[DOOM] source port maintained by James Quasar'' Haley, descended from Simonfraggle'' Howard's SMMU. It has a whole host of advanced features for editors and players alike, including:

• http://doomwiki.org/wiki/ACS[ACS], including many of ZDoom's enhancements

• http://eternity.youfailit.net/index.php?title=EDF[EDF], Eternity Definition File, a language to define and modify monsters, decorations, sounds, text strings, menus, terrain types, and other kinds of data.

• http://doomwiki.org/wiki/ENDOOM[ENDOOM] and animated startup screen support.

• High-resolution support (practically unlimited).

• Support for Master Levels and No Rest for the Living, allowing to play them without command line options.

• Portals which can be used to create skyboxes and fake 3D architecture. Linked portal allow objects to pass through them, as well.

• http://www.libpng.org/pub/png/[PNG] support

• Aided with http://libsdl.org/[SDL 2], Eternity is very portable and runs on a large range of operating systems: Windows (confirmed as low as XP, and all the way through Windows 10), Linux, Mac OS X, FreeBSD, OpenBSD, and more.

• Heretic, Hexen, and Strife support in-progress.

For more on its features, check out the http://eternity.youfailit.net/index.php?title=Main_Page[Eternity Engine Wiki].

Eternity Engine is maintained using the Git version control system, and the canonical source of the repository is available at https://github.com/team-eternity/eternity[GitHub].

Compiling

There are four ways available for building Eternity: CMake, Visual Studio, Xcode files, and Homebrew, for Unix, Windows, and both Mac OS X respectively.

Git submodule

The project contains the ADLMIDI submodule. You need to load it after you've just cloned Eternity, by using this command:

----
git submodule update --init
----

Building with CMake (Unix OSes and Visual Studio 2017+)

CMake should be capable of generating build files for all platforms, but it is most commonly used only for Unix OSes and Windows, and not thoroughly tested outside of it.

. If you haven't already, extract the source *.zip file or clone the Git repository, in the top-level directory you should see a +CMakeLists.txt+ file. You should be in this directory.

. Create a new empty directory and change to it, eg: +mkdir build+ followed by +cd build+. You cannot do an in-tree build.

. If using Visual Studio make sure that you have installed the MFC and ATL components for whatever version you are using.

. Run CMake. Usually you will want to run +cmake ..+, but you might want to change the generator with a special command, for example: +

cmake .. -G "Unix Makefiles" cmake .. -DCMAKE_BUILD_TYPE=Debug -DCMAKE_PREFIX_PATH=C:\sdk\x64 -G "NMake Makefiles" cmake .. -DCMAKE_BUILD_TYPE=MinSizRel -G "Visual Studio 15 2017 Win64" cmake .. -G "Visual Studio 16 2019" -A "x64"

. Run your build tool. On Unix, you probably want to just run +make+.

As an optional final step, you can create a binary installation package with CPack. For Windows, it will collect all the needed runtime libraries and bundle it with the Eternity engine. Some examples:

cpack -G ZIP cpack -G DEB cpack -G RPM cpack -G STGZ

Building with Xcode

You need Mac OS X 10.7 or more to run Eternity.

* Open Xcode and load macosx/EternityEngine.xcodeproj. This builds the main game
executable. Any dependencies should be automatically downloaded.

* If you want to build the full package, open 
macosx/launcher/EternityLaunch.xcodeproj. It depends on EternityEngine.xcodeproj
to generate the executable which gets bundled in the user-friendly app package.

* To actually make distributable app builds, don't use the master Git branch.
Instead go to the "release-mac" branch, updating it from master as necessary.
First you need to produce a release Eternity executable. Load
EternityEngine.xcodeproj and build an archive. Export it as a folder release and
copy the "eternity" executable into macosx/builds/ (create the "builds" 
subdirectory if missing). Now close EternityEngine.xcodeproj and open
EternityLaunch.xcodeproj. You'll need to replace my code signing with yours, or 
keep it unsigned if you're not enrolled in Apple's developer programme. Build
an archive and export it as a developer ID signed application (or unsigned).
You will then obtain a valid .app package.


Building with Homebrew (OS X Mavericks and up)

The benefit of Homebrew compilation is that you don't need to "install" Eternity like a standard Mac application. However, this will require some extra work. You will also need to run Eternity as you would in Unix.

These instructions are written with the assumption that the user has already set up Homebrew and the required dependencies. Please note that as of the latest Mavericks updates, GCC is no longer required. If you are using an older cmake release folder, you will need to create a new one.

• You will need the following libraries:

cmake sdl2 sdl2_mixer sdl2_net libogg libvorbis flac libmpeg2 libmodplug

• Follow the cmake instructions.

cmake .. -DCMAKE_BUILD_TYPE=Release make