Architecture

Introduction

Core Engine is a complex system and this section will help you to get a grasp on its inner structure.

Configuring Core Engine

As you've already seen in Quick Start guide, you start by creating core::CoreConfig object in your project.

Q: Why bother?

A: Core Engine is a highly flexible platform and might be configured differently to achieve different goals. By manually specifying parts you wish to use in it you get full freedom of what you want to do with it afterwards.

Unlike Unity and Unreal engines, which only give you some degree of freedom by adding some functionality to the heavy engines themself, you can control Core Engine build entirely. It's up to the point where you don't have to include any of the standard modules to the build.

Q: Why wouldn't I want to include them? Are they bad?

A: If you would try to serve every goal at the same time you risk to end up huge and bloated, just like the aforementioned and many other engines and tools. Thus, if any of the standard modules don't fit your project, you might want to extend or rewrite them completely, and use your own version. With Core Engine this process would be a breeze.

By plugging different modules in and out, you might change Core Enigne architecture completely. This page will focus on the standard build configuration (i.e. including all the standard modules shipped with the engine itself).

List of standard Core Engine modules

• Engine module
• Input module
• Render module
• Scene module
• Window module
• Math module
• Sound module // To be implemented
• Physics module // To be implemented
• Network module // To be implemented

Engine life cycle

After core::CoreConfig has been built into core::Core object, you might do your project internal initialization, using connected modules if needed.
Once initialization step is done, you need to send execution flow into main engine loop (aka game loop) by calling EngineModule::Main() function, for example, like this:

Core::GetModule<EngineModule>()->Main();

This is the main function of the engine. After it completes post-intialization command sequence, it will send execution flow into the main engine loop, by calling core::EngineLoop::Enter()
Once execution flow enters main game loop, it stays there until exit from loop is requested
You can request exit by calling EngineLoop::Stop() or by changing value of exitRequested member inside InputModule.

After exiting main loop the program will continue its flow after EngineModule::Main() call. Any members described in the initializing sequence will still be available until they go out of scope.

This usually concludes engine life cycle and program stops.

Continue reading: Entity system