Discover Illation/ETEngine Open Source project

Realtime 3D Graphics/Simulation/Game-Engine written in C++ 14.

Focus is on ease of use, extensibility, performance and providing rendering features for planet scale environments, enabling space games and simulations.

E.T. stands for "extra terrestial" due to the goal for this technology to go to space one day.

This project is under active development, and while a wide range of features are implemented and the overall architecture is approaching a cohesive state, many of the planned improvements are likely to touch a large crossection of the codebase. Therefore, while breaking changes are usually implemented in separate branches, the interface on the master branch changes relatively frequently.

Discuss it on Discord!

Features:

Rendering

Rendering is based on modern principals including Physically based Rendering. The data driven material system allows for custom shaders and parameter inheritance through material instances (similar to UE4). A variety of rendering features aimed at space simulation have been implemented, such as planet terrain generation, atmospheric scattering and Starfields based on real sky data.

Modular Architecture

The project is split into multiple libraries. Low level libraries such as core or rendering can be used independently from high level ones such as the framework. Many features have interfaces and implementations, allowing overriding of functionality. If you want to implement your own renderer or support a different file system, you can do that.

Data oriented design

Many performance critical sections have been programmed with aspects such as cache locality in mind. The renderer uses an optimized scene structure and can operate independently from the gameplay side scene. Gameplay features are implemented using an Archetype based Entity Component System.

Data Driven

Anything that is not a behavior can be described with data. The Resource manager allows for custom asset types. Reflection of data structures allows for automated serialization and deserialization of content. The work in progress editor will allow for easy editing, and control the workflow from Content creation tools to optimized engine formats.

How to build

For visual studio 2017:

git clone https://github.com/Illation/ETEngine
cd ETEngine/Projects/Demo
cmake -G "Visual Studio 15 2017 Win64" -S . -B build
cmake --build build --target all --config Develop
cmake --build build --target install
cmake --build build --target cook-installed-resources-EtEngineDemo

For more information (including unit tests and content cooking) check the build documentation.

Continuous Integration

Due to an issue with library dependencies CI is currently not working. However the project has been built outside of automated build scripts and works just fine.

Background

This project started off in 2016 as an OpenGL graphics framework based on the "Overlord Engine" (Dx11) from the Graphics Programming course at Howest University

In parallel I was writing my graduation work on realtime planet rendering, and in 2017 I merged the two projects into this engine.

Since then I added a variety of graphics and gameplay features, however due to the design at the time this was getting increasingly difficult.

Therefore, starting in 2019, the main focus has been on improving the Architecture and focusing on useability and extensibility, and the codebase has been nearly completely rewritten since.

Approximate Changelog

0.0 :

Initial OpenGL Graphics Framework implementation

0.1 :

Virtual File System
Deferred rendering
Physically based rendering
Post processing
Planet rendering
atmospheric scattering

0.2 :

Custom math library
Physics and Audio integration
Unit testing
Continuous integration
Json parser, GLTF

0.3 :

CMake build
Separate core library - update system
reflection; serialization / deserialization

0.4 :

Resource Manager, Asset Database
Package file format
Cooker
Asset Pointer

0.5 :

GTKmm based editor app
Abstract Graphics API
Cross context rendering viewport - support for multiple (3D) viewports
Flexible editor tool windowing system

0.6 :

Separated rendering / framework / runtime libraries
Optimized render scene with minimal graphics objects - scene renderer no longer traverses scene graph
Data driven material system

0.7 :

Archetype based Entity Component System
Removed previous scene graph structure, all game object behavior is expressed through components and systems
Scene Descriptor asset - scenes now described in files
Application Runtime and Editor can share custom data assets through common library