#include <GameManager.h>

Public Member Functions
	GameManager (const GameManager &)=delete

GameManager &	operator= (const GameManager &)=delete

void	setGarbageCollectorRunInterval (long long iGcRunIntervalInSec)

void	queueGarbageCollection (bool bForce, const std::optional< std::function< void()> > &onFinished={})

void	addDeferredTask (const std::function< void()> &task)

void	addTaskToThreadPool (const std::function< void()> &task)

void	createWorld (const std::function< void(const std::optional< Error > &)> &onCreated, size_t iWorldSize=Globals::getDefaultWorldSize())

void	loadNodeTreeAsWorld (const std::function< void(const std::optional< Error > &)> &onLoaded, const std::filesystem::path &pathToNodeTree, size_t iWorldSize=Globals::getDefaultWorldSize())

sgc::GcPtr< Node >	getWorldRootNode ()

float	getWorldTimeInSeconds ()

size_t	getWorldSize ()

size_t	getTotalSpawnedNodeCount ()

size_t	getCalledEveryFrameNodeCount ()

Window *	getWindow () const

GameInstance *	getGameInstance () const

CameraManager *	getCameraManager () const

float	getTimeSincePrevFrameInSec () const

long long	getGarbageCollectorRunIntervalInSec () const

bool	isNodeSpawned (size_t iNodeId)

bool	isBeingDestroyed () const

Static Public Member Functions
static GameManager *	get ()

Private Member Functions
	GameManager (Window *pWindow)

std::optional< Error >	initialize (std::optional< RendererType > preferredRenderer)

void	destroy ()

template<typename MyGameInstance > requires std::derived_from<MyGameInstance, GameInstance>
void	setGameInstance ()

void	onGameStarted ()

void	onBeforeNewFrame (float timeSincePrevCallInSec)

void	onKeyboardInput (KeyboardKey key, KeyboardModifiers modifiers, bool bIsPressedDown)

void	onMouseInput (MouseButton button, KeyboardModifiers modifiers, bool bIsPressedDown)

void	onMouseMove (double xOffset, double yOffset)

void	onMouseScrollMove (int iOffset)

void	onWindowFocusChanged (bool bIsFocused) const

void	onFramebufferSizeChanged (int iWidth, int iHeight) const

void	onWindowClose () const

void	onTickFinished ()

void	runGarbageCollection (bool bForce=false)

void	executeDeferredTasks ()

void	triggerActionEvents (std::variant< KeyboardKey, MouseButton > key, KeyboardModifiers modifiers, bool bIsPressedDown)

void	triggerAxisEvents (KeyboardKey key, KeyboardModifiers modifiers, bool bIsPressedDown)

void	destroyAndCleanExistingWorld ()

Private Attributes
Window *	pWindow

std::unique_ptr< GameInstance >	pGameInstance

std::pair< std::recursive_mutex, std::unique_ptr< World > >	mtxWorld

std::unique_ptr< Renderer >	pRenderer

std::unique_ptr< CameraManager >	pCameraManager

ThreadPool	threadPool

std::pair< std::recursive_mutex, std::queue< std::function< void()> > >	mtxDeferredTasks

InputManager	inputManager

std::chrono::steady_clock::time_point	lastGcRunTime

float	timeSincePrevFrameInSec = 0.0F

long long	iGcRunIntervalInSec = 120

std::thread::id	mainThreadId

bool	bShouldAcceptNewDeferredTasks = true

bool	bIsInitialized = false

bool	bIsBeingDestroyed = false

Static Private Attributes
static const char *	sGcLeakReasons

Friends
class	Window

Detailed Description

Controls main game objects: game instance, input manager, renderer, audio engine, physics engine and etc.

Remarks: Owned by Window object.

Constructor & Destructor Documentation

◆ GameManager()

ne::GameManager::GameManager ( Window * pWindow )

private

Creates uninitialized GameManager.

Remarks: Use initialize to initialize the manager.

Parameters

pWindow Window that owns this object.

Member Function Documentation

◆ addDeferredTask()

void ne::GameManager::addDeferredTask ( const std::function< void()> & task )

Adds a function to be executed on the main thread next time onBeforeNewFrame is called.

Warning: Don't capture gc pointers in std::function, this is not supported and will cause memory leaks/crashes!; If you are using member functions/fields inside of the task you need to make sure that the owner object of these member functions/fields will not be deleted until this task is finished. If you use GameInstance or Node member functions/fields inside of the task and submitting a deferred tasks from the main thread then ignore this warning, they are safe to use in deferred tasks and will not be deleted until the task is finished. If you are submitting a deferred task that operates on a GameInstance/Node from a non main thread then you need to do a few additional checks inside of your deferred task, for example:
// We are on a non-main thread inside of a node:

addDeferredTask([this, iNodeId](){ // capturing `this` to use `Node` (self) functions, also

capturing self ID

// We are inside of a deferred task (on the main thread) and we don't know if the node (`this`)

// was garbage collected or not because we submitted our task from a non-main thread.

// REMEMBER: we can't capture `gc` pointers in `std::function`, this is not supported

// and will cause memory leaks/crashes!

const auto pGameManager = GameManager::get(); // using engine's private class `GameManager`

// `pGameManager` is guaranteed to be valid inside of a deferred task.

// Otherwise, if running this code outside of a deferred task you need to do 2 checks:

// if (pGameManager == nullptr) return;

// if (pGameManager->isBeingDestroyed()) return;

if (!pGameManager->isNodeSpawned(iNodeId)){

// Node was despawned and it may be dangerous to run the callback.

return;

}

// Can safely interact with `this` (self) - we are on the main thread.

});

ne::GameManager::get
static GameManager * get()
Definition: GameManager.cpp:299

ne::GameManager::addDeferredTask
void addDeferredTask(const std::function< void()> &task)
Definition: GameManager.cpp:570

Remarks: In the task you don't need to check if the game is being destroyed, the engine makes sure all tasks are finished before the game is destroyed.

Parameters

task	Function to execute.

◆ addTaskToThreadPool()

void ne::GameManager::addTaskToThreadPool ( const std::function< void()> & task )

Adds a function to be executed on the thread pool.

Warning: Don't capture gc pointers in std::function, this is not supported and will cause memory leaks/crashes!; If you are using a member functions/fields inside of the task you need to make sure that the owner object of these member functions/fields will not be deleted until this task is finished.

Remarks: In the task you don't need to check if the game is being destroyed, the engine makes sure all tasks are finished before the game is destroyed.

Parameters

task	Function to execute.

◆ createWorld()

void ne::GameManager::createWorld	(	const std::function< void(const std::optional< Error > &)> &	onCreated,
		size_t	iWorldSize = `Globals::getDefaultWorldSize()`
	)

Adds a deferred task (see addDeferredTask) to create a new world that contains only one node - root node.

Remarks: Causes GameInstance::onWorldLoaded to be called after the world is loaded.; Replaces the old world (if existed).; Engine will execute all deferred tasks before changing the world (before destroying all nodes), so even if deferred tasks queue looks like this: ... – create/load world task – call node's member function task – ..., on create/load world task the engine will finish all other tasks and only when deferred tasks queue is empty start to create/load world so you don't need to care about the order of deferred tasks.

Parameters

onCreated Callback function that will be called on the main thread after the world is created. Contains optional error (if world creation failed) as the only argument. Use GameInstance member functions as callback functions for created worlds, because all nodes and other game objects will be destroyed while the world is changing.

iWorldSize Size of the new world in game units. Must be power of 2 (128, 256, 512, 1024, 2048, etc.). World size needs to be specified for internal purposes such as Directional Light shadow map size. You don't need to care why we need this information, you only need to know that if you leave world bounds lighting or physics may be incorrect (the editor or engine will warn you if something is leaving world bounds, pay attention to the logs).

◆ destroy()

void ne::GameManager::destroy ( )

private

Contains destructor logic: runs GC for the last time, destroys game instance, etc.

Warning: Should be called from the main thread.

Remarks: Can be safely called multiple times (additional calls will be ignored).; Can be used to destroy the game without clearing the actual game pointer.

◆ destroyAndCleanExistingWorld()

void ne::GameManager::destroyAndCleanExistingWorld ( )

private

Destroys the current world (if exists) and runs GC to clean everything up.

Warning: This function should be called from the main thread. If this function is called outside of the main thread an error will be shown.

◆ executeDeferredTasks()

void ne::GameManager::executeDeferredTasks ( )

private

Executes all deferred tasks from mtxDeferredTasks.

◆ get()

GameManager * ne::GameManager::get ( )

static

Returns the last created game manager object.

Warning: Avoid using this getter, use only when there's no other good way to get game manager object.; As an addition to checking returned pointer for nullptr use isBeingDestroyed.

Returns: nullptr if no game manager object was created yet, otherwise pointer to game manager object.

◆ getCalledEveryFrameNodeCount()

size_t ne::GameManager::getCalledEveryFrameNodeCount ( )

Returns the current amount of spawned nodes that are marked as "should be called every frame".

Returns: Amount of spawned nodes that should be called every frame.

◆ getCameraManager()

CameraManager * ne::GameManager::getCameraManager ( ) const

Returns camera manager.

Returns: Do not delete this pointer. Camera manager.

◆ getGameInstance()

GameInstance * ne::GameManager::getGameInstance ( ) const

Returns game instance that this game is using (Game owns GameInstance).

Returns: Do not delete this pointer. Used game instance.

◆ getGarbageCollectorRunIntervalInSec()

long long ne::GameManager::getGarbageCollectorRunIntervalInSec ( ) const

Returns the current interval after which we need to run garbage collector again.

Returns: Interval in seconds.

◆ getTimeSincePrevFrameInSec()

float ne::GameManager::getTimeSincePrevFrameInSec ( ) const

Returns the last time value that was passed to onBeforeNewFrame function(s).

Returns: Delta time.

◆ getTotalSpawnedNodeCount()

size_t ne::GameManager::getTotalSpawnedNodeCount ( )

Returns total amount of currently spawned nodes.

Returns: Total nodes spawned right now.

◆ getWindow()

Window * ne::GameManager::getWindow ( ) const

Returns window that owns this object.

Returns: Do not delete this pointer. Window that owns this object.

◆ getWorldRootNode()

sgc::GcPtr< Node > ne::GameManager::getWorldRootNode ( )

Returns a pointer to world's root node.

Returns: nullptr if world is not created (see createWorld), otherwise world's root node.

◆ getWorldSize()

size_t ne::GameManager::getWorldSize ( )

Returns world size in game units.

Returns: World size.

◆ getWorldTimeInSeconds()

float ne::GameManager::getWorldTimeInSeconds ( )

Returns time since world creation (in seconds).

Returns: Zero if world is not created (see createWorld), otherwise time since world creation (in seconds).

◆ initialize()

std::optional< Error > ne::GameManager::initialize ( std::optional< RendererType > preferredRenderer )

private

Initializes the manager.

Parameters

preferredRenderer Preferred renderer to be used.

Returns: Error if something went wrong.

◆ isBeingDestroyed()

bool ne::GameManager::isBeingDestroyed ( ) const

Tells whether Game's destruction process was started or not.

Returns: Whether Game's destruction process was started or not.

◆ isNodeSpawned()

bool ne::GameManager::isNodeSpawned ( size_t iNodeId )

Tells if a node with the specified ID is currently spawned or not.

Parameters

iNodeId ID of the node to check.

Returns: true if the node is spawned, false otherwise.

◆ loadNodeTreeAsWorld()

void ne::GameManager::loadNodeTreeAsWorld	(	const std::function< void(const std::optional< Error > &)> &	onLoaded,
		const std::filesystem::path &	pathToNodeTree,
		size_t	iWorldSize = `Globals::getDefaultWorldSize()`
	)

Adds a deferred task (see addDeferredTask) to load and deserialize a node tree to be used as the new world.

Node tree's root node will be used as world's root node.

Remarks: Replaces the old world (if existed).; Engine will execute all deferred tasks before changing the world (before destroying all nodes), so even if deferred tasks queue looks like this: ... – create/load world task – call node's member function task – ..., on create/load world task the engine will finish all other tasks and only when deferred tasks queue is empty start to create/load world so you don't need to care about the order of deferred tasks.

Parameters

onLoaded	Callback function that will be called on the main thread after the world is loaded. Contains optional error (if world loading failed) as the only argument. Use GameInstance member functions as callback functions for loaded worlds, because all nodes and other game objects will be destroyed while the world is changing.
pathToNodeTree	Path to the file that contains a node tree to load, the ".toml" extension will be automatically added if not specified.
iWorldSize	Size of the world in game units. Must be power of 2 (128, 256, 512, 1024, 2048, etc.). World size needs to be specified for internal purposes such as Directional Light shadow map size. You don't need to care why we need this information, you only need to know that if you leave world bounds lighting or physics may be incorrect (the editor or engine will warn you if something is leaving world bounds, pay attention to the logs).

◆ onBeforeNewFrame()

void ne::GameManager::onBeforeNewFrame ( float timeSincePrevCallInSec )

private

Called before a new frame is rendered.

Parameters

timeSincePrevCallInSec Time in seconds that has passed since the last call to this function.

◆ onFramebufferSizeChanged()

void ne::GameManager::onFramebufferSizeChanged	(	int	iWidth,
		int	iHeight
	)		const

private

Called when the framebuffer size was changed.

Parameters

iWidth	New width of the framebuffer (in pixels).
iHeight	New height of the framebuffer (in pixels).

◆ onGameStarted()

void ne::GameManager::onGameStarted ( )

private

Called by owner Window to notify game instance about game being started (everything is set up).

Remarks: Expects game instance to exist.

◆ onKeyboardInput()

void ne::GameManager::onKeyboardInput	(	KeyboardKey	key,
		KeyboardModifiers	modifiers,
		bool	bIsPressedDown
	)

private

Called when the window (that owns this object) receives keyboard input.

Parameters

key	Keyboard key.
modifiers	Keyboard modifier keys.
bIsPressedDown	Whether the key down event occurred or key up.

◆ onMouseInput()

void ne::GameManager::onMouseInput	(	MouseButton	button,
		KeyboardModifiers	modifiers,
		bool	bIsPressedDown
	)

private

Called when the window (that owns this object) receives mouse input.

Parameters

button	Mouse button.
modifiers	Keyboard modifier keys.
bIsPressedDown	Whether the button down event occurred or button up.

◆ onMouseMove()

void ne::GameManager::onMouseMove	(	double	xOffset,
		double	yOffset
	)

private

Called when the window received mouse movement.

Parameters

xOffset	Mouse X movement delta in pixels (plus if moved to the right, minus if moved to the left).
yOffset	Mouse Y movement delta in pixels (plus if moved up, minus if moved down).

◆ onMouseScrollMove()

void ne::GameManager::onMouseScrollMove ( int iOffset )

private

Called when the window receives mouse scroll movement.

Parameters

iOffset Movement offset.

◆ onTickFinished()

void ne::GameManager::onTickFinished ( )

private

Called by the owner when a tick is fully finished.

Warning: This function should be called on the main thread.

◆ onWindowClose()

void ne::GameManager::onWindowClose ( ) const

private

Called when a window that owns this game instance was requested to close (no new frames will be rendered). Prefer to do your destructor logic here.

◆ onWindowFocusChanged()

void ne::GameManager::onWindowFocusChanged ( bool bIsFocused ) const

private

Called when the window focus was changed.

Parameters

bIsFocused Whether the window has gained or lost the focus.

◆ queueGarbageCollection()

void ne::GameManager::queueGarbageCollection	(	bool	bForce,
		const std::optional< std::function< void()> > &	onFinished = `{}`
	)

Queues a request to run a garbage collection as a deferred task on the main thread using addDeferredTask.

Remarks: Typically you don't need to call this function as garbage collection is executed regularly (see setGarbageCollectorRunInterval) but you can still call it anyway.; Note that garbage collection will also be executed additionally in some special cases, such as when World is being destructed or some nodes are being detached and despawned.

Parameters

bForce	Force run garbage collection even if the last garbage collection was run not so long ago.
onFinished	Optional callback that will be triggered on the main thread when garbage collection is finished (queued as addDeferredTask).

◆ runGarbageCollection()

void ne::GameManager::runGarbageCollection ( bool bForce = false )

private

Runs garbage collection if enough time has passed since the last garbage collection (see setGarbageCollectorRunInterval).

Warning: This function should be called from the main thread. If this function is called outside of the main thread an error will be shown.

Parameters

bForce Force run garbage collection even if the last garbage collection was run not so long ago.

◆ setGameInstance()

template<typename MyGameInstance >
requires std::derived_from<MyGameInstance, GameInstance>

void ne::GameManager::setGameInstance ( )

inlineprivate

Set GameInstance derived class to react to user inputs, window events and etc.

◆ setGarbageCollectorRunInterval()

void ne::GameManager::setGarbageCollectorRunInterval ( long long iGcRunIntervalInSec )

Modifies the interval after which we need to run garbage collector again. The current value can be retrieved using getGarbageCollectorRunIntervalInSec.

Remarks: Interval should be in range [30; 300] seconds (otherwise it will be clamped).; Note that garbage collection will also be executed additionally in some special cases, such as when World is being destructed or some nodes are being detached and despawned.

Parameters

iGcRunIntervalInSec Interval in seconds.

◆ triggerActionEvents()

void ne::GameManager::triggerActionEvents	(	std::variant< KeyboardKey, MouseButton >	key,
		KeyboardModifiers	modifiers,
		bool	bIsPressedDown
	)

private

Triggers action events from keyboard/mouse input.

Parameters

key	Keyboard/mouse key.
modifiers	Keyboard modifier keys.
bIsPressedDown	Whether the key down event occurred or key up.

◆ triggerAxisEvents()

void ne::GameManager::triggerAxisEvents	(	KeyboardKey	key,
		KeyboardModifiers	modifiers,
		bool	bIsPressedDown
	)

private

Triggers axis events from keyboard input.

Parameters

key	Keyboard key.
modifiers	Keyboard modifier keys.
bIsPressedDown	Whether the key down event occurred or key up.

Member Data Documentation

◆ bIsBeingDestroyed

bool ne::GameManager::bIsBeingDestroyed = false

private

Whether destroy was called or not.

◆ bIsInitialized

bool ne::GameManager::bIsInitialized = false

private

Whether initialize was called or not.

◆ bShouldAcceptNewDeferredTasks

bool ne::GameManager::bShouldAcceptNewDeferredTasks = true

private

Whether addDeferredTask should accept new tasks or not.

◆ iGcRunIntervalInSec

long long ne::GameManager::iGcRunIntervalInSec = 120

private

Interval in seconds after which we need to run garbage collector again.

◆ inputManager

InputManager ne::GameManager::inputManager

private

Binds action/axis names with input keys.

◆ lastGcRunTime

std::chrono::steady_clock::time_point ne::GameManager::lastGcRunTime

private

Last time we run garbage collector.

◆ mainThreadId

std::thread::id ne::GameManager::mainThreadId

private

ID of the main thread.

◆ mtxDeferredTasks

std::pair<std::recursive_mutex, std::queue<std::function<void()> > > ne::GameManager::mtxDeferredTasks

private

Mutex for read/write operations on deferred tasks queue. Queue of functions to call on the main thread before each frame is rendered.

◆ mtxWorld

std::pair<std::recursive_mutex, std::unique_ptr<World> > ne::GameManager::mtxWorld

private

Game world, stores world's node tree.

◆ pCameraManager

std::unique_ptr<CameraManager> ne::GameManager::pCameraManager

private

Determines what camera is used as in-game eyes.

◆ pGameInstance

std::unique_ptr<GameInstance> ne::GameManager::pGameInstance

private

Reacts to user input, window events and etc.

◆ pRenderer

std::unique_ptr<Renderer> ne::GameManager::pRenderer

private

Draws graphics on window.

◆ pWindow

Window* ne::GameManager::pWindow

private

Do not delete this pointer. Window-owner of this Game.

◆ sGcLeakReasons

const char* ne::GameManager::sGcLeakReasons

inlinestaticprivate

Initial value:

=
            "- you are switching a world but your game instance holds some non-nullptr gc pointers,\n"
            "- you are not using STL container wrappers for gc "
            "pointers (for example, you need to use `sgc::GcVector<sgc::GcPtr<T>>` instead of "
            "`std::vector<sgc::GcPtr<T>>`, and other `gc_*` containers when storing gc pointers),\n"
            "- you are capturing `sgc::GcPtr` pointer(s) in `std::function` (this might leak in some "
            "special),\n"
            "- for a more detailed list of possible issues see the \"README\" file at "
            "https://github.com/Flone-dnb/sgc"

Description of reasons why a leak may occur.

◆ threadPool

ThreadPool ne::GameManager::threadPool

private

Thread pool to execute tasks.

◆ timeSincePrevFrameInSec

float ne::GameManager::timeSincePrevFrameInSec = 0.0F

private

The last time value that was passed to onBeforeNewFrame.

The documentation for this class was generated from the following files:

src/engine_lib/private/game/GameManager.h
src/engine_lib/private/game/GameManager.cpp

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ GameManager()

Member Function Documentation

◆ addDeferredTask()

◆ addTaskToThreadPool()

◆ createWorld()

◆ destroy()

◆ destroyAndCleanExistingWorld()

◆ executeDeferredTasks()

◆ get()

◆ getCalledEveryFrameNodeCount()

◆ getCameraManager()

◆ getGameInstance()

◆ getGarbageCollectorRunIntervalInSec()

◆ getTimeSincePrevFrameInSec()

◆ getTotalSpawnedNodeCount()

◆ getWindow()

◆ getWorldRootNode()

◆ getWorldSize()

◆ getWorldTimeInSeconds()

◆ initialize()

◆ isBeingDestroyed()

◆ isNodeSpawned()

◆ loadNodeTreeAsWorld()

◆ onBeforeNewFrame()

◆ onFramebufferSizeChanged()

◆ onGameStarted()

◆ onKeyboardInput()

◆ onMouseInput()

◆ onMouseMove()

◆ onMouseScrollMove()

◆ onTickFinished()

◆ onWindowClose()

◆ onWindowFocusChanged()

◆ queueGarbageCollection()

◆ runGarbageCollection()

◆ setGameInstance()

◆ setGarbageCollectorRunInterval()

◆ triggerActionEvents()

◆ triggerAxisEvents()

Member Data Documentation

◆ bIsBeingDestroyed

◆ bIsInitialized

◆ bShouldAcceptNewDeferredTasks

◆ iGcRunIntervalInSec

◆ inputManager

◆ lastGcRunTime

◆ mainThreadId

◆ mtxDeferredTasks

◆ mtxWorld

◆ pCameraManager

◆ pGameInstance

◆ pRenderer

◆ pWindow

◆ sGcLeakReasons

◆ threadPool

◆ timeSincePrevFrameInSec