blob: 17bddd1a1a1b09201f2f1c7a3ced7832042a5ba3 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
#pragma once
#include <memory>
#include "../facade/SDLContext.h"
#include "../manager/ComponentManager.h"
#include "../manager/SceneManager.h"
#include "../system/System.h"
#include "manager/SceneManager.h"
#include "api/Event.h"
#include "api/LoopTimer.h"
namespace crepe {
/**
* \brief Main game loop manager
*
* This class is responsible for managing the game loop, including initialization and updating.
*/
class LoopManager {
public:
/**
* \brief Start the gameloop
*
* This is the start of the engine where the setup is called and then the loop keeps running until the game stops running.
* Developers need to call this function to run the game.
*/
void start();
LoopManager();
/**
* \brief Add a new concrete scene to the scene manager
*
* \tparam T Type of concrete scene
*/
template <typename T>
void add_scene();
private:
/**
* \brief Setup function for one-time initialization.
*
* This function initializes necessary components for the game.
*/
void setup();
/**
* \brief Main game loop function.
*
* This function runs the main loop, handling game updates and rendering.
*/
void loop();
/**
* \brief Function for handling input-related system calls.
*
* Processes user inputs from keyboard and mouse.
*/
void process_input();
/**
* \brief Per-frame update.
*
* Updates the game state based on the elapsed time since the last frame.
*/
void update();
/**
* \brief Late update which is called after update().
*
* This function can be used for final adjustments before rendering.
*/
void late_update();
/**
* \brief Fixed update executed at a fixed rate.
*
* This function updates physics and game logic based on LoopTimer's fixed_delta_time.
*/
void fixed_update();
/**
* \brief Function for executing render-related systems.
*
* Renders the current state of the game to the screen.
*/
void render();
bool game_running = false;
private:
//! Global context
Mediator mediator;
//! Component manager instance
ComponentManager component_manager{mediator};
//! Scene manager instance
SceneManager scene_manager{mediator};
//! SDL context \todo no more singletons!
SDLContext & sdl_context = SDLContext::get_instance();
//! loop timer instance
std::unique_ptr<LoopTimer> loop_timer;
private:
//! callback function for shutdown event
bool on_shutdown(const ShutDownEvent & e);
/**
* \brief Collection of System instances
*
* This map holds System instances indexed by the system's class typeid. It is filled in the
* constructor of LoopManager using LoopManager::load_system.
*/
std::unordered_map<std::type_index, std::unique_ptr<System>> systems;
/**
* \brief Initialize a system
* \tparam T System type (must be derivative of \c System)
*/
template <class T>
void load_system();
/**
* \brief Retrieve a reference to ECS system
* \tparam T System type
* \returns Reference to system instance
* \throws std::runtime_error if the System is not initialized
*/
template <class T>
T & get_system();
};
} // namespace crepe
#include "LoopManager.hpp"
|